Prepare for decoupling analyzer ASTs from element model.

pkg/kernel/lib/analyzer/ast_from_analyzer.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 kernel.analyzer.ast_from_analyzer;
 
 import '../ast.dart' as ast;
 import '../frontend/accessors.dart';
 import '../frontend/super_initializers.dart';
 import '../log.dart';
 import '../type_algebra.dart';
 import '../transformations/flags.dart';
 import 'analyzer.dart';
 import 'loader.dart';
 import 'package:analyzer/analyzer.dart';
+import 'package:analyzer/dart/ast/resolution_accessors.dart';
 import 'package:analyzer/src/generated/parser.dart';
 import 'package:analyzer/src/dart/element/member.dart';
 import 'package:analyzer/src/error/codes.dart';
 
 /// Provides reference-level access to libraries, classes, and members.
 ///
 /// "Reference level" objects are incomplete nodes that have no children but
 /// can be used for linking until the loader promotes the node to a higher
 /// loading level.
 ///
@@ skipping 509 matching lines @@
     //   TypeScope.buildFunctionInterface.
     var positional = <ast.VariableDeclaration>[];
     var named = <ast.VariableDeclaration>[];
     int requiredParameterCount = 0;
     var formals = formalParameters?.parameters ?? const <FormalParameter>[];
     for (var parameter in formals) {
       var declaration = makeVariableDeclaration(parameter.element,
           initializer: parameter is DefaultFormalParameter
               ? buildOptionalTopLevelExpression(parameter.defaultValue)
               : null,
-          type: buildType(parameter.element.type));
+          type: buildType(elementForFormalParameter(parameter).type));
       switch (parameter.kind) {
         case ParameterKind.REQUIRED:
           positional.add(declaration);
           ++requiredParameterCount;
           declaration.initializer = null;
           break;
 
         case ParameterKind.POSITIONAL:
           positional.add(declaration);
           break;
@@ skipping 1773 matching lines @@
   }
 
   /// True if the given class member should not be emitted, and does not
   /// correspond to any Kernel member.
   ///
   /// This is true for redirecting factories with a resolved target. These are
   /// always bypassed at the call site.
   bool _isIgnoredMember(ClassMember node) {
     return node is ConstructorDeclaration &&
         node.factoryKeyword != null &&
-        node.element.redirectedConstructor != null;
+        elementForConstructorDeclaration(node).redirectedConstructor != null;
   }
 
   visitClassDeclaration(ClassDeclaration node) {
     addAnnotations(node.metadata);
     ast.Class classNode = currentClass;
     assert(classNode.members.isEmpty); // All members will be added here.
 
     bool foundConstructor = false;
     for (var member in node.members) {
       if (_isIgnoredMember(member)) continue;
@@ skipping 254 matching lines @@
       }
     }
     bool hasExplicitConstructorCall = false;
     for (var initializer in node.initializers) {
       var node = scope.buildInitializer(initializer);
       constructor.initializers.add(node..parent = constructor);
       if (node is ast.SuperInitializer || node is ast.RedirectingInitializer) {
         hasExplicitConstructorCall = true;
       }
     }
-    ClassElement classElement = node.element.enclosingElement;
+    ClassElement classElement =
+        elementForConstructorDeclaration(node).enclosingElement;
     if (classElement.supertype != null && !hasExplicitConstructorCall) {
       ConstructorElement targetElement =
           scope.findDefaultConstructor(classElement.supertype.element);
       ast.Constructor target = scope.resolveConstructor(targetElement);
       ast.Initializer initializer = target == null
           ? new ast.InvalidInitializer()
           : new ast.SuperInitializer(
               target, new ast.Arguments(<ast.Expression>[]));
       constructor.initializers.add(initializer..parent = constructor);
     } else {
       moveSuperInitializerLast(constructor);
     }
   }
 
   void buildFactoryConstructor(ConstructorDeclaration node) {
     addAnnotations(node.metadata);
     ast.Procedure procedure = currentMember;
-    ClassElement classElement = node.element.enclosingElement;
+    ClassElement classElement =
+        elementForConstructorDeclaration(node).enclosingElement;
     ast.Class classNode = procedure.enclosingClass;
     var types = getFreshTypeParameters(classNode.typeParameters);
     for (int i = 0; i < classElement.typeParameters.length; ++i) {
       scope.localTypeParameters[classElement.typeParameters[i]] =
           types.freshTypeParameters[i];
     }
     var function = scope.buildFunctionNode(node.parameters, node.body,
         typeParameters: types.freshTypeParameters,
         inferredReturnType: new ast.InterfaceType(classNode,
             types.freshTypeParameters.map(makeTypeParameterType).toList()));
     procedure.function = function..parent = procedure;
     handleNativeBody(node.body);
     if (node.redirectedConstructor != null) {
       // Redirecting factories with resolved targets don't show up here.
-      assert(node.element.redirectedConstructor == null);
+      assert(
+          elementForConstructorDeclaration(node).redirectedConstructor == null);
       var function = procedure.function;
       var name = node.redirectedConstructor.type.name.name;
       if (node.redirectedConstructor.name != null) {
         name += '.' + node.redirectedConstructor.name.name;
       }
       // TODO(asgerf): Sometimes a TypeError should be thrown.
       function.body = new ast.ExpressionStatement(
           scope.buildThrowNoSuchMethodError(
               new ast.NullLiteral(), name, new ast.Arguments.empty()))
         ..parent = function;
     }
   }
 
   visitMethodDeclaration(MethodDeclaration node) {
     addAnnotations(node.metadata);
     ast.Procedure procedure = currentMember;
     procedure.function = scope.buildFunctionNode(node.parameters, node.body,
         returnType: node.returnType,
-        inferredReturnType: scope.buildType(node.element.returnType),
+        inferredReturnType:
+            scope.buildType(elementForMethodDeclaration(node).returnType),
         typeParameters:
             scope.buildOptionalTypeParameterList(node.typeParameters))
       ..parent = procedure;
     handleNativeBody(node.body);
   }
 
   visitVariableDeclaration(VariableDeclaration node) {
     addAnnotations(node.metadata);
     ast.Field field = currentMember;
-    field.type = scope.buildType(node.element.type);
+    field.type = scope.buildType(elementForVariableDeclaration(node).type);
     if (node.initializer != null) {
       field.initializer = scope.buildTopLevelExpression(node.initializer)
         ..parent = field;
     } else if (field.isStatic) {
       // Add null initializer to static fields without an initializer.
       // For instance fields, this is handled when building the class.
       field.initializer = new ast.NullLiteral()..parent = field;
     }
   }
 
@@ skipping 122 matching lines @@
     if (list[i - 1].compareTo(item) == 0) {
       ++deleted;
     } else if (deleted > 0) {
       list[i - deleted] = item;
     }
   }
   if (deleted > 0) {
     list.length -= deleted;
   }
 }