Move ParseScope and friends into Sema

Author: Sirraide

clang/include/clang/Parse/Parser.h

@@ -210,10 +210,6 @@ class Parser : public CodeCompletionHandler {
   const Token &getCurToken() const { return Tok; }
   Scope *getCurScope() const { return Actions.getCurScope(); }
 
-  void incrementMSManglingNumber() const {
-    return Actions.incrementMSManglingNumber();
-  }
-
   // Type forwarding.  All of these are statically 'void*', but they may all be
   // different actual classes based on the actions in place.
   typedef OpaquePtr<DeclGroupRef> DeclGroupPtrTy;
@@ -384,78 +380,6 @@ class Parser : public CodeCompletionHandler {
     return MightBeCXXScopeToken() && TryAnnotateCXXScopeToken(EnteringContext);
   }
 
-  //===--------------------------------------------------------------------===//
-  // Scope manipulation
-
-  /// ParseScope - Introduces a new scope for parsing. The kind of
-  /// scope is determined by ScopeFlags. Objects of this type should
-  /// be created on the stack to coincide with the position where the
-  /// parser enters the new scope, and this object's constructor will
-  /// create that new scope. Similarly, once the object is destroyed
-  /// the parser will exit the scope.
-  class ParseScope {
-    Parser *Self;
-    ParseScope(const ParseScope &) = delete;
-    void operator=(const ParseScope &) = delete;
-
-  public:
-    // ParseScope - Construct a new object to manage a scope in the
-    // parser Self where the new Scope is created with the flags
-    // ScopeFlags, but only when we aren't about to enter a compound statement.
-    ParseScope(Parser *Self, unsigned ScopeFlags, bool EnteredScope = true,
-               bool BeforeCompoundStmt = false)
-        : Self(Self) {
-      if (EnteredScope && !BeforeCompoundStmt)
-        Self->EnterScope(ScopeFlags);
-      else {
-        if (BeforeCompoundStmt)
-          Self->incrementMSManglingNumber();
-
-        this->Self = nullptr;
-      }
-    }
-
-    // Exit - Exit the scope associated with this object now, rather
-    // than waiting until the object is destroyed.
-    void Exit() {
-      if (Self) {
-        Self->ExitScope();
-        Self = nullptr;
-      }
-    }
-
-    ~ParseScope() { Exit(); }
-  };
-
-  /// Introduces zero or more scopes for parsing. The scopes will all be exited
-  /// when the object is destroyed.
-  class MultiParseScope {
-    Parser &Self;
-    unsigned NumScopes = 0;
-
-    MultiParseScope(const MultiParseScope &) = delete;
-
-  public:
-    MultiParseScope(Parser &Self) : Self(Self) {}
-    void Enter(unsigned ScopeFlags) {
-      Self.EnterScope(ScopeFlags);
-      ++NumScopes;
-    }
-    void Exit() {
-      while (NumScopes) {
-        Self.ExitScope();
-        --NumScopes;
-      }
-    }
-    ~MultiParseScope() { Exit(); }
-  };
-
-  /// EnterScope - Start a new scope.
-  void EnterScope(unsigned ScopeFlags);
-
-  /// ExitScope - Pop a scope off the scope stack.
-  void ExitScope();
-
   //===--------------------------------------------------------------------===//
   // Diagnostic Emission and Error recovery.
 
@@ -546,11 +470,6 @@ class Parser : public CodeCompletionHandler {
 
   StackExhaustionHandler StackHandler;
 
-  /// ScopeCache - Cache scopes to reduce malloc traffic.
-  static constexpr int ScopeCacheSize = 16;
-  unsigned NumCachedScopes;
-  Scope *ScopeCache[ScopeCacheSize];
-
   /// Identifiers used for SEH handling in Borland. These are only
   /// allowed in particular circumstances
   // __except block
@@ -2532,7 +2451,7 @@ class Parser : public CodeCompletionHandler {
       assert(SS.isSet() && "C++ scope was not set!");
 
       CreatedScope = true;
-      P.EnterScope(0); // Not a decl scope.
+      P.Actions.EnterScope(0); // Not a decl scope.
 
       if (!P.Actions.ActOnCXXEnterDeclaratorScope(P.getCurScope(), SS))
         EnteredScope = true;
@@ -2544,7 +2463,7 @@ class Parser : public CodeCompletionHandler {
         P.Actions.ActOnCXXExitDeclaratorScope(P.getCurScope(), SS);
       }
       if (CreatedScope)
-        P.ExitScope();
+        P.Actions.ExitScope();
     }
   };
 

clang/include/clang/Sema/Scope.h

@@ -29,11 +29,11 @@ class raw_ostream;
 } // namespace llvm
 
 namespace clang {
-
 class Decl;
 class DeclContext;
 class UsingDirectiveDecl;
 class VarDecl;
+class Sema;
 
 /// Scope - A scope is a transient data structure that is used while parsing the
 /// program.  It assists with resolving identifiers to the appropriate
@@ -667,6 +667,45 @@ class Scope {
   void dump() const;
 };
 
+/// ParseScope - Introduces a new scope for parsing. The kind of
+/// scope is determined by ScopeFlags. Objects of this type should
+/// be created on the stack to coincide with the position where the
+/// parser enters the new scope, and this object's constructor will
+/// create that new scope. Similarly, once the object is destroyed
+/// the parser will exit the scope.
+class ParseScope {
+  Sema *S;
+  ParseScope(const ParseScope &) = delete;
+  void operator=(const ParseScope &) = delete;
+
+public:
+  // ParseScope - Construct a new object to manage a scope in the
+  // parser Self where the new Scope is created with the flags
+  // ScopeFlags, but only when we aren't about to enter a compound statement.
+  ParseScope(Sema &S, unsigned ScopeFlags, bool EnteredScope = true,
+             bool BeforeCompoundStmt = false);
+
+  // Exit - Exit the scope associated with this object now, rather
+  // than waiting until the object is destroyed.
+  void Exit();
+
+  ~ParseScope() { Exit(); }
+};
+
+/// Introduces zero or more scopes for parsing. The scopes will all be exited
+/// when the object is destroyed.
+class MultiParseScope {
+  Sema &S;
+  unsigned NumScopes = 0;
+
+  MultiParseScope(const MultiParseScope &) = delete;
+
+public:
+  MultiParseScope(Sema &S) : S(S) {}
+  void Enter(unsigned ScopeFlags);
+  void Exit();
+  ~MultiParseScope() { Exit(); }
+};
 } // namespace clang
 
 #endif // LLVM_CLANG_SEMA_SCOPE_H

clang/include/clang/Sema/Sema.h

@@ -1200,6 +1200,15 @@ class Sema final : public SemaBase {
   /// Scope actions.
   void ActOnTranslationUnitScope(Scope *S);
 
+  /// EnterScope - Start a new scope.
+  void EnterScope(unsigned ScopeFlags);
+
+  /// ExitScope - Pop a scope off the scope stack.
+  void ExitScope();
+
+  /// Delete the scope stack and all cached scopes.
+  void FreeScopes();
+
   /// Determine whether \param D is function like (function or function
   /// template) for parsing.
   bool isDeclaratorFunctionLike(Declarator &D);
@@ -1575,10 +1584,12 @@ class Sema final : public SemaBase {
   sema::SemaPPCallbacks *SemaPPCallbackHandler;
 
   /// The parser's current scope.
-  ///
-  /// The parser maintains this state here.
   Scope *CurScope;
 
+  /// ScopeCache - Cache scopes to reduce malloc traffic.
+  static constexpr unsigned MaxScopeCacheSize = 16;
+  SmallVector<std::unique_ptr<Scope>, MaxScopeCacheSize> ScopeCache;
+
   mutable IdentifierInfo *Ident_super;
 
   std::unique_ptr<SemaAMDGPU> AMDGPUPtr;
@@ -4218,7 +4229,7 @@ class Sema final : public SemaBase {
   TopLevelStmtDecl *ActOnStartTopLevelStmtDecl(Scope *S);
   void ActOnFinishTopLevelStmtDecl(TopLevelStmtDecl *D, Stmt *Statement);
 
-  void ActOnPopScope(SourceLocation Loc, Scope *S);
+  void ActOnPopScope(Scope *S);
 
   /// ParsedFreeStandingDeclSpec - This method is invoked when a declspec with
   /// no declarator (e.g. "struct foo;") is parsed.

clang/lib/Interpreter/IncrementalParser.cpp

@@ -63,10 +63,10 @@ IncrementalParser::ParseOrWrapTopLevelDecl() {
     P->ConsumeAnyToken();
     // FIXME: Clang does not call ExitScope on finalizing the regular TU, we
     // might want to do that around HandleEndOfTranslationUnit.
-    P->ExitScope();
+    S.ExitScope();
     S.CurContext = nullptr;
     // Start a new PTU.
-    P->EnterScope(Scope::DeclScope);
+    S.EnterScope(Scope::DeclScope);
     S.ActOnTranslationUnitScope(P->getCurScope());
   }
 

clang/lib/Parse/ParseCXXInlineMethods.cpp

@@ -328,7 +328,8 @@ struct Parser::ReenterTemplateScopeRAII {
   TemplateParameterDepthRAII CurTemplateDepthTracker;
 
   ReenterTemplateScopeRAII(Parser &P, Decl *MaybeTemplated, bool Enter = true)
-      : P(P), Scopes(P), CurTemplateDepthTracker(P.TemplateParameterDepth) {
+      : P(P), Scopes(P.Actions),
+        CurTemplateDepthTracker(P.TemplateParameterDepth) {
     if (Enter) {
       CurTemplateDepthTracker.addDepth(
           P.ReenterTemplateScopes(Scopes, MaybeTemplated));
@@ -510,7 +511,7 @@ void Parser::ParseLexedMethodDeclaration(LateParsedMethodDeclaration &LM) {
     // };
     // Setup the CurScope to match the function DeclContext - we have such
     // assumption in IsInFnTryBlockHandler().
-    ParseScope FnScope(this, Scope::FnScope);
+    ParseScope FnScope(Actions, Scope::FnScope);
     Sema::ContextRAII FnContext(Actions, FunctionToPush,
                                 /*NewThisContext=*/false);
     Sema::FunctionScopeRAII PopFnContext(Actions);
@@ -597,8 +598,8 @@ void Parser::ParseLexedMethodDef(LexedMethod &LM) {
 
   // Parse the method body. Function body parsing code is similar enough
   // to be re-used for method bodies as well.
-  ParseScope FnScope(this, Scope::FnScope | Scope::DeclScope |
-                               Scope::CompoundStmtScope);
+  ParseScope FnScope(Actions, Scope::FnScope | Scope::DeclScope |
+                                  Scope::CompoundStmtScope);
   Sema::FPFeaturesStateRAII SaveFPFeatures(Actions);
 
   Actions.ActOnStartOfFunctionDef(getCurScope(), LM.D);

clang/lib/Parse/ParseDecl.cpp

@@ -677,9 +677,9 @@ void Parser::ParseGNUAttributeArgs(
   if (normalizeAttrName(AttrName->getName()) == "enable_if" &&
       D && D->isFunctionDeclarator()) {
     const DeclaratorChunk::FunctionTypeInfo& FTI = D->getFunctionTypeInfo();
-    PrototypeScope.emplace(this, Scope::FunctionPrototypeScope |
-                                     Scope::FunctionDeclarationScope |
-                                     Scope::DeclScope);
+    PrototypeScope.emplace(Actions, Scope::FunctionPrototypeScope |
+                                        Scope::FunctionDeclarationScope |
+                                        Scope::DeclScope);
     for (unsigned i = 0; i != FTI.NumParams; ++i) {
       ParmVarDecl *Param = cast<ParmVarDecl>(FTI.Params[i].Param);
       Actions.ActOnReenterCXXMethodParameter(getCurScope(), Param);
@@ -2454,7 +2454,7 @@ Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
       if (ThisDecl && P.getLangOpts().CPlusPlus) {
         Scope *S = nullptr;
         if (D.getCXXScopeSpec().isSet()) {
-          P.EnterScope(0);
+          P.Actions.EnterScope(0);
           S = P.getCurScope();
         }
         if (ThisDecl && !ThisDecl->isInvalidDecl()) {
@@ -2472,7 +2472,7 @@ Decl *Parser::ParseDeclarationAfterDeclaratorAndAttributes(
         if (Entered)
           P.Actions.ActOnCXXExitDeclInitializer(S, ThisDecl);
         if (S)
-          P.ExitScope();
+          P.Actions.ExitScope();
       }
       ThisDecl = nullptr;
     }
@@ -4826,7 +4826,7 @@ void Parser::ParseStructUnionBody(SourceLocation RecordLoc,
   if (T.consumeOpen())
     return;
 
-  ParseScope StructScope(this, Scope::ClassScope|Scope::DeclScope);
+  ParseScope StructScope(Actions, Scope::ClassScope|Scope::DeclScope);
   Actions.ActOnTagStartDefinition(getCurScope(), TagDecl);
 
   // `LateAttrParseExperimentalExtOnly=true` requests that only attributes
@@ -5338,7 +5338,7 @@ void Parser::ParseEnumSpecifier(SourceLocation StartLoc, DeclSpec &DS,
 void Parser::ParseEnumBody(SourceLocation StartLoc, Decl *EnumDecl,
                            SkipBodyInfo *SkipBody) {
   // Enter the scope of the enum body and start the definition.
-  ParseScope EnumScope(this, Scope::DeclScope | Scope::EnumScope);
+  ParseScope EnumScope(Actions, Scope::DeclScope | Scope::EnumScope);
   Actions.ActOnTagStartDefinition(getCurScope(), EnumDecl);
 
   BalancedDelimiterTracker T(*this, tok::l_brace);
@@ -5681,8 +5681,8 @@ Parser::DeclGroupPtrTy Parser::ParseTopLevelStmtDecl() {
   // Parse a top-level-stmt.
   Parser::StmtVector Stmts;
   ParsedStmtContext SubStmtCtx = ParsedStmtContext();
-  ParseScope FnScope(this, Scope::FnScope | Scope::DeclScope |
-                               Scope::CompoundStmtScope);
+  ParseScope FnScope(Actions, Scope::FnScope | Scope::DeclScope |
+                                  Scope::CompoundStmtScope);
   TopLevelStmtDecl *TLSD = Actions.ActOnStartTopLevelStmtDecl(getCurScope());
   StmtResult R = ParseStatementOrDeclaration(Stmts, SubStmtCtx);
   Actions.ActOnFinishTopLevelStmtDecl(TLSD, R.get());
@@ -6804,9 +6804,9 @@ void Parser::ParseDirectDeclarator(Declarator &D) {
       // Enter function-declaration scope, limiting any declarators to the
       // function prototype scope, including parameter declarators.
       ParseScope PrototypeScope(
-          this, Scope::FunctionPrototypeScope | Scope::DeclScope |
-                    (IsFunctionDeclaration ? Scope::FunctionDeclarationScope
-                                           : Scope::NoScope));
+          Actions, Scope::FunctionPrototypeScope | Scope::DeclScope |
+                       (IsFunctionDeclaration ? Scope::FunctionDeclarationScope
+                                              : Scope::NoScope));
 
       // The paren may be part of a C++ direct initializer, eg. "int x(1);".
       // In such a case, check if we actually have a function declarator; if it
@@ -7085,7 +7085,7 @@ void Parser::ParseParenDeclarator(Declarator &D) {
 
   // Enter function-declaration scope, limiting any declarators to the
   // function prototype scope, including parameter declarators.
-  ParseScope PrototypeScope(this,
+  ParseScope PrototypeScope(Actions,
                             Scope::FunctionPrototypeScope | Scope::DeclScope |
                                 (D.isFunctionDeclaratorAFunctionDeclaration()
                                      ? Scope::FunctionDeclarationScope
@@ -8126,7 +8126,7 @@ TypeResult Parser::ParseTypeFromString(StringRef TypeStr, StringRef Context,
   ConsumeAnyToken();
 
   // Enter a new scope.
-  ParseScope LocalScope(this, 0);
+  ParseScope LocalScope(Actions, 0);
 
   // Parse the type.
   TypeResult Result = ParseTypeName(nullptr);