Prepare for decoupling analyzer ASTs from element model.

pkg/analyzer/test/src/dart/analysis/driver_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.driver;
 
 import 'dart:async';
 import 'dart:convert';
 
 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/error/error.dart';
 import 'package:analyzer/file_system/file_system.dart';
 import 'package:analyzer/file_system/memory_file_system.dart';
 import 'package:analyzer/src/dart/analysis/byte_store.dart';
 import 'package:analyzer/src/dart/analysis/driver.dart';
 import 'package:analyzer/src/dart/analysis/file_state.dart';
 import 'package:analyzer/src/dart/analysis/status.dart';
 import 'package:analyzer/src/dart/analysis/top_level_declaration.dart';
 import 'package:analyzer/src/error/codes.dart';
@@ skipping 509 matching lines @@
     String content = r'''
 export 'dart:async';
 export 'dart:noSuchLib';
 export 'dart:math';
 ''';
     addTestFile(content, priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(result.path, testFile);
     // Has only exports for valid URIs.
-    List<ExportElement> imports = result.unit.element.library.exports;
+    List<ExportElement> imports =
+        elementForCompilationUnit(result.unit).library.exports;
     expect(
         imports.map((import) => import.exportedLibrary.source.uri.toString()),
         unorderedEquals(['dart:async', 'dart:math']));
   }
 
   test_getResult_invalidUri_imports_dart() async {
     String content = r'''
 import 'dart:async';
 import 'dart:noSuchLib';
 import 'dart:math';
 ''';
     addTestFile(content, priority: true);
 
     AnalysisResult result = await driver.getResult(testFile);
     expect(result.path, testFile);
     // Has only imports for valid URIs.
-    List<ImportElement> imports = result.unit.element.library.imports;
+    List<ImportElement> imports =
+        elementForCompilationUnit(result.unit).library.imports;
     expect(
         imports.map((import) => import.importedLibrary.source.uri.toString()),
         unorderedEquals(['dart:async', 'dart:math', 'dart:core']));
   }
 
   test_getResult_mix_fileAndPackageUris() async {
     var a = _p('/test/bin/a.dart');
     var b = _p('/test/bin/b.dart');
     var c = _p('/test/lib/c.dart');
     var d = _p('/test/test/d.dart');
@@ skipping 626 matching lines @@
           }
         }
       }
     }
     fail('Cannot find the field $fieldName in the class $className in\n$unit');
     return null;
   }
 
   String _getClassFieldType(
       CompilationUnit unit, String className, String fieldName) {
-    return _getClassField(unit, className, fieldName).element.type.toString();
+    return elementForVariableDeclaration(
+            _getClassField(unit, className, fieldName))
+        .type
+        .toString();
   }
 
   MethodDeclaration _getClassMethod(
       CompilationUnit unit, String className, String methodName) {
     ClassDeclaration classDeclaration = _getClass(unit, className);
     for (ClassMember declaration in classDeclaration.members) {
       if (declaration is MethodDeclaration &&
           declaration.name.name == methodName) {
         return declaration;
       }
     }
     fail('Cannot find the method $methodName in the class $className in\n'
         '$unit');
     return null;
   }
 
   String _getClassMethodReturnType(
       CompilationUnit unit, String className, String fieldName) {
-    return _getClassMethod(unit, className, fieldName)
-        .element
+    return elementForMethodDeclaration(
+            _getClassMethod(unit, className, fieldName))
         .type
         .returnType
         .toString();
   }
 
   ImportElement _getImportElement(CompilationUnit unit, int directiveIndex) {
     var import = unit.directives[directiveIndex] as ImportDirective;
     return import.element as ImportElement;
   }
 
   Source _getImportSource(CompilationUnit unit, int directiveIndex) {
     return _getImportElement(unit, directiveIndex).importedLibrary.source;
   }
 
   VariableDeclaration _getTopLevelVar(CompilationUnit unit, String name) {
     for (CompilationUnitMember declaration in unit.declarations) {
       if (declaration is TopLevelVariableDeclaration) {
         for (VariableDeclaration variable in declaration.variables.variables) {
           if (variable.name.name == name) {
             return variable;
           }
         }
       }
     }
     fail('Cannot find the top-level variable $name in\n$unit');
     return null;
   }
 
   String _getTopLevelVarType(CompilationUnit unit, String name) {
-    return _getTopLevelVar(unit, name).element.type.toString();
+    return elementForVariableDeclaration(_getTopLevelVar(unit, name))
+        .type
+        .toString();
   }
 
   /**
    * Return the [provider] specific path for the given Posix [path].
    */
   String _p(String path) => provider.convertPath(path);
 
   Future<Null> _waitForIdle() async {
     await idleStatusMonitor.signal;
   }
 
   static String _md5(String content) {
     return hex.encode(md5.convert(UTF8.encode(content)).bytes);
   }
 }