[clang-repl] Harden the incremental processing infrastructure

clang/include/clang/Sema/Sema.h

public:
   bool resolveAssumedTemplateNameAsType(Scope *S, TemplateName &Name,
                                         SourceLocation NameLoc,
                                         bool Diagnose = true);
 
   /// Determine whether a particular identifier might be the name in a C++1z
   /// deduction-guide declaration.
   bool isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
                             SourceLocation NameLoc,
-                            ParsedTemplateTy *Template = nullptr);
+                            ParsedTemplateTy *Template = nullptr,
+                            bool AllowTypoCorrection = true);
 
   bool DiagnoseUnknownTemplateName(const IdentifierInfo &II,
                                    SourceLocation IILoc,
                                    Scope *S,
                                    const CXXScopeSpec *SS,
                                    TemplateTy &SuggestedTemplate,
                                    TemplateNameKind &SuggestedKind);
 

clang/lib/Parse/ParseTentative.cpp

 //===--- ParseTentative.cpp - Ambiguity Resolution Parsing ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements the tentative parsing portions of the Parser
 //  interfaces, for ambiguity resolution.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Parse/Parser.h"
 #include "clang/Parse/ParseDiagnostic.h"
+#include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/ParsedTemplate.h"
 using namespace clang;
 
 /// isCXXDeclarationStatement - C++-specialized function that disambiguates
 /// between a declaration or an expression statement, when parsing function
 /// bodies. Returns true for declaration, false for expression.
 ///
 ///         declaration-statement:
bool Parser::isCXXDeclarationStatement(
   case tok::kw_using:
     // static_assert-declaration
   case tok::kw_static_assert:
   case tok::kw__Static_assert:
     return true;
   case tok::identifier: {
     if (DisambiguatingWithExpression) {
       RevertingTentativeParsingAction TPA(*this);
+      ParsingDeclSpec PDS(*this);
       // Parse the C++ scope specifier.
       CXXScopeSpec SS;
       ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
                                      /*ObjectHasErrors=*/false,
                                      /*EnteringContext=*/true);
 
       switch (Tok.getKind()) {
       case tok::identifier: {
         IdentifierInfo *II = Tok.getIdentifierInfo();
         bool isDeductionGuide =
-            Actions.isDeductionGuideName(getCurScope(), *II, Tok.getLocation());
+          Actions.isDeductionGuideName(getCurScope(), *II, Tok.getLocation(),
+                                       /*Template=*/nullptr,
+                                       /*AllowTypoCorrection=*/false);
         if (Actions.isCurrentClassName(*II, getCurScope(), &SS) ||
             isDeductionGuide) {
           if (isConstructorDeclarator(/*Unqualified=*/SS.isEmpty(),
                                       isDeductionGuide,
                                       DeclSpec::FriendSpecified::No))
             return true;
         }
         break;
       }
       case tok::kw_operator:
         return true;
+      case tok::tilde: // Check if this is a dtor.
+        return true;
       case tok::annot_cxxscope: // Check if this is a dtor.
         if (NextToken().is(tok::tilde))
           return true;
         break;
       default:
         break;
       }
     }
if (Next.isNot(tok::coloncolon) && Next.isNot(tok::less)) {
       }
       assert(Tok.isNot(tok::identifier) &&
              "TryAnnotateName succeeded without producing an annotation");
     } else {
       // This might possibly be a type with a dependent scope specifier and
       // a missing 'typename' keyword. Don't use TryAnnotateName in this case,
       // since it will annotate as a primary expression, and we want to use the
       // "missing 'typename'" logic.
+      SuppressAccessChecks SAC(*this);
       if (TryAnnotateTypeOrScopeToken(AllowImplicitTypename))
         return TPResult::Error;
       // If annotation failed, assume it's a non-type.
       // FIXME: If this happens due to an undeclared identifier, treat it as
       // ambiguous.
       if (Tok.is(tok::identifier))
         return TPResult::False;
     }

clang/lib/Parse/Parser.cpp

if (PP.getMaxTokens() != 0 && PP.getTokenCount() > PP.getMaxTokens()) {
       SourceLocation OverrideLoc = PP.getMaxTokensOverrideLoc();
       if (OverrideLoc.isValid()) {
         PP.Diag(OverrideLoc, diag::note_max_tokens_total_override);
       }
     }
 
     // Late template parsing can begin.
     Actions.SetLateTemplateParser(LateTemplateParserCallback, nullptr, this);
-    if (!PP.isIncrementalProcessingEnabled())
-      Actions.ActOnEndOfTranslationUnit();
     //else don't tell Sema that we ended parsing: more input might come.
     return true;
 
   case tok::identifier:
     // C++2a [basic.link]p3:
     //   A token sequence beginning with 'export[opt] module' or
     //   'export[opt] import' and not immediately followed by '::'
     //   is never interpreted as the declaration of a top-level-declaration.

clang/lib/Sema/SemaTemplate.cpp

TemplateNameKind Sema::isTemplateName(Scope *S,
   }
 
   TemplateResult = TemplateTy::make(Template);
   return TemplateKind;
 }
 
 bool Sema::isDeductionGuideName(Scope *S, const IdentifierInfo &Name,
                                 SourceLocation NameLoc,
-                                ParsedTemplateTy *Template) {
+                                ParsedTemplateTy *Template, bool AllowTypoCorrection /*=true*/) {
   CXXScopeSpec SS;
   bool MemberOfUnknownSpecialization = false;
 
   // We could use redeclaration lookup here, but we don't need to: the
   // syntactic form of a deduction guide is enough to identify it even
   // if we can't look up the template name at all.
   LookupResult R(*this, DeclarationName(&Name), NameLoc, LookupOrdinaryName);
   if (LookupTemplateName(R, S, SS, /*ObjectType*/ QualType(),
                          /*EnteringContext*/ false,
-                         MemberOfUnknownSpecialization))
+                         MemberOfUnknownSpecialization,
+                         /*RequiredTemplate=*/SourceLocation(),
+                         /*ATK=*/nullptr, AllowTypoCorrection))
     return false;
 
   if (R.empty()) return false;
   if (R.isAmbiguous()) {
     // FIXME: Diagnose an ambiguity if we find at least one template.
     R.suppressDiagnostics();
     return false;
   }

clang/test/Interpreter/disambiguate-decl-stmt.cpp

 // REQUIRES: host-supports-jit
 // UNSUPPORTED: system-aix
 // RUN: cat %s | clang-repl -Xcc -std=c++20 -Xcc -Xclang -Xcc -verify | FileCheck %s
 // RUN: %clang_cc1 -fsyntax-only -verify -fincremental-extensions -std=c++20 %s
 
 // expected-no-diagnostics
 
 extern "C" int printf(const char*,...);
 
 // Decls which are hard to disambiguate
 
+// Typo correction.
+template <typename> struct _List_iterator;
+struct S4 { struct const_iterator {}; };
+class AddressRanges { using Collection = S4; Collection::const_iterator insert(); };
+AddressRanges::Collection::const_iterator AddressRanges::insert() { return {}; }
+
+// Access control.
+class C4 { using Int = int; public: Int get(); };
+C4::Int C4::get() { return {}; }
+
+class C2 { class U { U();}; };
+C2::U::U() {}
+
+struct S3 { ~S3(); };
+S3::~S3() {}
+
+
 // Operators.
 struct S1 { operator int(); };
 S1::operator int() { return 0; }
 
 // Dtors
 using I = int;
 I x = 10;
 x.I::~I();