Don't use Element.computeNode() in resolver tests.

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';
 
+import '../utils.dart';
 import 'resolver_test_case.dart';
 import 'test_support.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(SimpleResolverTest);
   });
 }
 
 @reflectiveTest
@@ skipping 91 matching lines @@
 class A {
   void f() {
     g(1, 2, 3, 4);
   }
   void g(a, b, [c]) {}
 }''');
     _validateArgumentResolution(source, [0, 1, 2, -1]);
   }
 
   test_argumentResolution_setter_propagated() async {
-    Source source = addSource(r'''
+    CompilationUnit unit = await resolveSource(r'''
 main() {
   var a = new A();
   a.sss = 0;
 }
 class A {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve2(source);
-    CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
-      FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
-      Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
-      ExpressionStatement expressionStatement =
-          statement as ExpressionStatement;
-      assignment = expressionStatement.expression as AssignmentExpression;
+      var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
+      var statement = statements[1] as ExpressionStatement;
+      assignment = statement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
-    ClassElement classA = unit.types[0];
+    ClassElement classA = unit.element.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
     expect(setter.parameters[0], same(parameter));
   }
 
   test_argumentResolution_setter_propagated_propertyAccess() async {
-    Source source = addSource(r'''
+    CompilationUnit unit = await resolveSource(r'''
 main() {
   var a = new A();
   a.b.sss = 0;
 }
 class A {
   B b = new B();
 }
 class B {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve2(source);
-    CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
-      FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
-      Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
-      ExpressionStatement expressionStatement =
-          statement as ExpressionStatement;
-      assignment = expressionStatement.expression as AssignmentExpression;
+      var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
+      var statement = statements[1] as ExpressionStatement;
+      assignment = statement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
-    ClassElement classB = unit.types[1];
+    ClassElement classB = unit.element.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
     expect(setter.parameters[0], same(parameter));
   }
 
   test_argumentResolution_setter_static() async {
-    Source source = addSource(r'''
+    CompilationUnit unit = await resolveSource(r'''
 main() {
   A a = new A();
   a.sss = 0;
 }
 class A {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve2(source);
-    CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
-      FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
-      Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
-      ExpressionStatement expressionStatement =
-          statement as ExpressionStatement;
-      assignment = expressionStatement.expression as AssignmentExpression;
+      var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
+      var statement = statements[1] as ExpressionStatement;
+      assignment = statement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
-    ClassElement classA = unit.types[0];
+    ClassElement classA = unit.element.types[0];
     PropertyAccessorElement setter = classA.accessors[0];
     expect(setter.parameters[0], same(parameter));
   }
 
   test_argumentResolution_setter_static_propertyAccess() async {
-    Source source = addSource(r'''
+    CompilationUnit unit = await resolveSource(r'''
 main() {
   A a = new A();
   a.b.sss = 0;
 }
 class A {
   B b = new B();
 }
 class B {
   set sss(x) {}
 }''');
-    LibraryElement library = resolve2(source);
-    CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
-      FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
-      Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
-      ExpressionStatement expressionStatement =
-          statement as ExpressionStatement;
-      assignment = expressionStatement.expression as AssignmentExpression;
+      var statements = AstFinder.getStatementsInTopLevelFunction(unit, 'main');
+      var statement = statements[1] as ExpressionStatement;
+      assignment = statement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
     // validate
-    ClassElement classB = unit.types[1];
+    ClassElement classB = unit.element.types[1];
     PropertyAccessorElement setter = classB.accessors[0];
     expect(setter.parameters[0], same(parameter));
   }
 
   test_breakTarget_labeled() async {
     // Verify that the target of the label is correctly found and is recorded
     // as the unlabeled portion of the statement.
     String text = r'''
 void f() {
   loop1: while (true) {
@@ skipping 463 matching lines @@
 class M2 {
   get x => null;
   set x(value) {}
 }
 class C extends B with M1, M2 {
   void f() {
     x += 1;
   }
 }
 ''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(source);
     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;
+    List<Statement> statements =
+        AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'f');
+    var statement = statements[0] as ExpressionStatement;
+    AssignmentExpression assignment = statement.expression;
     SimpleIdentifier leftHandSide = assignment.leftHandSide;
     expect(
         resolutionMap
             .staticElementForIdentifier(leftHandSide)
             .enclosingElement
             .name,
         'M2');
     expect(leftHandSide.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   @failingTest
   test_getter_and_setter_fromMixins_property_access() async {
     // 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('''
+    Source source = addSource(r'''
 class B {}
 class M1 {
   get x => null;
   set x(value) {}
 }
 class M2 {
   get x => null;
   set x(value) {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().x += 1;
 }
 ''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(source);
     assertNoErrors(source);
     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;
+    List<Statement> statements =
+        AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
+    var statement = statements[0] as ExpressionStatement;
+    AssignmentExpression assignment = statement.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
         resolutionMap
             .staticElementForIdentifier(propertyAccess.propertyName)
             .enclosingElement
             .name,
         'M2');
     expect(
         propertyAccess
             .propertyName.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   test_getter_fromMixins_bare_identifier() async {
     Source source = addSource('''
 class B {}
 class M1 {
   get x => null;
 }
 class M2 {
   get x => null;
 }
 class C extends B with M1, M2 {
   f() {
     return x;
   }
 }
 ''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(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;
+    var statements =
+        AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'f');
+    var statement = statements[0] as ReturnStatement;
+    SimpleIdentifier x = statement.expression;
     expect(resolutionMap.staticElementForIdentifier(x).enclosingElement.name,
         'M2');
   }
 
   test_getter_fromMixins_property_access() async {
     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);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(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;
+    List<Statement> statements =
+        AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
+    var statement = statements[0] as VariableDeclarationStatement;
+    PropertyAccess propertyAccess =
+        statement.variables.variables[0].initializer;
     expect(
         resolutionMap
             .staticElementForIdentifier(propertyAccess.propertyName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_getterAndSetterWithDifferentTypes() async {
     Source source = addSource(r'''
@@ skipping 689 matching lines @@
   void f() {}
 }
 class M2 {
   void f() {}
 }
 class C extends B with M1, M2 {}
 void main() {
   new C().f();
 }
 ''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(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;
+    List<Statement> statements =
+        AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
+    var statement = statements[0] as ExpressionStatement;
+    MethodInvocation expr = statement.expression;
     expect(
         resolutionMap
             .staticElementForIdentifier(expr.methodName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_method_fromMixins_bare_identifier() async {
     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);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(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;
+    List<Statement> statements =
+        AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'g');
+    var statement = statements[0] as ExpressionStatement;
+    MethodInvocation invocation = statement.expression;
     SimpleIdentifier methodName = invocation.methodName;
     expect(
         resolutionMap
             .staticElementForIdentifier(methodName)
             .enclosingElement
             .name,
         'M2');
   }
 
-  test_method_fromMixins_invked_from_outside_class() async {
+  test_method_fromMixins_invoked_from_outside_class() async {
     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);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(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;
+    List<Statement> statements =
+        AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
+    var statement = statements[0] as ExpressionStatement;
+    MethodInvocation invocation = statement.expression;
     expect(
         resolutionMap
             .staticElementForIdentifier(invocation.methodName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_method_fromSuperclassMixin() async {
     Source source = addSource(r'''
@@ skipping 64 matching lines @@
 }
 class M2 {
   set x(value) {}
 }
 class C extends B with M1, M2 {
   void f() {
     x = 1;
   }
 }
 ''');
-    LibraryElement library = resolve2(source);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(source);
     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;
+    List<Statement> statements =
+        AstFinder.getStatementsInMethod(analysisResult.unit, 'C', 'f');
+    var statement = statements[0] as ExpressionStatement;
+    AssignmentExpression assignment = statement.expression;
     SimpleIdentifier leftHandSide = assignment.leftHandSide;
     expect(
         resolutionMap
             .staticElementForIdentifier(leftHandSide)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_setter_fromMixins_property_access() async {
     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);
-    await computeAnalysisResult(source);
+    var analysisResult = await computeAnalysisResult(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;
+    List<Statement> statements =
+        AstFinder.getStatementsInTopLevelFunction(analysisResult.unit, 'main');
+    var statement = statements[0] as ExpressionStatement;
+    AssignmentExpression assignment = statement.expression;
     PropertyAccess propertyAccess = assignment.leftHandSide;
     expect(
         resolutionMap
             .staticElementForIdentifier(propertyAccess.propertyName)
             .enclosingElement
             .name,
         'M2');
   }
 
   test_setter_inherited() async {
@@ skipping 114 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;
   }
 }