Rename Element.node

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 engine.resolver_test;
 
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/ast.dart';
 import 'package:analyzer/src/generated/element.dart';
@@ skipping 8058 matching lines @@
 void main() {
   new C().x += 1;
 }
 ''');
     LibraryElement library = resolve(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].node;
+        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');
     expect(
         propertyAccess.propertyName.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
@@ skipping 120 matching lines @@
 }
 class A {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.node.functionExpression.body;
+      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
     expect(parameter, isNotNull);
@@ skipping 15 matching lines @@
 }
 class B {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.node.functionExpression.body;
+      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     expect(rhs.staticParameterElement, isNull);
     ParameterElement parameter = rhs.propagatedParameterElement;
     expect(parameter, isNotNull);
@@ skipping 12 matching lines @@
 }
 class A {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.node.functionExpression.body;
+      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
@@ skipping 14 matching lines @@
 }
 class B {
   set sss(x) {}
 }''');
     LibraryElement library = resolve(source);
     CompilationUnitElement unit = library.definingCompilationUnit;
     // find "a.b.sss = 0"
     AssignmentExpression assignment;
     {
       FunctionElement mainElement = unit.functions[0];
-      FunctionBody mainBody = mainElement.node.functionExpression.body;
+      FunctionBody mainBody = mainElement.computeNode().functionExpression.body;
       Statement statement = (mainBody as BlockFunctionBody).block.statements[1];
       ExpressionStatement expressionStatement =
           statement as ExpressionStatement;
       assignment = expressionStatement.expression as AssignmentExpression;
     }
     // get parameter
     Expression rhs = assignment.rightHandSide;
     ParameterElement parameter = rhs.staticParameterElement;
     expect(parameter, isNotNull);
     expect(parameter.displayName, "x");
@@ skipping 455 matching lines @@
     x += 1;
   }
 }
 ''');
     LibraryElement library = resolve(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').node;
+    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(leftHandSide.auxiliaryElements.staticElement.enclosingElement.name,
         'M2');
   }
 
   void test_getter_fromMixins_bare_identifier() {
@@ skipping 10 matching lines @@
     return x;
   }
 }
 ''');
     LibraryElement library = resolve(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').node;
+    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');
   }
 
   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 = resolve(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].node;
+        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');
   }
 
   void test_getterAndSetterWithDifferentTypes() {
     Source source = addSource(r'''
 class A {
@@ skipping 491 matching lines @@
 class C extends B with M1, M2 {}
 void main() {
   new C().f();
 }
 ''');
     LibraryElement library = resolve(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].node;
+        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');
   }
 
   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 = resolve(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').node;
+    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');
   }
 
   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 = resolve(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].node;
+        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');
   }
 
   void test_method_fromSuperclassMixin() {
     Source source = addSource(r'''
 class A {
   void m1() {}
@@ skipping 68 matching lines @@
     x = 1;
   }
 }
 ''');
     LibraryElement library = resolve(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').node;
+    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');
   }
 
   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 = resolve(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].node;
+        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');
   }
 
   void test_setter_inherited() {
     Source source = addSource(r'''
@@ skipping 4244 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;
   }
 }