Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/test/generated/simple_resolver_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.simple_resolver_test;
 
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/dart/ast/standard_resolution_map.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/exception/exception.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';
 
@@ skipping 723 matching lines @@
     assertNoErrors(source);
     verify([source]);
     // Verify that both the getter and setter for "x" in C.f() refer to the
     // accessors defined in M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration f = classC.getMethod('f').computeNode();
     BlockFunctionBody body = f.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     SimpleIdentifier leftHandSide = assignment.leftHandSide;
-    expect(leftHandSide.staticElement.enclosingElement.name, 'M2');
+    expect(
+        resolutionMap
+            .staticElementForIdentifier(leftHandSide)
+            .enclosingElement
+            .name,
+        'M2');
     expect(leftHandSide.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   @failingTest
   void test_getter_and_setter_fromMixins_property_access() {
     // TODO(paulberry): it appears that auxiliaryElements isn't properly set on
     // a SimpleIdentifier that's inside a property access.  This bug should be
     // fixed.
     Source source = addSource('''
@@ skipping 16 matching lines @@
     verify([source]);
     // Verify that both the getter and setter for "x" in "new C().x" refer to
     // the accessors defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
-        propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
+        resolutionMap
+            .staticElementForIdentifier(propertyAccess.propertyName)
+            .enclosingElement
+            .name,
+        'M2');
     expect(
         propertyAccess
             .propertyName.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   void test_getter_fromMixins_bare_identifier() {
     Source source = addSource('''
 class B {}
 class M1 {
@@ skipping 11 matching lines @@
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the getter for "x" in C.f() refers to the getter defined in
     // M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration f = classC.getMethod('f').computeNode();
     BlockFunctionBody body = f.body;
     ReturnStatement stmt = body.block.statements[0];
     SimpleIdentifier x = stmt.expression;
-    expect(x.staticElement.enclosingElement.name, 'M2');
+    expect(resolutionMap.staticElementForIdentifier(x).enclosingElement.name,
+        'M2');
   }
 
   void test_getter_fromMixins_property_access() {
     Source source = addSource('''
 class B {}
 class M1 {
   get x => null;
 }
 class M2 {
   get x => null;
 }
 class C extends B with M1, M2 {}
 void main() {
   var y = new C().x;
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the getter for "x" in "new C().x" refers to the getter
     // defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     VariableDeclarationStatement stmt = body.block.statements[0];
     PropertyAccess propertyAccess = stmt.variables.variables[0].initializer;
     expect(
-        propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
+        resolutionMap
+            .staticElementForIdentifier(propertyAccess.propertyName)
+            .enclosingElement
+            .name,
+        'M2');
   }
 
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource(r'''
 class A {
   int get f => 0;
   void set f(String s) {}
 }
 g (A a) {
   a.f = a.f.toString();
@@ skipping 669 matching lines @@
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the "f" in "new C().f()" refers to the "f" defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation expr = stmt.expression;
-    expect(expr.methodName.staticElement.enclosingElement.name, 'M2');
+    expect(
+        resolutionMap
+            .staticElementForIdentifier(expr.methodName)
+            .enclosingElement
+            .name,
+        'M2');
   }
 
   void test_method_fromMixins_bare_identifier() {
     Source source = addSource('''
 class B {}
 class M1 {
   void f() {}
 }
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {
   void g() {
     f();
   }
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the call to f() in C.g() refers to the method defined in M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration g = classC.getMethod('g').computeNode();
     BlockFunctionBody body = g.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation invocation = stmt.expression;
     SimpleIdentifier methodName = invocation.methodName;
-    expect(methodName.staticElement.enclosingElement.name, 'M2');
+    expect(
+        resolutionMap
+            .staticElementForIdentifier(methodName)
+            .enclosingElement
+            .name,
+        'M2');
   }
 
   void test_method_fromMixins_invked_from_outside_class() {
     Source source = addSource('''
 class B {}
 class M1 {
   void f() {}
 }
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().f();
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the call to f() in "new C().f()" refers to the method
     // defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     MethodInvocation invocation = stmt.expression;
-    expect(invocation.methodName.staticElement.enclosingElement.name, 'M2');
+    expect(
+        resolutionMap
+            .staticElementForIdentifier(invocation.methodName)
+            .enclosingElement
+            .name,
+        'M2');
   }
 
   void test_method_fromSuperclassMixin() {
     Source source = addSource(r'''
 class A {
   void m1() {}
 }
 class B extends Object with A {
 }
 class C extends B {
@@ skipping 69 matching lines @@
     assertNoErrors(source);
     verify([source]);
     // Verify that the setter for "x" in C.f() refers to the setter defined in
     // M2.
     ClassElement classC = library.definingCompilationUnit.types[3];
     MethodDeclaration f = classC.getMethod('f').computeNode();
     BlockFunctionBody body = f.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     SimpleIdentifier leftHandSide = assignment.leftHandSide;
-    expect(leftHandSide.staticElement.enclosingElement.name, 'M2');
+    expect(
+        resolutionMap
+            .staticElementForIdentifier(leftHandSide)
+            .enclosingElement
+            .name,
+        'M2');
   }
 
   void test_setter_fromMixins_property_access() {
     Source source = addSource('''
 class B {}
 class M1 {
   set x(value) {}
 }
 class M2 {
   set x(value) {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().x = 1;
 }
 ''');
     LibraryElement library = resolve2(source);
     assertNoErrors(source);
     verify([source]);
     // Verify that the setter for "x" in "new C().x" refers to the setter
     // defined in M2.
     FunctionDeclaration main =
         library.definingCompilationUnit.functions[0].computeNode();
     BlockFunctionBody body = main.functionExpression.body;
     ExpressionStatement stmt = body.block.statements[0];
     AssignmentExpression assignment = stmt.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
-        propertyAccess.propertyName.staticElement.enclosingElement.name, 'M2');
+        resolutionMap
+            .staticElementForIdentifier(propertyAccess.propertyName)
+            .enclosingElement
+            .name,
+        'M2');
   }
 
   void test_setter_inherited() {
     Source source = addSource(r'''
 class A {
   int get x => 0;
   set x(int p) {}
 }
 class B extends A {
   int get x => super.x == null ? 0 : super.x;
@@ skipping 107 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;
   }
 }