Prepare for decoupling analyzer ASTs from element model.

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 analyzer.test.generated.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/resolution_accessors.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/dart/element/builder.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ skipping 452 matching lines @@
       if (invalidlyPropagatedExpressionCount > 0) {
         buffer.writeln("Incorrectly propagated ");
         buffer.write(invalidlyPropagatedExpressionCount);
         buffer.write(" of ");
         buffer.write(_propagatedExpressionCount);
         buffer.writeln(" expressions:");
         for (Expression expression in _invalidlyPropagatedExpressions) {
           buffer.write("  ");
           buffer.write(expression.toString());
           buffer.write(" [");
-          buffer.write(expression.staticType.displayName);
+          buffer.write(staticTypeForExpression(expression).displayName);
           buffer.write(", ");
-          buffer.write(expression.propagatedType.displayName);
+          buffer.write(propagatedTypeForExpression(expression).displayName);
           buffer.writeln("]");
           buffer.write("    ");
           buffer.write(_getFileName(expression));
           buffer.write(" : ");
           buffer.write(expression.offset);
           buffer.writeln(")");
         }
       }
       fail(buffer.toString());
     }
@@ skipping 36 matching lines @@
   @override
   Object visitLabel(Label node) => null;
 
   @override
   Object visitLibraryIdentifier(LibraryIdentifier node) => null;
 
   @override
   Object visitPrefixedIdentifier(PrefixedIdentifier node) {
     // In cases where we have a prefixed identifier where the prefix is dynamic,
     // we don't want to assert that the node will have a type.
-    if (node.staticType == null && node.prefix.staticType.isDynamic) {
+    if (node.staticType == null && staticTypeForExpression(node.prefix).isDynamic) {
       return null;
     }
     return super.visitPrefixedIdentifier(node);
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     // In cases where identifiers are being used for something other than an
     // expressions, then they can be ignored.
     AstNode parent = node.parent;
@@ skipping 30 matching lines @@
   }
 
   String _getFileName(AstNode node) {
     // TODO (jwren) there are two copies of this method, one here and one in
     // ResolutionVerifier, they should be resolved into a single method
     if (node != null) {
       AstNode root = node.root;
       if (root is CompilationUnit) {
         CompilationUnit rootCU = root;
         if (rootCU.element != null) {
-          return rootCU.element.source.fullName;
+          return elementForCompilationUnit(rootCU).source.fullName;
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
   }
 }
@@ skipping 475 matching lines @@
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_assert() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   assert (p is A);
   return p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_assignment() {
     Source source = addSource(r'''
@@ skipping 74 matching lines @@
 main(CanvasElement canvas) {
   var context = canvas.getContext('2d');
 }''';
     Source source = addSource(code);
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     SimpleIdentifier identifier = EngineTestCase.findNode(
         unit, code, "context", (node) => node is SimpleIdentifier);
-    expect(identifier.propagatedType.name, "CanvasRenderingContext2D");
+    expect(propagatedTypeForExpression(identifier).name, "CanvasRenderingContext2D");
   }
 
   void test_forEach() {
     String code = r'''
 main() {
   var list = <String> [];
   for (var e in list) {
     e;
   }
 }''';
@@ skipping 432 matching lines @@
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is A) ? p : null;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
         conditional.thenExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     // prepare A
     InterfaceType typeA;
     {
       ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-      typeA = classA.element.type;
+      typeA = elementForClassDeclaration(classA).type;
     }
     // verify "f"
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     // "p is A"
     {
       IsExpression isExpression = ifStatement.condition;
       SimpleIdentifier variableName = isExpression.expression;
@@ skipping 42 matching lines @@
     return p;
   } else {
     return null;
   }
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.thenStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is A) ? p : throw null;
   return p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is A) {
     A a = p;
   } else {
     return null;
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_is_subclass() {
     Source source = addSource(r'''
@@ skipping 28 matching lines @@
   while (p is A) {
     return p;
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     WhileStatement whileStatement = body.block.statements[0] as WhileStatement;
     ReturnStatement statement =
         (whileStatement.body as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_conditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   return (p is! A) ? null : p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[0] as ReturnStatement;
     ConditionalExpression conditional =
         statement.expression as ConditionalExpression;
     SimpleIdentifier variableName =
         conditional.elseExpression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_if() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   } else {
     return p;
   }
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_if_logicalOr() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A || null == p) {
     return null;
   } else {
     return p;
   }
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     IfStatement ifStatement = body.block.statements[0] as IfStatement;
     ReturnStatement statement =
         (ifStatement.elseStatement as Block).statements[0] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_postConditional() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   A a = (p is! A) ? throw null : p;
   return p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_isNot_postIf() {
     Source source = addSource(r'''
 class A {}
 A f(var p) {
   if (p is! A) {
     return null;
   }
   return p;
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
-    InterfaceType typeA = classA.element.type;
+    InterfaceType typeA = elementForClassDeclaration(classA).type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
     BlockFunctionBody body =
         function.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[1] as ReturnStatement;
     SimpleIdentifier variableName = statement.expression as SimpleIdentifier;
     expect(variableName.propagatedType, same(typeA));
   }
 
   void test_issue20904BuggyTypePromotionAtIfJoin_5() {
     // https://code.google.com/p/dart/issues/detail?id=20904
@@ skipping 429 matching lines @@
 }''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     FunctionDeclaration main = unit.declarations[0] as FunctionDeclaration;
     BlockFunctionBody body = main.functionExpression.body as BlockFunctionBody;
     ReturnStatement statement = body.block.statements[11] as ReturnStatement;
     NodeList<Expression> elements =
         (statement.expression as ListLiteral).elements;
-    expect(elements[0].propagatedType.name, "AnchorElement");
-    expect(elements[1].propagatedType.name, "AnchorElement");
-    expect(elements[2].propagatedType.name, "BodyElement");
-    expect(elements[3].propagatedType.name, "ButtonElement");
-    expect(elements[4].propagatedType.name, "DivElement");
-    expect(elements[5].propagatedType.name, "InputElement");
-    expect(elements[6].propagatedType.name, "SelectElement");
-    expect(elements[7].propagatedType.name, "DivElement");
-    expect(elements[8].propagatedType.name, "Element");
-    expect(elements[9].propagatedType.name, "Element");
-    expect(elements[10].propagatedType.name, "Element");
+    expect(propagatedTypeForExpression(elements[0]).name, "AnchorElement");
+    expect(propagatedTypeForExpression(elements[1]).name, "AnchorElement");
+    expect(propagatedTypeForExpression(elements[2]).name, "BodyElement");
+    expect(propagatedTypeForExpression(elements[3]).name, "ButtonElement");
+    expect(propagatedTypeForExpression(elements[4]).name, "DivElement");
+    expect(propagatedTypeForExpression(elements[5]).name, "InputElement");
+    expect(propagatedTypeForExpression(elements[6]).name, "SelectElement");
+    expect(propagatedTypeForExpression(elements[7]).name, "DivElement");
+    expect(propagatedTypeForExpression(elements[8]).name, "Element");
+    expect(propagatedTypeForExpression(elements[9]).name, "Element");
+    expect(propagatedTypeForExpression(elements[10]).name, "Element");
   }
 }
 
 @reflectiveTest
 class TypeProviderImplTest extends EngineTestCase {
   void test_creation() {
     //
     // Create a mock library element with the types expected to be in dart:core.
     // We cannot use either ElementFactory or TestTypeProvider (which uses
     // ElementFactory) because we side-effect the elements in ways that would
@@ skipping 1194 matching lines @@
  */
 class _StaleElement extends ElementImpl {
   _StaleElement() : super("_StaleElement", -1);
 
   @override
   get kind => throw "_StaleElement's kind shouldn't be accessed";
 
   @override
   accept(_) => throw "_StaleElement shouldn't be visited";
 }