Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/test/src/task/incremental_element_builder_test.dart

 // Copyright (c) 2015, 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.src.task.incremental_element_builder_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/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/task/dart.dart';
 import 'package:analyzer/src/task/incremental_element_builder.dart';
 import 'package:analyzer/task/dart.dart';
 import 'package:test/test.dart';
@@ skipping 1219 matching lines @@
   test_directives_library_updateOffset() {
     _buildOldUnit(r'''
 #!/bin/sh
 library my_lib;
 class A {}
 ''');
     LibraryDirective libraryDirective = oldUnit.directives.single;
     // Set the LibraryElement and check that its nameOffset is correct.
     libraryDirective.element =
         new LibraryElementImpl.forNode(context, libraryDirective.name);
-    expect(libraryDirective.element.nameOffset, libraryDirective.name.offset);
+    expect(elementForDirective(libraryDirective).nameOffset,
+        libraryDirective.name.offset);
     // Update and check again that the nameOffset is correct.
     _buildNewUnit(r'''
 #!/bin/sh
 
 library my_lib;
 class A {}
 ''');
-    expect(libraryDirective.element.nameOffset, libraryDirective.name.offset);
+    expect(elementForDirective(libraryDirective).nameOffset,
+        libraryDirective.name.offset);
   }
 
   test_directives_remove() {
     _buildOldUnit(r'''
 library test;
 import 'dart:async';
 import 'dart:math';
 ''');
     List<Directive> oldDirectives = oldUnit.directives.toList();
     _buildNewUnit(r'''
@@ skipping 77 matching lines @@
     import1.element = importElement1;
     import2.element = importElement2;
     import1.prefix.staticElement = prefixElement;
     import2.prefix.staticElement = prefixElement;
     _buildNewUnit(r'''
 import 'test1.dart' as m;
 import 'test2.dart' as m;
 class A {}
 ''');
     int expectedPrefixOffset = 23;
-    expect(import1.prefix.staticElement.nameOffset, expectedPrefixOffset);
-    expect(import2.prefix.staticElement.nameOffset, expectedPrefixOffset);
+    expect(staticElementForIdentifier(import1.prefix).nameOffset,
+        expectedPrefixOffset);
+    expect(staticElementForIdentifier(import2.prefix).nameOffset,
+        expectedPrefixOffset);
     expect(importElement1.prefix.nameOffset, expectedPrefixOffset);
     expect(importElement2.prefix.nameOffset, expectedPrefixOffset);
   }
 
   test_directives_sameOrder_insertSpaces() {
     _buildOldUnit(r'''
 library test;
 import 'dart:async';
 import 'dart:math';
 ''');
@@ skipping 156 matching lines @@
 /// reference [double] and [B] types.
 class C {}''');
       ClassElement element = newNode.element;
       expect(element, isNotNull);
       expect(element.name, 'C');
       expect(element.nameOffset, newCode.indexOf('C {}'));
       // [double] and [B] are still resolved
       {
         var docReferences = newNode.documentationComment.references;
         expect(docReferences, hasLength(2));
-        expect(docReferences[0].identifier.staticElement.name, 'double');
+        expect(staticElementForIdentifier(docReferences[0].identifier).name,
+            'double');
         expect(docReferences[1].identifier.staticElement,
             same(newNodes[2].element));
       }
     }
     {
       CompilationUnitMember newNode = newNodes[1];
       expect(newNode, same(oldNodes[0]));
       expect(
           getNodeText(newNode),
           r'''
 /// reference [bool] type.
 class A {}''');
       ClassElement element = newNode.element;
       expect(element, isNotNull);
       expect(element.name, 'A');
       expect(element.nameOffset, newCode.indexOf('A {}'));
       // [bool] is still resolved
       {
         var docReferences = newNode.documentationComment.references;
         expect(docReferences, hasLength(1));
-        expect(docReferences[0].identifier.staticElement.name, 'bool');
+        expect(staticElementForIdentifier(docReferences[0].identifier).name,
+            'bool');
       }
     }
     {
       CompilationUnitMember newNode = newNodes[2];
       expect(newNode, same(oldNodes[1]));
       expect(
           getNodeText(newNode),
           r'''
 /// reference [int] type.
 class B {}''');
       ClassElement element = newNode.element;
       expect(element, isNotNull);
       expect(element.name, 'B');
       expect(element.nameOffset, newCode.indexOf('B {}'));
       // [int] is still resolved
       {
         var docReferences = newNode.documentationComment.references;
         expect(docReferences, hasLength(1));
-        expect(docReferences[0].identifier.staticElement.name, 'int');
+        expect(staticElementForIdentifier(docReferences[0].identifier).name,
+            'int');
       }
     }
     // verify delta
     expect(unitDelta.addedDeclarations, unorderedEquals([]));
     expect(unitDelta.removedDeclarations, unorderedEquals([]));
   }
 
   test_unitMembers_class_remove() {
     _buildOldUnit(r'''
 class A {}
@@ skipping 618 matching lines @@
       ClassDeclaration classNode =
           actual.getAncestor((n) => n is ClassDeclaration);
       expect(element.enclosingElement, same(classNode.element));
     }
     // ElementAnnotationImpl must use the enclosing CompilationUnitElement.
     if (actual is Annotation) {
       AstNode parent = actual.parent;
       if (parent is Declaration) {
         ElementAnnotationImpl actualElement = actual.elementAnnotation;
         CompilationUnitElement enclosingUnitElement =
-            parent.element.getAncestor((a) => a is CompilationUnitElement);
+            elementForDeclaration(parent)
+                .getAncestor((a) => a is CompilationUnitElement);
         expect(actualElement.compilationUnit, same(enclosingUnitElement));
       }
     }
     // Identifiers like 'a.b' in 'new a.b()' might be rewritten if resolver
     // sees that 'a' is actually a class name, so 'b' is a constructor name.
     //
     if (expected is ConstructorName && actual is ConstructorName) {
       Identifier expectedTypeName = expected.type.name;
       Identifier actualTypeName = actual.type.name;
       if (expectedTypeName is PrefixedIdentifier &&
@@ skipping 119 matching lines @@
           unitMember is ClassDeclaration && unitMember.name.name == name);
 }
 
 class _MaterializeLazyElementsVisitor extends GeneralizingElementVisitor {
   @override
   visitExecutableElement(ExecutableElement element) {
     element.parameters;
     super.visitExecutableElement(element);
   }
 }