Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/test/generated/strong_mode_test.dart

 // Copyright (c) 2016, 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.strong_mode_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/resolution_accessors.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source_io.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import '../utils.dart';
@@ skipping 282 matching lines @@
    ''';
     CompilationUnit unit = resolveSource(code);
 
     ConstructorDeclaration constructor =
         AstFinder.getConstructorInClass(unit, "A", null);
     BlockFunctionBody body = constructor.body;
     ReturnStatement stmt = body.block.statements[0];
     InstanceCreationExpression exp = stmt.expression;
     ClassElement elementB = AstFinder.getClass(unit, "B").element;
     ClassElement elementA = AstFinder.getClass(unit, "A").element;
-    expect(exp.constructorName.type.type.element, elementB);
+    expect(typeForTypeName(exp.constructorName.type).element, elementB);
     _isInstantiationOf(_hasElement(elementB))(
         [_isType(elementA.typeParameters[0].type)])(exp.staticType);
   }
 
   void test_fieldDeclaration_propagation() {
     String code = r'''
       class A {
         List<String> f0 = ["hello"];
       }
    ''';
@@ skipping 31 matching lines @@
     FunctionDeclaration inner =
         (statements[0] as FunctionDeclarationStatement).functionDeclaration;
     BlockFunctionBody body0 = inner.functionExpression.body;
     ReturnStatement return0 = body0.block.statements[0];
     Expression anon0 = return0.expression;
     FunctionType type0 = anon0.staticType;
     expect(type0.returnType, typeProvider.intType);
     expect(type0.normalParameterTypes[0], typeProvider.stringType);
 
     FunctionExpression anon1 = (statements[1] as ReturnStatement).expression;
-    FunctionType type1 = anon1.element.type;
+    FunctionType type1 = elementForFunctionExpression(anon1).type;
     expect(type1.returnType, typeProvider.intType);
     expect(type1.normalParameterTypes[0], typeProvider.intType);
   }
 
   void test_functionLiteral_assignment_typedArguments() {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, String> l0 = (int x) => null;
         Function2<int, String> l1 = (int x) => "hello";
         Function2<int, String> l2 = (String x) => "hello";
         Function2<int, String> l3 = (int x) => 3;
         Function2<int, String> l4 = (int x) {return 3;};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_assignment_unTypedArguments() {
     String code = r'''
       typedef T Function2<S, T>(S x);
 
       void main () {
         Function2<int, String> l0 = (x) => null;
         Function2<int, String> l1 = (x) => "hello";
         Function2<int, String> l2 = (x) => "hello";
         Function2<int, String> l3 = (x) => 3;
         Function2<int, String> l4 = (x) {return 3;};
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       VariableDeclarationStatement stmt = statements[i];
       VariableDeclaration decl = stmt.variables.variables[0];
       FunctionExpression exp = decl.initializer;
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_body_propagation() {
@@ skipping 44 matching lines @@
         (new Mapper<int, String>().map)((int x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       FunctionExpressionInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_functionExpressionInvocation_unTypedArguments() {
@@ skipping 10 matching lines @@
         (new Mapper<int, String>().map)((x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       FunctionExpressionInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_functionInvocation_typedArguments() {
     String code = r'''
       String map(String mapper(int x)) => mapper(null);
 
       void main () {
         map((int x) => null);
         map((int x) => "hello");
         map((String x) => "hello");
         map((int x) => 3);
         map((int x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_functionInvocation_unTypedArguments() {
     String code = r'''
       String map(String mapper(int x)) => mapper(null);
 
       void main () {
         map((x) => null);
         map((x) => "hello");
         map((x) => "hello");
         map((x) => 3);
         map((x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_methodInvocation_typedArguments() {
@@ skipping 10 matching lines @@
         new Mapper<int, String>().map((int x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isString, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_methodInvocation_unTypedArguments() {
@@ skipping 10 matching lines @@
         new Mapper<int, String>().map((x) {return 3;});
      }
    ''';
     CompilationUnit unit = resolveSource(code);
     List<Statement> statements =
         AstFinder.getStatementsInTopLevelFunction(unit, "main");
     DartType literal(int i) {
       ExpressionStatement stmt = statements[i];
       MethodInvocation invk = stmt.expression;
       FunctionExpression exp = invk.argumentList.arguments[0];
-      return exp.element.type;
+      return elementForFunctionExpression(exp).type;
     }
 
     _isFunction2Of(_isInt, _isString)(literal(0));
     _isFunction2Of(_isInt, _isString)(literal(1));
     _isFunction2Of(_isInt, _isString)(literal(2));
     _isFunction2Of(_isInt, _isInt)(literal(3));
     _isFunction2Of(_isInt, _isString)(literal(4));
   }
 
   void test_functionLiteral_unTypedArgument_propagation() {
@@ skipping 57 matching lines @@
       }
    ''';
     CompilationUnit unit = resolveSource(code);
 
     Asserter<InterfaceType> assertListOfInt = _isListOf(_isInt);
     Asserter<InterfaceType> assertMapOfIntToListOfInt =
         _isMapOf(_isInt, (DartType type) => assertListOfInt(type));
 
     VariableDeclaration mapB = AstFinder.getFieldInClass(unit, "B", "map");
     MethodDeclaration mapC = AstFinder.getMethodInClass(unit, "C", "map");
-    assertMapOfIntToListOfInt(mapB.element.type);
-    assertMapOfIntToListOfInt(mapC.element.returnType);
+    assertMapOfIntToListOfInt(elementForVariableDeclaration(mapB).type);
+    assertMapOfIntToListOfInt(elementForMethodDeclaration(mapC).returnType);
 
     MapLiteral mapLiteralB = mapB.initializer;
     MapLiteral mapLiteralC = (mapC.body as ExpressionFunctionBody).expression;
     assertMapOfIntToListOfInt(mapLiteralB.staticType);
     assertMapOfIntToListOfInt(mapLiteralC.staticType);
 
     ListLiteral listLiteralB = mapLiteralB.entries[0].value;
     ListLiteral listLiteralC = mapLiteralC.entries[0].value;
     assertListOfInt(listLiteralB.staticType);
     assertListOfInt(listLiteralC.staticType);
@@ skipping 1680 matching lines @@
 main() {
   var v = x;
   v; // marker
 }
 int x = 3;
 ''';
     assertPropagatedAssignedType(code, typeProvider.intType, null);
     assertTypeOfMarkedExpression(code, typeProvider.intType, null);
   }
 }