Extend resolution Scope with ResolutionContext and set it for ResolverVisitor.

pkg/analyzer/test/generated/incremental_resolver_test.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_test;
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/error.dart';
@@ skipping 10 matching lines @@
 import '../reflective_tests.dart';
 import 'parser_test.dart';
 import 'resolver_test.dart';
 import 'test_support.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(IncrementalResolverTest);
-  runReflectiveTests(ScopeBuilderTest);
+  runReflectiveTests(ResolutionContextBuilderTest);
 }
 
 
 class DeclarationMatcherTest extends ResolverTestCase {
   void fail_test_methodDeclarationMatches_false_localVariable() {
     // TODO(scheglov) as I understand DeclarationMatcher, we care only
     // about externally visible model changes. So, because we analyze (at least
     // right now) incremental changes on method level, local variable can be
     // ignored.
     _assertMethodMatches(false, r'''
@@ skipping 1051 matching lines @@
   void fail_test_constructor_fieldInitializer_add() {
     // TODO(scheglov) resolver uses "enclosingClass", which we don't set yet
     _resolveUnit(r'''
 class A {
   int f;
   A(int a, int b);
 }''');
     _resolve(_editString(');', ') : f = a + b;'), _isClassMember);
   }
 
-  void fail_test_constructor_fieldInitializer_edit() {
-    // TODO(scheglov) resolver uses "enclosingClass", which we don't set yet
-    _resolveUnit(r'''
-class A {
-  int f;
-  A(int a, int b) : f = a + b {
-    int a = 42;
-  }
-}''');
-    _resolve(_editString('+', '*'), _isExpression);
-  }
-
   void fail_test_topLevelFunction_parameter_rename() {
     // TODO(scheglov) Decide if incremental parser keeps the element
     // of the function. If so, we can resolve parameter renames.
     _resolveUnit(r'''
 int main(int a, int b) {
   return a + b;
 }
 ''');
     _resolve(_editString(r'''(int a, int b) {
   return a + b;''', r'''(int first, int b) {
   return first + b;'''), _isDeclaration);
   }
 
   void test_constructor_body() {
     _resolveUnit(r'''
 class A {
   int f;
   A(int a, int b) {
     f = a + b;
   }
 }''');
     _resolve(_editString('+', '*'), _isFunctionBody);
   }
 
+  void test_constructor_fieldInitializer_edit() {
+    // TODO(scheglov) resolver uses "enclosingClass", which we don't set yet
+    _resolveUnit(r'''
+class A {
+  int f;
+  A(int a, int b) : f = a + b {
+    int a = 42;
+  }
+}''');
+    _resolve(_editString('+', '*'), _isExpression);
+  }
+
   void test_constructor_superConstructorInvocation() {
     _resolveUnit(r'''
 class A {
   A(int p);
 }
 class A {
   A(int a, int b) : super(a + b);
 }
 ''');
     _resolve(_editString('+', '*'), _isExpression);
@@ skipping 206 matching lines @@
     var errorListener = new BooleanErrorListener();
     var reader = new CharSequenceReader(code);
     var scanner = new Scanner(null, reader, errorListener);
     var token = scanner.tokenize();
     var parser = new Parser(null, errorListener);
     return parser.parseCompilationUnit(token);
   }
 }
 
 
-class ScopeBuilderTest extends EngineTestCase {
+class ResolutionContextBuilderTest extends EngineTestCase {
+  GatheringErrorListener listener = new GatheringErrorListener();
+
   void test_scopeFor_ClassDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedClassDeclaration(), listener);
+    Scope scope = _scopeFor(_createResolvedClassDeclaration());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryScope,
         LibraryScope,
         scope);
   }
 
   void test_scopeFor_ClassTypeAlias() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedClassTypeAlias(), listener);
+    Scope scope = _scopeFor(_createResolvedClassTypeAlias());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryScope,
         LibraryScope,
         scope);
   }
 
   void test_scopeFor_CompilationUnit() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedCompilationUnit(), listener);
+    Scope scope = _scopeFor(_createResolvedCompilationUnit());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryScope,
         LibraryScope,
         scope);
   }
 
   void test_scopeFor_ConstructorDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedConstructorDeclaration(), listener);
+    Scope scope = _scopeFor(_createResolvedConstructorDeclaration());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassScope,
         ClassScope,
         scope);
   }
 
   void test_scopeFor_ConstructorDeclaration_parameters() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope = ScopeBuilder.scopeFor(
-        _createResolvedConstructorDeclaration().parameters,
-        listener);
+    Scope scope = _scopeFor(_createResolvedConstructorDeclaration().parameters);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionScope,
         FunctionScope,
         scope);
   }
 
   void test_scopeFor_FunctionDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedFunctionDeclaration(), listener);
+    Scope scope = _scopeFor(_createResolvedFunctionDeclaration());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryScope,
         LibraryScope,
         scope);
   }
 
   void test_scopeFor_FunctionDeclaration_parameters() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope = ScopeBuilder.scopeFor(
-        _createResolvedFunctionDeclaration().functionExpression.parameters,
-        listener);
+    Scope scope =
+        _scopeFor(_createResolvedFunctionDeclaration().functionExpression.parameters);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionScope,
         FunctionScope,
         scope);
   }
 
   void test_scopeFor_FunctionTypeAlias() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedFunctionTypeAlias(), listener);
+    Scope scope = _scopeFor(_createResolvedFunctionTypeAlias());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is LibraryScope,
         LibraryScope,
         scope);
   }
 
   void test_scopeFor_FunctionTypeAlias_parameters() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedFunctionTypeAlias().parameters, listener);
+    Scope scope = _scopeFor(_createResolvedFunctionTypeAlias().parameters);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionTypeScope,
         FunctionTypeScope,
         scope);
   }
 
   void test_scopeFor_MethodDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedMethodDeclaration(), listener);
+    Scope scope = _scopeFor(_createResolvedMethodDeclaration());
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassScope,
         ClassScope,
         scope);
   }
 
   void test_scopeFor_MethodDeclaration_body() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedMethodDeclaration().body, listener);
+    Scope scope = _scopeFor(_createResolvedMethodDeclaration().body);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is FunctionScope,
         FunctionScope,
         scope);
   }
 
   void test_scopeFor_notInCompilationUnit() {
-    GatheringErrorListener listener = new GatheringErrorListener();
     try {
-      ScopeBuilder.scopeFor(AstFactory.identifier3("x"), listener);
+      _scopeFor(AstFactory.identifier3("x"));
       fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   void test_scopeFor_null() {
-    GatheringErrorListener listener = new GatheringErrorListener();
     try {
-      ScopeBuilder.scopeFor(null, listener);
+      _scopeFor(null);
       fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   void test_scopeFor_unresolved() {
-    GatheringErrorListener listener = new GatheringErrorListener();
     try {
-      ScopeBuilder.scopeFor(AstFactory.compilationUnit(), listener);
+      _scopeFor(AstFactory.compilationUnit());
       fail("Expected AnalysisException");
     } on AnalysisException catch (exception) {
       // Expected
     }
   }
 
   ClassDeclaration _createResolvedClassDeclaration() {
     CompilationUnit unit = _createResolvedCompilationUnit();
     String className = "C";
     ClassDeclaration classNode = AstFactory.classDeclaration(
@@ skipping 99 matching lines @@
         AstFactory.identifier3(methodName),
         AstFactory.formalParameterList());
     classNode.members.add(methodNode);
     MethodElement methodElement =
         ElementFactory.methodElement(methodName, null);
     methodNode.name.staticElement = methodElement;
     (classNode.element as ClassElementImpl).methods =
         <MethodElement>[methodElement];
     return methodNode;
   }
+
+  Scope _scopeFor(AstNode node) {
+    return ResolutionContextBuilder.contextFor(node, listener).scope;
+  }
 }
 
 
 class _Edit {
   final int offset;
   final int length;
   final String replacement;
   _Edit(this.offset, this.length, this.replacement);
 }
 
@@ skipping 808 matching lines @@
     _visitList(node.metadata, other.metadata);
     _visitNode(node.identifier, other.identifier);
   }
 
   static void assertSameResolution(CompilationUnit actual,
       CompilationUnit expected) {
     _SameResolutionValidator validator = new _SameResolutionValidator(expected);
     actual.accept(validator);
   }
 }