Extend resolution Scope with ResolutionContext and set it for ResolverVisitor.

pkg/analyzer/lib/src/generated/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.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'ast.dart';
@@ skipping 10998 matching lines @@
    * The object used to resolve the element associated with the current node.
    */
   ElementResolver _elementResolver;
 
   /**
    * The object used to compute the type associated with the current node.
    */
   StaticTypeAnalyzer _typeAnalyzer;
 
   /**
-   * The class element representing the class containing the current node, or `null` if the
-   * current node is not contained in a class.
+   * The class element representing the class containing the current node,
+   * or `null` if the current node is not contained in a class.
    */
-  ClassElement _enclosingClass = null;
+  ClassElement enclosingClass = null;
 
   /**
    * The class declaration representing the class containing the current node, or `null` if
    * the current node is not contained in a class.
    */
   ClassDeclaration _enclosingClassDeclaration = null;
 
   /**
    * The function type alias representing the function type containing the current node, or
    * `null` if the current node is not contained in a function type alias.
@@ skipping 92 matching lines @@
     this._inheritanceManager = library.inheritanceManager;
     this._elementResolver = new ElementResolver(this);
     this._typeAnalyzer = new StaticTypeAnalyzer(this);
   }
 
   get elementResolver_J2DAccessor => _elementResolver;
 
   set elementResolver_J2DAccessor(__v) => _elementResolver = __v;
 
   /**
-   * Return the class element representing the class containing the current node, or `null` if
-   * the current node is not contained in a class.
-   *
-   * @return the class element representing the class containing the current node
-   */
-  ClassElement get enclosingClass => _enclosingClass;
-
-  get enclosingClass_J2DAccessor => _enclosingClass;
-
-  set enclosingClass_J2DAccessor(__v) => _enclosingClass = __v;
-
-  /**
    * Return the element representing the function containing the current node, or `null` if
    * the current node is not contained in a function.
    *
    * @return the element representing the function containing the current node
    */
   ExecutableElement get enclosingFunction => _enclosingFunction;
 
   get labelScope_J2DAccessor => _labelScope;
 
   set labelScope_J2DAccessor(__v) => _labelScope = __v;
@@ skipping 269 matching lines @@
     //
     // Resolve the metadata in the library scope.
     //
     if (node.metadata != null) {
       node.metadata.accept(this);
     }
     _enclosingClassDeclaration = node;
     //
     // Continue the class resolution.
     //
-    ClassElement outerType = _enclosingClass;
+    ClassElement outerType = enclosingClass;
     try {
-      _enclosingClass = node.element;
+      enclosingClass = node.element;
       _typeAnalyzer.thisType =
-          _enclosingClass == null ? null : _enclosingClass.type;
+          enclosingClass == null ? null : enclosingClass.type;
       super.visitClassDeclaration(node);
       node.accept(_elementResolver);
       node.accept(_typeAnalyzer);
     } finally {
       _typeAnalyzer.thisType = outerType == null ? null : outerType.type;
-      _enclosingClass = outerType;
+      enclosingClass = outerType;
       _enclosingClassDeclaration = null;
     }
     return null;
   }
 
   @override
   Object visitComment(Comment node) {
     if (node.parent is FunctionDeclaration ||
         node.parent is ConstructorDeclaration ||
         node.parent is MethodDeclaration) {
@@ skipping 1173 matching lines @@
   /**
    * The scope used to resolve labels for `break` and `continue` statements, or
    * `null` if no labels have been defined in the current context.
    */
   LabelScope _labelScope;
 
   /**
    * The class containing the AST nodes being visited,
    * or `null` if we are not in the scope of a class.
    */
-  ClassElement _enclosingClass;
+  ClassElement enclosingClass;
 
   /**
    * Initialize a newly created visitor to resolve the nodes in a compilation unit.
    *
    * @param library the library containing the compilation unit being resolved
    * @param source the source representing the compilation unit being visited
    * @param typeProvider the object used to access the types from the core library
    */
   ScopedVisitor.con1(Library library, this.source, this.typeProvider) {
     this._definingLibrary = library.libraryElement;
@@ skipping 190 matching lines @@
   Object visitClassDeclaration(ClassDeclaration node) {
     ClassElement classElement = node.element;
     Scope outerScope = _nameScope;
     try {
       if (classElement == null) {
         AnalysisEngine.instance.logger.logInformation(
             "Missing element for class declaration ${node.name.name} in ${definingLibrary.source.fullName}",
             new CaughtException(new AnalysisException(), null));
         super.visitClassDeclaration(node);
       } else {
-        ClassElement outerClass = _enclosingClass;
+        ClassElement outerClass = enclosingClass;
         try {
-          _enclosingClass = node.element;
+          enclosingClass = node.element;
           _nameScope = new TypeParameterScope(_nameScope, classElement);
           visitClassDeclarationInScope(node);
           _nameScope = new ClassScope(_nameScope, classElement);
           visitClassMembersInScope(node);
         } finally {
-          _enclosingClass = outerClass;
+          enclosingClass = outerClass;
         }
       }
     } finally {
       _nameScope = outerScope;
     }
     return null;
   }
 
   void visitClassDeclarationInScope(ClassDeclaration node) {
     safelyVisit(node.name);
@@ skipping 3352 matching lines @@
    * library.
    */
   final HashSet<String> members = new HashSet<String>();
 
   /**
    * Names of resolved or unresolved class members that are read in the
    * library.
    */
   final HashSet<String> readMembers = new HashSet<String>();
 }