Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/test/src/task/dart_test.dart

 // Copyright (c) 2015, 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 analyzer.test.src.task.dart_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
@@ skipping 15 matching lines @@
 import 'package:analyzer/task/dart.dart';
 import 'package:analyzer/task/general.dart';
 import 'package:analyzer/task/model.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../../generated/resolver_test_case.dart';
 import '../../generated/test_support.dart';
 import '../../utils.dart';
 import '../context/abstract_context.dart';
+import 'package:analyzer/dart/ast/resolution_accessors.dart';

[scheglov, 2016/12/05 17:10:50]

Not sorted.

[Paul Berry, 2016/12/05 17:50:48]

Fixed, thanks.

 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(BuildCompilationUnitElementTaskTest);
     defineReflectiveTests(BuildDirectiveElementsTaskTest);
     defineReflectiveTests(BuildEnumMemberElementsTaskTest);
     defineReflectiveTests(BuildExportNamespaceTaskTest);
     defineReflectiveTests(BuildLibraryElementTaskTest);
     defineReflectiveTests(BuildPublicNamespaceTaskTest);
     defineReflectiveTests(BuildSourceExportClosureTaskTest);
@@ skipping 133 matching lines @@
     CompilationUnitElement unitElement = outputs[COMPILATION_UNIT_ELEMENT];
     Annotation annotation = unit.declarations
         .firstWhere((m) => m is FunctionDeclaration)
         .metadata[0];
     List<ConstantEvaluationTarget> expectedConstants =
         <ConstantEvaluationTarget>[
       unitElement.accessors.firstWhere((e) => e.isGetter).variable,
       unitElement.types[0].fields[0],
       unitElement.functions[0].localVariables[0],
       unitElement.types[0].constructors[0],
-      annotation.elementAnnotation,
+      elementAnnotationForAnnotation(annotation),
       unitElement.types[0].constructors[0].parameters[0]
     ];
     expect(
         outputs[COMPILATION_UNIT_CONSTANTS].toSet(), expectedConstants.toSet());
   }
 
   test_perform_library() {
     _performBuildTask(r'''
 library lib;
 import 'lib2.dart';
@@ skipping 373 matching lines @@
         matcher: isBuildDirectiveElementsTask);
     // Get outputs
     LibraryElement libraryA =
         context.getCacheEntry(sourceA).getValue(LIBRARY_ELEMENT2);
     CompilationUnit part = context
         .getCacheEntry(new LibrarySpecificUnit(sourceA, sourcePart))
         .getValue(RESOLVED_UNIT1);
     // Validate metadata
     expect(part.directives[0], new isInstanceOf<PartOfDirective>());
     expect(part.directives[0].element, same(libraryA));
-    expect(part.directives[0].element.metadata, isEmpty);
+    expect(elementForDirective(part.directives[0]).metadata, isEmpty);
   }
 
   void _assertErrorsWithCodes(List<ErrorCode> expectedErrorCodes) {
     _fillErrorListener(BUILD_DIRECTIVES_ERRORS);
     errorListener.assertErrorsWithCodes(expectedErrorCodes);
   }
 
   _getExportLibraryInput(Source source) {
     var key = BuildDirectiveElementsTask.EXPORTS_LIBRARY_ELEMENT_INPUT_NAME;
     return task.inputs[key][source];
@@ skipping 25 matching lines @@
         '/test.dart',
         '''
 enum MyEnum {
   A, B
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT3,
         matcher: isBuildEnumMemberElementsTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT3];
     // validate Element
-    ClassElement enumElement = unit.element.getEnum('MyEnum');
+    ClassElement enumElement =
+        elementForCompilationUnit(unit).getEnum('MyEnum');
     List<FieldElement> fields = enumElement.fields;
     expect(fields, hasLength(4));
     {
       FieldElementImpl index = fields[0];
       expect(index, isNotNull);
       expect(index.name, 'index');
       expect(index.isStatic, isFalse);
       expect(index.evaluationResult, isNull);
       _assertGetter(index);
     }
@@ skipping 185 matching lines @@
     // LibraryElement references
     expect((libraryUnit.directives[0] as LibraryDirective).element,
         same(libraryElement));
     expect((partUnits[0].directives[0] as PartOfDirective).element,
         same(libraryElement));
     expect((partUnits[1].directives[0] as PartOfDirective).element,
         same(libraryElement));
     // CompilationUnitElement(s)
     CompilationUnitElement firstPart;
     CompilationUnitElement secondPart;
-    if (partUnits[0].element.uri == 'part1.dart') {
+    if (elementForCompilationUnit(partUnits[0]).uri == 'part1.dart') {
       firstPart = partUnits[0].element;
       secondPart = partUnits[1].element;
     } else {
       firstPart = partUnits[1].element;
       secondPart = partUnits[0].element;
     }
     expect(firstPart.uri, 'part1.dart');
     expect(firstPart.uriOffset, 18);
     expect(firstPart.uriEnd, 30);
     expect(
@@ skipping 147 matching lines @@
       '/part1.dart': '''
 part of lib;
 int get test => 0;
 ''',
       '/part2.dart': '''
 part of lib;
 void set test(_) {}
 '''
     });
     CompilationUnitElement unitElement1 = partUnits
-        .singleWhere((u) => u.element.name.endsWith('part1.dart'))
+        .singleWhere(
+            (u) => elementForCompilationUnit(u).name.endsWith('part1.dart'))
         .element;
     CompilationUnitElement unitElement2 = partUnits
-        .singleWhere((u) => u.element.name.endsWith('part2.dart'))
+        .singleWhere(
+            (u) => elementForCompilationUnit(u).name.endsWith('part2.dart'))
         .element;
     PropertyAccessorElement getter = unitElement1.accessors[0];
     PropertyAccessorElement setter = unitElement2.accessors[0];
     PropertyInducingElement variable = getter.variable;
     expect(getter.isGetter, isTrue);
     expect(setter.isSetter, isTrue);
     expect(variable, isNotNull);
     expect(setter.variable, same(variable));
     expect(unitElement1.topLevelVariables, [variable]);
     expect(unitElement2.topLevelVariables, [variable]);
@@ skipping 133 matching lines @@
 const x = 1;
 @D(x) class C {}
 class D { const D(value); }
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the elements for x and D's constructor, and the annotation on C.
-    List<PropertyAccessorElement> accessors = unit.element.accessors;
+    CompilationUnitElement compilationUnitElement =
+        elementForCompilationUnit(unit);
+    List<PropertyAccessorElement> accessors = compilationUnitElement.accessors;
     Element x = accessors
         .firstWhere((PropertyAccessorElement accessor) =>
             accessor.isGetter && accessor.name == 'x')
         .variable;
-    List<ClassElement> types = unit.element.types;
+    List<ClassElement> types = compilationUnitElement.types;
     Element constructorForD =
         types.firstWhere((ClassElement cls) => cls.name == 'D').constructors[0];
     Annotation annotation = findClassAnnotation(unit, 'C');
     // Now compute the dependencies for the annotation, and check that it is
     // the set [x, constructorForD].
     // TODO(paulberry): test librarySource != source
-    computeResult(annotation.elementAnnotation, CONSTANT_DEPENDENCIES,
+    computeResult(
+        elementAnnotationForAnnotation(annotation), CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(
         outputs[CONSTANT_DEPENDENCIES].toSet(), [x, constructorForD].toSet());
   }
 
   test_annotation_with_nonConstArg() {
     Source source = newSource(
         '/test.dart',
         '''
 class A {
   const A(x);
 }
 class C {
   @A(const [(_) => null])
   String s;
 }
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the annotation on the field.
     ClassDeclaration classC = unit.declarations[1];
     Annotation annotation = classC.members[0].metadata[0];
     // Now compute the dependencies for the annotation, and check that it is
     // the right size.
-    computeResult(annotation.elementAnnotation, CONSTANT_DEPENDENCIES,
+    computeResult(
+        elementAnnotationForAnnotation(annotation), CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(outputs[CONSTANT_DEPENDENCIES], hasLength(1));
   }
 
   test_annotation_without_args() {
     Source source = newSource(
         '/test.dart',
         '''
 const x = 1;
 @x class C {}
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the element for x and the annotation on C.
-    List<PropertyAccessorElement> accessors = unit.element.accessors;
+    List<PropertyAccessorElement> accessors =
+        elementForCompilationUnit(unit).accessors;
     Element x = accessors
         .firstWhere((PropertyAccessorElement accessor) =>
             accessor.isGetter && accessor.name == 'x')
         .variable;
     Annotation annotation = findClassAnnotation(unit, 'C');
     // Now compute the dependencies for the annotation, and check that it is
     // the list [x].
-    computeResult(annotation.elementAnnotation, CONSTANT_DEPENDENCIES,
+    computeResult(
+        elementAnnotationForAnnotation(annotation), CONSTANT_DEPENDENCIES,
         matcher: isComputeConstantDependenciesTask);
     expect(outputs[CONSTANT_DEPENDENCIES], [x]);
   }
 
   test_enumConstant() {
     Source source = newSource(
         '/test.dart',
         '''
 enum E {A, B, C}
 ''');
@@ skipping 19 matching lines @@
         '''
 const x = y;
 const y = 1;
 ''');
     // First compute the resolved unit for the source.
     LibrarySpecificUnit librarySpecificUnit =
         new LibrarySpecificUnit(source, source);
     computeResult(librarySpecificUnit, RESOLVED_UNIT1);
     CompilationUnit unit = outputs[RESOLVED_UNIT1];
     // Find the elements for the constants x and y.
-    List<PropertyAccessorElement> accessors = unit.element.accessors;
+    List<PropertyAccessorElement> accessors =
+        elementForCompilationUnit(unit).accessors;
     Element x = accessors
         .firstWhere((PropertyAccessorElement accessor) =>
             accessor.isGetter && accessor.name == 'x')
         .variable;
     Element y = accessors
         .firstWhere((PropertyAccessorElement accessor) =>
             accessor.isGetter && accessor.name == 'y')
         .variable;
     // Now compute the dependencies for x, and check that it is the list [y].
     computeResult(x, CONSTANT_DEPENDENCIES,
@@ skipping 255 matching lines @@
   test_perform() {
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 const a = b;
 const b = 0;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT7);
     CompilationUnit unit = outputs[RESOLVED_UNIT7];
-    TopLevelVariableElement elementA = unit.element.topLevelVariables[0];
-    TopLevelVariableElement elementB = unit.element.topLevelVariables[1];
+    TopLevelVariableElement elementA =
+        elementForCompilationUnit(unit).topLevelVariables[0];
+    TopLevelVariableElement elementB =
+        elementForCompilationUnit(unit).topLevelVariables[1];
 
     computeResult(elementA, INFERABLE_STATIC_VARIABLE_DEPENDENCIES,
         matcher: isComputeInferableStaticVariableDependenciesTask);
     expect(outputs, hasLength(1));
     List<VariableElement> dependencies = outputs[
         INFERABLE_STATIC_VARIABLE_DEPENDENCIES] as List<VariableElement>;
     expect(dependencies, unorderedEquals([elementB]));
   }
 }
 
@@ skipping 1117 matching lines @@
 }
 class X {}
 class Y {}
 class Z {}
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT10,
         matcher: isInferInstanceMembersInUnitTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT10];
     VariableDeclaration field = AstFinder.getFieldInClass(unit, 'B', 'f');
     MethodDeclaration method = AstFinder.getMethodInClass(unit, 'B', 'm');
-    DartType typeX = AstFinder.getClass(unit, 'X').element.type;
-    DartType typeY = AstFinder.getClass(unit, 'Y').element.type;
-    DartType typeZ = AstFinder.getClass(unit, 'Z').element.type;
+    DartType typeX =
+        elementForClassDeclaration(AstFinder.getClass(unit, 'X')).type;
+    DartType typeY =
+        elementForClassDeclaration(AstFinder.getClass(unit, 'Y')).type;
+    DartType typeZ =
+        elementForClassDeclaration(AstFinder.getClass(unit, 'Z')).type;
 
-    expect(field.element.type, typeX);
-    expect(method.element.returnType, typeY);
-    expect(method.element.parameters[0].type, typeZ);
+    expect(elementForVariableDeclaration(field).type, typeX);
+    expect(elementForMethodDeclaration(method).returnType, typeY);
+    expect(elementForMethodDeclaration(method).parameters[0].type, typeZ);
   }
 
   void test_perform_cross_library_const() {
     enableStrongMode();
     AnalysisTarget firstSource = newSource(
         '/first.dart',
         '''
 library first;
 
 const a = 'hello';
@@ skipping 17 matching lines @@
     CompilationUnit secondUnit = outputs[RESOLVED_UNIT10];
 
     VariableDeclaration variableA =
         AstFinder.getTopLevelVariable(firstUnit, 'a');
     VariableDeclaration variableB =
         AstFinder.getTopLevelVariable(secondUnit, 'b');
     VariableDeclaration variableC =
         AstFinder.getFieldInClass(secondUnit, 'M', 'c');
     InterfaceType stringType = context.typeProvider.stringType;
 
-    expect(variableA.element.type, stringType);
-    expect(variableB.element.type, stringType);
+    expect(elementForVariableDeclaration(variableA).type, stringType);
+    expect(elementForVariableDeclaration(variableB).type, stringType);
     expect(variableB.initializer.staticType, stringType);
-    expect(variableC.element.type, stringType);
+    expect(elementForVariableDeclaration(variableC).type, stringType);
     expect(variableC.initializer.staticType, stringType);
   }
 
   void test_perform_reresolution() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 const topLevel = '';
 class C {
@@ skipping 44 matching lines @@
         '''
 class M {
   static const X = "";
 }
 ''');
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT8,
         matcher: isInferStaticVariableTypesInUnitTask);
     CompilationUnit unit = outputs[RESOLVED_UNIT8];
     VariableDeclaration declaration = AstFinder.getFieldInClass(unit, 'M', 'X');
     InterfaceType stringType = context.typeProvider.stringType;
-    expect(declaration.element.type, stringType);
+    expect(elementForVariableDeclaration(declaration).type, stringType);
   }
 
   test_perform_hasParseError() {
     Source source = newSource(
         '/test.dart',
         r'''
 @(i $=
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT8);
@@ skipping 42 matching lines @@
         new LibrarySpecificUnit(secondSource, secondSource), RESOLVED_UNIT8);
     CompilationUnit secondUnit = outputs[RESOLVED_UNIT8];
 
     VariableDeclaration variableA =
         AstFinder.getTopLevelVariable(firstUnit, 'a');
     VariableDeclaration variableB =
         AstFinder.getTopLevelVariable(secondUnit, 'b');
     VariableDeclaration variableC =
         AstFinder.getTopLevelVariable(firstUnit, 'c');
     ClassDeclaration classM = AstFinder.getClass(secondUnit, 'M');
-    DartType typeM = classM.element.type;
+    DartType typeM = elementForClassDeclaration(classM).type;
 
-    expect(variableA.element.type, typeM);
-    expect(variableB.element.type, typeM);
+    expect(elementForVariableDeclaration(variableA).type, typeM);
+    expect(elementForVariableDeclaration(variableB).type, typeM);
     expect(variableB.initializer.staticType, typeM);
-    expect(variableC.element.type, typeM);
+    expect(elementForVariableDeclaration(variableC).type, typeM);
     expect(variableC.initializer.staticType, typeM);
   }
 
   void test_perform_simple() {
     enableStrongMode();
     AnalysisTarget source = newSource(
         '/test.dart',
         '''
 var X = 1;
 
@@ skipping 1621 matching lines @@
     _assertTypeParameterBound(
         nodeF.typeParameters.typeParameters[0], 'String', 'String');
   }
 
   void _assertTypeParameterBound(TypeParameter typeParameter,
       String expectedBoundTypeString, String expectedBoundElementName) {
     TypeName boundNode = typeParameter.bound;
     Identifier boundName = boundNode.name;
     expect(boundNode.type.toString(), expectedBoundTypeString);
     expect(boundName.staticType.toString(), expectedBoundTypeString);
-    expect(boundName.staticElement.displayName, expectedBoundElementName);
+    expect(staticElementForIdentifier(boundName).displayName,
+        expectedBoundElementName);
   }
 }
 
 @reflectiveTest
 class ResolveUnitTaskTest extends _AbstractDartTaskTest {
   test_created_resolved_unit() {
     Source source = newSource(
         '/test.dart',
         r'''
 library lib;
@@ skipping 63 matching lines @@
 int f(String p) => p.length;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5, matcher: isResolveUnitTypeNamesTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     {
       ClassDeclaration nodeA = unit.declarations[0];
       ClassDeclaration nodeB = unit.declarations[1];
       DartType extendsType = nodeB.extendsClause.superclass.type;
-      expect(extendsType, nodeA.element.type);
+      expect(extendsType, elementForClassDeclaration(nodeA).type);
     }
     {
       FunctionDeclaration functionNode = unit.declarations[2];
       DartType returnType = functionNode.returnType.type;
       List<FormalParameter> parameters =
           functionNode.functionExpression.parameters.parameters;
       expect(returnType.displayName, 'int');
-      expect(parameters[0].element.type.displayName, 'String');
+      expect(
+          elementForFormalParameter(parameters[0]).type.displayName, 'String');
     }
   }
 
   test_perform_errors() {
     Source source = newSource(
         '/test.dart',
         '''
 NoSuchClass f() => null;
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
@@ skipping 13 matching lines @@
 typedef String G(int p);
 ''');
     LibrarySpecificUnit target = new LibrarySpecificUnit(source, source);
     computeResult(target, RESOLVED_UNIT5, matcher: isResolveUnitTypeNamesTask);
     // validate
     CompilationUnit unit = outputs[RESOLVED_UNIT5];
     FunctionTypeAlias nodeF = unit.declarations[0];
     FunctionTypeAlias nodeG = unit.declarations[1];
     {
       FormalParameter parameter = nodeF.parameters.parameters[0];
-      DartType parameterType = parameter.element.type;
-      Element returnTypeElement = nodeF.returnType.type.element;
+      DartType parameterType = elementForFormalParameter(parameter).type;
+      Element returnTypeElement = typeForTypeName(nodeF.returnType).element;
       expect(returnTypeElement.displayName, 'int');
       expect(parameterType.element, nodeG.element);
     }
     {
       FormalParameter parameter = nodeG.parameters.parameters[0];
-      DartType parameterType = parameter.element.type;
-      expect(nodeG.returnType.type.element.displayName, 'String');
+      DartType parameterType = elementForFormalParameter(parameter).type;
+      expect(typeForTypeName(nodeG.returnType).element.displayName, 'String');
       expect(parameterType.element.displayName, 'int');
     }
   }
 
   test_perform_typedef_errors() {
     Source source = newSource(
         '/test.dart',
         '''
 typedef int F(NoSuchType p);
 ''');
@@ skipping 650 matching lines @@
     computeResult(new LibrarySpecificUnit(source, source), RESOLVED_UNIT11);
     CompilationUnit unit = outputs[RESOLVED_UNIT11];
 
     InterfaceType intType = context.typeProvider.intType;
     InterfaceType stringType = context.typeProvider.stringType;
 
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "test");
     VariableDeclaration decl =
         (statements[0] as VariableDeclarationStatement).variables.variables[0];
-    expect(decl.element.type, intType);
+    expect(elementForVariableDeclaration(decl).type, intType);
     expect(decl.initializer.staticType, intType);
 
     ExpressionStatement statement = statements[1];
     AssignmentExpression assgn = statement.expression;
     expect(assgn.leftHandSide.staticType, intType);
     expect(assgn.rightHandSide.staticType, stringType);
   }
 }
 
 @reflectiveTest
@@ skipping 267 matching lines @@
 
   void assertVariableDeclarationStatementTypes(
       Statement stmt, DartType varType, DartType initializerType) {
     VariableDeclaration decl =
         (stmt as VariableDeclarationStatement).variables.variables[0];
     assertVariableDeclarationTypes(decl, varType, initializerType);
   }
 
   void assertVariableDeclarationTypes(
       VariableDeclaration decl, DartType varType, DartType initializerType) {
-    expect(decl.element.type, varType);
+    expect(elementForVariableDeclaration(decl).type, varType);
     expect(decl.initializer.staticType, initializerType);
   }
 
   List<dynamic> computeLibraryResults(
       List<Source> sources, ResultDescriptor result,
       {isInstanceOf matcher: null}) {
     dynamic compute(Source source) {
       computeResult(new LibrarySpecificUnit(source, source), result,
           matcher: matcher);
       return outputs[result];
@@ skipping 60 matching lines @@
   /**
    * Fill [errorListener] with [result] errors in the current [task].
    */
   void _fillErrorListener(ResultDescriptor<List<AnalysisError>> result) {
     List<AnalysisError> errors = task.outputs[result] as List<AnalysisError>;
     expect(errors, isNotNull, reason: result.name);
     errorListener = new GatheringErrorListener();
     errorListener.addAll(errors);
   }
 }