Extend resolution Scope with ResolutionContext and set it for ResolverVisitor.

pkg/analyzer/lib/src/generated/incremental_resolver.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library engine.incremental_resolver;
 
 import 'dart:collection';
 
 import 'ast.dart';
 import 'element.dart';
@@ skipping 19 matching lines @@
    */
   CompilationUnitElement _enclosingUnit;
 
   /**
    * The function type alias containing the AST nodes being visited, or `null` if we are not
    * in the scope of a function type alias.
    */
   FunctionTypeAliasElement _enclosingAlias;
 
   /**
-   * The class containing the AST nodes being visited, or `null` if we are not in the scope of
-   * a class.
+   * The class containing the AST nodes being visited, or `null` if we are not
+   * in the scope of a class.
    */
   ClassElement _enclosingClass;
 
   /**
    * The parameter containing the AST nodes being visited, or `null` if we are not in the
    * scope of a parameter.
    */
   ParameterElement _enclosingParameter;
 
   FieldDeclaration _enclosingFieldNode = null;
@@ skipping 597 matching lines @@
       this._definingLibrary, this._definingUnit, this._source, this._updateOffset,
       this._updateOldLength, this._updateNewLength);
 
   /**
    * Resolve [node], reporting any errors or warnings to the given listener.
    *
    * [node] - the root of the AST structure to be resolved.
    */
   void resolve(AstNode node) {
     AstNode rootNode = _findResolutionRoot(node);
-    if (_elementModelChanged(rootNode)) {
-      throw new AnalysisException("Cannot resolve node: element model changed");
-    }
     // update elements
     _definingUnit.accept(
         new _ElementNameOffsetUpdater(
             _updateOffset,
             _updateNewLength - _updateOldLength));
     _updateElements(rootNode);
+    if (_elementModelChanged(rootNode)) {
+      throw new AnalysisException("Cannot resolve node: element model changed");
+    }
     // resolve root in scope
-    Scope scope = ScopeBuilder.scopeFor(rootNode, _errorListener);
+    ResolutionContext context =
+        ResolutionContextBuilder.contextFor(rootNode, _errorListener);
+    Scope scope = context.scope;
     _resolveTypes(rootNode, scope);
     _resolveVariables(rootNode, scope);
-    _resolveReferences(rootNode, scope);
+    _resolveReferences(rootNode, context);
   }
 
   /**
    * Return `true` if the given node can be resolved independently of any other
    * nodes.
    *
    * *Note*: This method needs to be kept in sync with
-   * [ScopeBuilder.scopeForAstNode].
+   * [ScopeBuilder.ContextBuilder].
    *
    * [node] - the node being tested.
    */
   bool _canBeResolved(AstNode node) =>
       node is ClassDeclaration ||
           node is ClassTypeAlias ||
           node is CompilationUnit ||
           node is ConstructorDeclaration ||
           node is FunctionDeclaration ||
           node is FunctionTypeAlias ||
@@ skipping 42 matching lines @@
    */
   Element _getElement(AstNode node) {
     if (node is Declaration) {
       return node.element;
     } else if (node is CompilationUnit) {
       return node.element;
     }
     return null;
   }
 
-  void _resolveReferences(AstNode node, Scope scope) {
+  void _resolveReferences(AstNode node, ResolutionContext context) {
     ResolverVisitor visitor = new ResolverVisitor.con3(
         _definingLibrary,
         _source,
         _typeProvider,
-        scope,
+        context.scope,
         _errorListener);
+    visitor.enclosingClass = context.enclosingClass;
     node.accept(visitor);
   }
 
   void _resolveTypes(AstNode node, Scope scope) {
     TypeResolverVisitor visitor = new TypeResolverVisitor.con3(
         _definingLibrary,
         _source,
         _typeProvider,
         scope,
         _errorListener);
@@ skipping 32 matching lines @@
       MethodElementImpl oldElement = node.element;
       MethodElementImpl newElement = holder.methods[0];
       oldElement.labels = newElement.labels;
       oldElement.localVariables = newElement.localVariables;
     }
   }
 }
 
 
 /**
- * Instances of the class [ScopeBuilder] build the scope for a given node in an
- * AST structure. At the moment, this class only handles top-level and
- * class-level declarations.
+ * The context to resolve an [AstNode] in.
  */
-class ScopeBuilder {
+class ResolutionContext {
+  ClassElement enclosingClass;
+  Scope scope;
+}
+
+
+/**
+ * Instances of the class [ResolutionContextBuilder] build the context for a
+ * given node in an AST structure. At the moment, this class only handles
+ * top-level and class-level declarations.
+ */
+class ResolutionContextBuilder {
   /**
    * The listener to which analysis errors will be reported.
    */
   final AnalysisErrorListener _errorListener;
 
   /**
-   * Initialize a newly created scope builder to generate a scope that will report errors to the
-   * given listener.
-   *
-   * @param errorListener the listener to which analysis errors will be reported
+   * The class containing the AST nodes being visited, or `null` if we are not
+   * in the scope of a class.
    */
-  ScopeBuilder(this._errorListener);
+  ClassElement _enclosingClass;
+
+  /**
+   * Initialize a newly created scope builder to generate a scope that will
+   * report errors to the given listener.
+   */
+  ResolutionContextBuilder(this._errorListener);
+
+  Scope _scopeFor(AstNode node) {
+    if (node is CompilationUnit) {
+      return _scopeForAstNode(node);
+    }
+    AstNode parent = node.parent;
+    if (parent == null) {
+      throw new AnalysisException(
+          "Cannot create scope: node is not part of a CompilationUnit");
+    }
+    return _scopeForAstNode(parent);
+  }
 
   /**
    * Return the scope in which the given AST structure should be resolved.
    *
-   * <b>Note:</b> This method needs to be kept in sync with
+   * *Note:* This method needs to be kept in sync with
    * [IncrementalResolver.canBeResolved].
    *
-   * @param node the root of the AST structure to be resolved
-   * @return the scope in which the given AST structure should be resolved
-   * @throws AnalysisException if the AST structure has not been resolved or is not part of a
-   *           [CompilationUnit]
+   * [node] - the root of the AST structure to be resolved.
+   *
+   * Throws [AnalysisException] if the AST structure has not been resolved or
+   * is not part of a [CompilationUnit]
    */
   Scope _scopeForAstNode(AstNode node) {
     if (node is CompilationUnit) {
       return _scopeForCompilationUnit(node);
     }
     AstNode parent = node.parent;
     if (parent == null) {
       throw new AnalysisException(
           "Cannot create scope: node is not part of a CompilationUnit");
     }
     Scope scope = _scopeForAstNode(parent);
     if (node is ClassDeclaration) {
-      ClassElement element = node.element;
-      if (element == null) {
+      _enclosingClass = node.element;
+      if (_enclosingClass == null) {
         throw new AnalysisException(
             "Cannot build a scope for an unresolved class");
       }
-      scope = new ClassScope(new TypeParameterScope(scope, element), element);
+      scope = new ClassScope(
+          new TypeParameterScope(scope, _enclosingClass),
+          _enclosingClass);
     } else if (node is ClassTypeAlias) {
       ClassElement element = node.element;
       if (element == null) {
         throw new AnalysisException(
             "Cannot build a scope for an unresolved class type alias");
       }
       scope = new ClassScope(new TypeParameterScope(scope, element), element);
     } else if (node is ConstructorDeclaration) {
       ConstructorElement element = node.element;
       if (element == null) {
@@ skipping 35 matching lines @@
     }
     LibraryElement libraryElement = unitElement.library;
     if (libraryElement == null) {
       throw new AnalysisException(
           "Cannot create scope: compilation unit is not part of a library");
     }
     return new LibraryScope(libraryElement, _errorListener);
   }
 
   /**
-   * Return the scope in which the given AST structure should be resolved.
+   * Return the context in which the given AST structure should be resolved.
    *
-   * @param node the root of the AST structure to be resolved
-   * @param errorListener the listener to which analysis errors will be reported
-   * @return the scope in which the given AST structure should be resolved
-   * @throws AnalysisException if the AST structure has not been resolved or is not part of a
-   *           [CompilationUnit]
+   * [node] - the root of the AST structure to be resolved.
+   * [errorListener] - the listener to which analysis errors will be reported.
+   *
+   * Throws [AnalysisException] if the AST structure has not been resolved or
+   * is not part of a [CompilationUnit]
    */
-  static Scope scopeFor(AstNode node, AnalysisErrorListener errorListener) {
+  static ResolutionContext contextFor(AstNode node,
+      AnalysisErrorListener errorListener) {
     if (node == null) {
-      throw new AnalysisException("Cannot create scope: node is null");
-    } else if (node is CompilationUnit) {
-      ScopeBuilder builder = new ScopeBuilder(errorListener);
-      return builder._scopeForAstNode(node);
+      throw new AnalysisException("Cannot create context: node is null");
     }
-    AstNode parent = node.parent;
-    if (parent == null) {
-      throw new AnalysisException(
-          "Cannot create scope: node is not part of a CompilationUnit");
-    }
-    ScopeBuilder builder = new ScopeBuilder(errorListener);
-    return builder._scopeForAstNode(parent);
+    // build scope
+    ResolutionContextBuilder builder =
+        new ResolutionContextBuilder(errorListener);
+    Scope scope = builder._scopeFor(node);
+    // prepare context
+    ResolutionContext context = new ResolutionContext();
+    context.scope = scope;
+    context.enclosingClass = builder._enclosingClass;
+    return context;
   }
 }
 
 
 /**
  * Instances of the class [_DeclarationMismatchException] represent an exception
  * that is thrown when the element model defined by a given AST structure does
  * not match an existing element model.
  */
 class _DeclarationMismatchException {
@@ skipping 108 matching lines @@
   visitFunctionExpression(FunctionExpression node) {
     _elements[node] = node.element;
     super.visitFunctionExpression(node);
   }
 
   @override
   visitSimpleIdentifier(SimpleIdentifier node) {
     _elements[node] = node.staticElement;
   }
 }