Extract incremental resolver classes into separate files.

pkg/analyzer/test/generated/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.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 10 matching lines @@
 import 'package:analyzer/src/generated/sdk.dart';
 import 'package:analyzer/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:analyzer/src/generated/static_type_analyzer.dart';
 import 'package:analyzer/src/generated/testing/ast_factory.dart';
 import 'package:analyzer/src/generated/testing/element_factory.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:unittest/unittest.dart';
 
 import '../reflective_tests.dart';
-import 'parser_test.dart';
 import 'test_support.dart';
 
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisDeltaTest);
   runReflectiveTests(ChangeSetTest);
   runReflectiveTests(EnclosedScopeTest);
   runReflectiveTests(LibraryImportScopeTest);
   runReflectiveTests(LibraryScopeTest);
-  runReflectiveTests(ScopeBuilderTest);
   runReflectiveTests(ScopeTest);
-  runReflectiveTests(DeclarationMatcherTest);
   runReflectiveTests(ElementResolverTest);
-  runReflectiveTests(IncrementalResolverTest);
   runReflectiveTests(InheritanceManagerTest);
   runReflectiveTests(LibraryElementBuilderTest);
   runReflectiveTests(LibraryResolver2Test);
   runReflectiveTests(LibraryResolverTest);
   runReflectiveTests(LibraryTest);
   runReflectiveTests(StaticTypeAnalyzerTest);
   runReflectiveTests(StaticTypeAnalyzer2Test);
   runReflectiveTests(SubtypeManagerTest);
   runReflectiveTests(TypeOverrideManagerTest);
   runReflectiveTests(TypeProviderImplTest);
@@ skipping 1077 matching lines @@
     resolve(source);
     assertErrors(
         source,
         [
             CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH,
             StaticWarningCode.UNDEFINED_CLASS]);
     verify([source]);
   }
 }
 
-class DeclarationMatcherTest extends ResolverTestCase {
-  void test_compilationUnitMatches_false_topLevelVariable() {
-    _assertCompilationUnitMatches(false, r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''', r'''
-const int ZERO = 0;
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''');
-  }
-
-  void test_compilationUnitMatches_true_different() {
-    _assertCompilationUnitMatches(true, r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''', r'''
-class C {
-  int m(int p) {
-    return (p * p) + (p * p);
-  }
-}''');
-  }
-
-  void test_compilationUnitMatches_true_same() {
-    String content = r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''';
-    _assertCompilationUnitMatches(true, content, content);
-  }
-
-  void test_methodDeclarationMatches_false_localVariable() {
-    _assertMethodMatches(false, r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''', r'''
-class C {
-  int m(int p) {
-    int product = p * p;
-    return product + product;
-  }
-}''');
-  }
-
-  void test_methodDeclarationMatches_false_parameter() {
-    _assertMethodMatches(false, r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''', r'''
-class C {
-  int m(int p, int q) {
-    return (p * q) + (q * p);
-  }
-}''');
-  }
-
-  void test_methodDeclarationMatches_true_different() {
-    _assertMethodMatches(true, r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''', r'''
-class C {
-  int m(int p) {
-    return (p * p) + (p * p);
-  }
-}''');
-  }
-
-  void test_methodDeclarationMatches_true_same() {
-    String content = r'''
-class C {
-  int m(int p) {
-    return p + p;
-  }
-}''';
-    _assertMethodMatches(true, content, content);
-  }
-
-  void _assertCompilationUnitMatches(bool expectMatch, String oldContent,
-      String newContent) {
-    Source source = addSource(oldContent);
-    LibraryElement library = resolve(source);
-    CompilationUnit oldUnit = resolveCompilationUnit(source, library);
-    CompilationUnit newUnit = ParserTestCase.parseCompilationUnit(newContent);
-    DeclarationMatcher matcher = new DeclarationMatcher();
-    expect(matcher.matches(newUnit, oldUnit.element), expectMatch);
-  }
-
-  void _assertMethodMatches(bool expectMatch, String oldContent,
-      String newContent) {
-    Source source = addSource(oldContent);
-    LibraryElement library = resolve(source);
-    CompilationUnit oldUnit = resolveCompilationUnit(source, library);
-    MethodElement element = _getFirstMethod(oldUnit).element as MethodElement;
-    AnalysisContext context = analysisContext;
-    context.setContents(source, newContent);
-    CompilationUnit newUnit = context.parseCompilationUnit(source);
-    MethodDeclaration newMethod = _getFirstMethod(newUnit);
-    DeclarationMatcher matcher = new DeclarationMatcher();
-    expect(matcher.matches(newMethod, element), expectMatch);
-  }
-
-  MethodDeclaration _getFirstMethod(CompilationUnit unit) {
-    ClassDeclaration classNode = unit.declarations[0] as ClassDeclaration;
-    return classNode.members[0] as MethodDeclaration;
-  }
-}
-
 class ElementResolverTest extends EngineTestCase {
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
@@ skipping 3215 matching lines @@
   }
 }''');
     resolve(source);
     assertErrors(
         source,
         [HintCode.USE_OF_VOID_RESULT, HintCode.USE_OF_VOID_RESULT]);
     verify([source]);
   }
 }
 
-class IncrementalResolverTest extends ResolverTestCase {
-  void test_resolve() {
-    MethodDeclaration method = _resolveMethod(r'''
-class C {
-  int m(int a) {
-    return a + a;
-  }
-}''');
-    BlockFunctionBody body = method.body as BlockFunctionBody;
-    ReturnStatement statement = body.block.statements[0] as ReturnStatement;
-    BinaryExpression expression = statement.expression as BinaryExpression;
-    SimpleIdentifier left = expression.leftOperand as SimpleIdentifier;
-    Element leftElement = left.staticElement;
-    SimpleIdentifier right = expression.rightOperand as SimpleIdentifier;
-    Element rightElement = right.staticElement;
-    expect(leftElement, isNotNull);
-    expect(rightElement, same(leftElement));
-  }
-
-  MethodDeclaration _resolveMethod(String content) {
-    Source source = addSource(content);
-    LibraryElement library = resolve(source);
-    CompilationUnit unit = resolveCompilationUnit(source, library);
-    ClassDeclaration classNode = unit.declarations[0] as ClassDeclaration;
-    MethodDeclaration method = classNode.members[0] as MethodDeclaration;
-    method.body.accept(new ResolutionEraser());
-    GatheringErrorListener errorListener = new GatheringErrorListener();
-    IncrementalResolver resolver =
-        new IncrementalResolver(library, source, typeProvider, errorListener);
-    resolver.resolve(method.body);
-    return method;
-  }
-}
-
 class InheritanceManagerTest extends EngineTestCase {
   /**
    * The type provider used to access the types.
    */
   TestTypeProvider _typeProvider;
 
   /**
    * The library containing the code being resolved.
    */
   LibraryElementImpl _definingLibrary;
@@ skipping 3497 matching lines @@
 
   @override
   AnalysisErrorListener get errorListener => listener;
 
   @override
   Element internalLookup(Identifier identifier, String name,
       LibraryElement referencingLibrary) =>
       null;
 }
 
-class ScopeBuilderTest extends EngineTestCase {
-  void test_scopeFor_ClassDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedClassDeclaration(), listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryScope,
-        LibraryScope,
-        scope);
-  }
-
-  void test_scopeFor_ClassTypeAlias() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedClassTypeAlias(), listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryScope,
-        LibraryScope,
-        scope);
-  }
-
-  void test_scopeFor_CompilationUnit() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedCompilationUnit(), listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryScope,
-        LibraryScope,
-        scope);
-  }
-
-  void test_scopeFor_ConstructorDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedConstructorDeclaration(), listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassScope,
-        ClassScope,
-        scope);
-  }
-
-  void test_scopeFor_ConstructorDeclaration_parameters() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope = ScopeBuilder.scopeFor(
-        _createResolvedConstructorDeclaration().parameters,
-        listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionScope,
-        FunctionScope,
-        scope);
-  }
-
-  void test_scopeFor_FunctionDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedFunctionDeclaration(), listener);
-    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);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionScope,
-        FunctionScope,
-        scope);
-  }
-
-  void test_scopeFor_FunctionTypeAlias() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedFunctionTypeAlias(), listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is LibraryScope,
-        LibraryScope,
-        scope);
-  }
-
-  void test_scopeFor_FunctionTypeAlias_parameters() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedFunctionTypeAlias().parameters, listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionTypeScope,
-        FunctionTypeScope,
-        scope);
-  }
-
-  void test_scopeFor_MethodDeclaration() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedMethodDeclaration(), listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is ClassScope,
-        ClassScope,
-        scope);
-  }
-
-  void test_scopeFor_MethodDeclaration_body() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    Scope scope =
-        ScopeBuilder.scopeFor(_createResolvedMethodDeclaration().body, listener);
-    EngineTestCase.assertInstanceOf(
-        (obj) => obj is FunctionScope,
-        FunctionScope,
-        scope);
-  }
-
-  void test_scopeFor_notInCompilationUnit() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    try {
-      ScopeBuilder.scopeFor(AstFactory.identifier3("x"), listener);
-      fail("Expected AnalysisException");
-    } on AnalysisException catch (exception) {
-      // Expected
-    }
-  }
-
-  void test_scopeFor_null() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    try {
-      ScopeBuilder.scopeFor(null, listener);
-      fail("Expected AnalysisException");
-    } on AnalysisException catch (exception) {
-      // Expected
-    }
-  }
-
-  void test_scopeFor_unresolved() {
-    GatheringErrorListener listener = new GatheringErrorListener();
-    try {
-      ScopeBuilder.scopeFor(AstFactory.compilationUnit(), listener);
-      fail("Expected AnalysisException");
-    } on AnalysisException catch (exception) {
-      // Expected
-    }
-  }
-
-  ClassDeclaration _createResolvedClassDeclaration() {
-    CompilationUnit unit = _createResolvedCompilationUnit();
-    String className = "C";
-    ClassDeclaration classNode = AstFactory.classDeclaration(
-        null,
-        className,
-        AstFactory.typeParameterList(),
-        null,
-        null,
-        null);
-    unit.declarations.add(classNode);
-    ClassElement classElement = ElementFactory.classElement2(className);
-    classNode.name.staticElement = classElement;
-    (unit.element as CompilationUnitElementImpl).types =
-        <ClassElement>[classElement];
-    return classNode;
-  }
-
-  ClassTypeAlias _createResolvedClassTypeAlias() {
-    CompilationUnit unit = _createResolvedCompilationUnit();
-    String className = "C";
-    ClassTypeAlias classNode = AstFactory.classTypeAlias(
-        className,
-        AstFactory.typeParameterList(),
-        null,
-        null,
-        null,
-        null);
-    unit.declarations.add(classNode);
-    ClassElement classElement = ElementFactory.classElement2(className);
-    classNode.name.staticElement = classElement;
-    (unit.element as CompilationUnitElementImpl).types =
-        <ClassElement>[classElement];
-    return classNode;
-  }
-
-  CompilationUnit _createResolvedCompilationUnit() {
-    CompilationUnit unit = AstFactory.compilationUnit();
-    LibraryElementImpl library =
-        ElementFactory.library(AnalysisContextFactory.contextWithCore(), "lib");
-    unit.element = library.definingCompilationUnit;
-    return unit;
-  }
-
-  ConstructorDeclaration _createResolvedConstructorDeclaration() {
-    ClassDeclaration classNode = _createResolvedClassDeclaration();
-    String constructorName = "f";
-    ConstructorDeclaration constructorNode = AstFactory.constructorDeclaration(
-        AstFactory.identifier3(constructorName),
-        null,
-        AstFactory.formalParameterList(),
-        null);
-    classNode.members.add(constructorNode);
-    ConstructorElement constructorElement =
-        ElementFactory.constructorElement2(classNode.element, null);
-    constructorNode.element = constructorElement;
-    (classNode.element as ClassElementImpl).constructors =
-        <ConstructorElement>[constructorElement];
-    return constructorNode;
-  }
-
-  FunctionDeclaration _createResolvedFunctionDeclaration() {
-    CompilationUnit unit = _createResolvedCompilationUnit();
-    String functionName = "f";
-    FunctionDeclaration functionNode = AstFactory.functionDeclaration(
-        null,
-        null,
-        functionName,
-        AstFactory.functionExpression());
-    unit.declarations.add(functionNode);
-    FunctionElement functionElement =
-        ElementFactory.functionElement(functionName);
-    functionNode.name.staticElement = functionElement;
-    (unit.element as CompilationUnitElementImpl).functions =
-        <FunctionElement>[functionElement];
-    return functionNode;
-  }
-
-  FunctionTypeAlias _createResolvedFunctionTypeAlias() {
-    CompilationUnit unit = _createResolvedCompilationUnit();
-    FunctionTypeAlias aliasNode = AstFactory.typeAlias(
-        AstFactory.typeName4("A"),
-        "F",
-        AstFactory.typeParameterList(),
-        AstFactory.formalParameterList());
-    unit.declarations.add(aliasNode);
-    SimpleIdentifier aliasName = aliasNode.name;
-    FunctionTypeAliasElement aliasElement =
-        new FunctionTypeAliasElementImpl.forNode(aliasName);
-    aliasName.staticElement = aliasElement;
-    (unit.element as CompilationUnitElementImpl).typeAliases =
-        <FunctionTypeAliasElement>[aliasElement];
-    return aliasNode;
-  }
-
-  MethodDeclaration _createResolvedMethodDeclaration() {
-    ClassDeclaration classNode = _createResolvedClassDeclaration();
-    String methodName = "f";
-    MethodDeclaration methodNode = AstFactory.methodDeclaration(
-        null,
-        null,
-        null,
-        null,
-        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;
-  }
-}
-
 class ScopeTest extends ResolverTestCase {
   void test_define_duplicate() {
     GatheringErrorListener errorListener = new GatheringErrorListener();
     ScopeTest_TestScope scope = new ScopeTest_TestScope(errorListener);
     VariableElement element1 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     VariableElement element2 =
         ElementFactory.localVariableElement(AstFactory.identifier3("v1"));
     scope.define(element1);
     scope.define(element2);
@@ skipping 5523 matching lines @@
         // check propagated type
         FunctionType propagatedType = node.propagatedType as FunctionType;
         expect(propagatedType.returnType, test.typeProvider.stringType);
       } on AnalysisException catch (e, stackTrace) {
         thrownException[0] = new CaughtException(e, stackTrace);
       }
     }
     return null;
   }
 }