Prepare for decoupling analyzer ASTs from element model.

pkg/dev_compiler/lib/src/compiler/code_generator.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.
 
 import 'dart:collection' show HashMap, HashSet;
 import 'dart:math' show min, max;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/standard_ast_factory.dart';
 import 'package:analyzer/dart/ast/token.dart' show Token, TokenType;
+import 'package:analyzer/dart/ast/resolution_accessors.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/token.dart' show StringToken;
 import 'package:analyzer/src/dart/element/element.dart'
     show LocalVariableElementImpl;
 import 'package:analyzer/src/dart/element/type.dart' show DynamicTypeImpl;
 import 'package:analyzer/src/dart/sdk/sdk.dart';
 import 'package:analyzer/src/generated/engine.dart' show AnalysisContext;
 import 'package:analyzer/src/generated/resolver.dart'
     show TypeProvider, NamespaceBuilder;
@@ skipping 162 matching lines @@
 
     var module = _emitModule(compilationUnits);
     var dartApiSummary = _summarizeModule(compilationUnits);
 
     return new JSModuleFile(unit.name, errors, options, module, dartApiSummary);
   }
 
   List<int> _summarizeModule(List<CompilationUnit> units) {
     if (!options.summarizeApi) return null;
 
-    if (!units.any((u) => u.element.librarySource.isInSystemLibrary)) {
+    if (!units.any((u) => elementForCompilationUnit(u).librarySource.isInSystemLibrary)) {
       var sdk = context.sourceFactory.dartSdk;
       summaryData.addBundle(
           null,
           sdk is SummaryBasedDartSdk
               ? sdk.bundle
               : (sdk as FolderBasedDartSdk).getSummarySdkBundle(true));
     }
 
     var assembler = new PackageBundleAssembler();
     assembler.recordDependencies(summaryData);
@@ skipping 21 matching lines @@
   }
 
   JS.Program _emitModule(List<CompilationUnit> compilationUnits) {
     if (_moduleItems.isNotEmpty) {
       throw new StateError('Can only call emitModule once.');
     }
 
     // Transform the AST to make coercions explicit.
     compilationUnits = CoercionReifier.reify(compilationUnits);
 
-    if (compilationUnits.any((u) => _isDartRuntime(u.element.library))) {
+    if (compilationUnits.any((u) => _isDartRuntime(elementForCompilationUnit(u).library))) {
       // Don't allow these to be renamed when we're building the SDK.
       // There is JS code in dart:* that depends on their names.
       _runtimeModule = new JS.Identifier('dart');
       _extensionSymbolsModule = new JS.Identifier('dartx');
     } else {
       // Otherwise allow these to be renamed so users can write them.
       _runtimeModule = new JS.TemporaryId('dart');
       _extensionSymbolsModule = new JS.TemporaryId('dartx');
     }
     _typeTable = new TypeTable(_runtimeModule);
 
     // Initialize our library variables.
     var items = <JS.ModuleItem>[];
     for (var unit in compilationUnits) {
-      var library = unit.element.library;
+      var library = elementForCompilationUnit(unit).library;
       if (unit.element != library.definingCompilationUnit) continue;
 
       var libraryTemp = _isDartRuntime(library)
           ? _runtimeModule
           : new JS.TemporaryId(jsLibraryName(_libraryRoot, library));
       _libraries[library] = libraryTemp;
       items.add(new JS.ExportDeclaration(
           js.call('const # = Object.create(null)', [libraryTemp])));
 
       // dart:_runtime has a magic module that holds extension method symbols.
       // TODO(jmesserly): find a cleaner design for this.
       if (_isDartRuntime(library)) {
         items.add(new JS.ExportDeclaration(js
             .call('const # = Object.create(null)', [_extensionSymbolsModule])));
       }
     }
 
     // Collect all Element -> Node mappings, in case we need to forward declare
     // any nodes.
     var nodes = new HashMap<Element, AstNode>.identity();
     var sdkBootstrappingFns = new List<FunctionElement>();
     for (var unit in compilationUnits) {
-      if (_isDartRuntime(unit.element.library)) {
-        sdkBootstrappingFns.addAll(unit.element.functions);
+      if (_isDartRuntime(elementForCompilationUnit(unit).library)) {
+        sdkBootstrappingFns.addAll(elementForCompilationUnit(unit).functions);
       }
       _collectElements(unit, nodes);
     }
     _loader = new ElementLoader(nodes);
     if (compilationUnits.isNotEmpty) {
       _constants = new ConstFieldVisitor(context,
-          dummySource: compilationUnits.first.element.source);
+          dummySource: elementForCompilationUnit(compilationUnits.first).source);
     }
 
     // Add implicit dart:core dependency so it is first.
     emitLibraryName(dartCoreLibrary);
 
     // Emit SDK bootstrapping functions first, if any.
     sdkBootstrappingFns.forEach(_emitDeclaration);
 
     // Visit each compilation unit and emit its code.
     //
@@ skipping 427 matching lines @@
 
     // We export the JS type as if it was a Dart type. For example this allows
     // `dom.InputElement` to actually be HTMLInputElement.
     // TODO(jmesserly): if we had the JS name on the Element, we could just
     // generate it correctly when we refer to it.
     return js.statement('# = #;', [_emitTopLevelName(e), jsTypeName]);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
-    var classElem = node.element;
+    var classElem = elementForClassDeclaration(node);
 
     // If this class is annotated with `@JS`, then there is nothing to emit.
     if (findAnnotation(classElem, isPublicJSAnnotation) != null) return null;
 
     // If this is a JavaScript type, emit it now and then exit.
     var jsTypeDef = _emitJsType(classElem);
     if (jsTypeDef != null) return jsTypeDef;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
@@ skipping 361 matching lines @@
   /// Emits a field declaration for TypeScript & Closure's ES6_TYPED
   /// (e.g. `class Foo { i: string; }`)
   JS.VariableDeclarationList _emitTypeScriptField(FieldDeclaration field) {
     return new JS.VariableDeclarationList(
         field.isStatic ? 'static' : null,
         field.fields.variables
             .map((decl) => new JS.VariableInitialization(
                 new JS.Identifier(
                     // TODO(ochafik): use a refactored _emitMemberName instead.
                     decl.name.name,
-                    type: emitTypeRef(decl.element.type)),
+                    type: emitTypeRef(elementForVariableDeclaration(decl).type)),
                 null))
             .toList(growable: false));
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) {
-    var element = node.element;
+    var element = elementForEnumDeclaration(node);
     var type = element.type;
 
     // Generate a class per section 13 of the spec.
     // TODO(vsm): Generate any accompanying metadata
 
     // Create constructor and initialize index
     var constructor = new JS.Method(_propertyName('new'),
         js.call('function(index) { this.index = index; }') as JS.Fun);
     var fields = new List<FieldElement>.from(
         element.fields.where((f) => f.type == type));
@@ skipping 150 matching lines @@
     }
     return jsMethods;
   }
 
   List<JS.Method> _emitClassMethods(
       ClassDeclaration node,
       List<ConstructorDeclaration> ctors,
       List<FieldDeclaration> fields,
       List<ClassElement> superclasses,
       Map<FieldElement, JS.TemporaryId> virtualFields) {
-    var element = node.element;
+    var element = elementForClassDeclaration(node);
     var type = element.type;
     var isObject = type.isObject;
 
     // Iff no constructor is specified for a class C, it implicitly has a
     // default constructor `C() : super() {}`, unless C is class Object.
     var jsMethods = <JS.Method>[];
     if (isObject) {
       // Implements Dart constructor behavior.
       //
       // Because of ES6 constructor restrictions (`this` is not available until
@@ skipping 459 matching lines @@
 
     var tStaticMethods = <JS.Property>[];
     var tInstanceMethods = <JS.Property>[];
     var tStaticGetters = <JS.Property>[];
     var tInstanceGetters = <JS.Property>[];
     var tStaticSetters = <JS.Property>[];
     var tInstanceSetters = <JS.Property>[];
     var sNames = <JS.Expression>[];
     for (MethodDeclaration node in methods) {
       var name = node.name.name;
-      var element = node.element;
+      var element = elementForMethodDeclaration(node);
       // TODO(vsm): Clean up all the nasty duplication.
       if (node.isAbstract) {
         continue;
       }
 
       Function lookup;
       List<JS.Property> tMember;
       JS.Expression type;
       if (node.isGetter) {
         lookup = classElem.lookUpInheritedConcreteGetter;
@@ skipping 34 matching lines @@
         var memberName = _declareMemberName(element.getter);
         var type = _emitAnnotatedType(element.type, node.metadata);
         var property = new JS.Property(memberName, type);
         (node.isStatic ? tStaticFields : tInstanceFields).add(property);
       }
     }
 
     var tCtors = <JS.Property>[];
     for (ConstructorDeclaration node in ctors) {
       var memberName = _constructorName(node.element);
-      var element = node.element;
+      var element = elementForConstructorDeclaration(node);
       var type = _emitAnnotatedFunctionType(element.type, node.metadata,
           parameters: node.parameters.parameters,
           nameType: options.hoistSignatureTypes,
           hoistType: options.hoistSignatureTypes,
           definite: true);
       var property = new JS.Property(memberName, type);
       tCtors.add(property);
     }
 
     JS.Property build(String name, List<JS.Property> elements) {
@@ skipping 51 matching lines @@
 
   /// Ensure `dartx.` symbols we will use are present.
   void _initExtensionSymbols(
       ClassElement classElem,
       List<MethodDeclaration> methods,
       List<FieldDeclaration> fields,
       List<JS.Statement> body) {
     if (_extensionTypes.hasNativeSubtype(classElem.type)) {
       var dartxNames = <JS.Expression>[];
       for (var m in methods) {
-        if (!m.isAbstract && !m.isStatic && m.element.isPublic) {
+        if (!m.isAbstract && !m.isStatic && elementForMethodDeclaration(m).isPublic) {
           dartxNames.add(_declareMemberName(m.element, useExtension: false));
         }
       }
       for (var fieldDecl in fields) {
         if (!fieldDecl.isStatic) {
           for (var field in fieldDecl.fields.variables) {
             var e = field.element as FieldElement;
             if (e.isPublic) {
               dartxNames.add(_declareMemberName(e.getter, useExtension: false));
             }
@@ skipping 41 matching lines @@
       Map<FieldElement, JS.TemporaryId> virtualFields) {
     // If we don't have a method body, skip this.
     var superCall = _superConstructorCall(node.element);
     if (fields.isEmpty && superCall == null) return null;
 
     var initFields = _initializeFields(node, fields, virtualFields);
     List<JS.Statement> body = [initFields];
     if (superCall != null) {
       body.add(superCall);
     }
-    var name = _constructorName(node.element.unnamedConstructor);
+    var name = _constructorName(elementForClassDeclaration(node).unnamedConstructor);
     return annotate(
         new JS.Method(name, js.call('function() { #; }', [body]) as JS.Fun),
         node,
         node.element);
   }
 
   JS.Method _emitConstructor(
       ConstructorDeclaration node,
       InterfaceType type,
       List<FieldDeclaration> fields,
       Map<FieldElement, JS.TemporaryId> virtualFields,
       bool isObject) {
     if (_externalOrNative(node)) return null;
 
     var name = _constructorName(node.element);
-    var returnType = emitTypeRef(node.element.enclosingElement.type);
+    var returnType = emitTypeRef(elementForConstructorDeclaration(node).enclosingElement.type);
 
     // Wacky factory redirecting constructors: factory Foo.q(x, y) = Bar.baz;
     var redirect = node.redirectedConstructor;
     if (redirect != null) {
-      var newKeyword = redirect.staticElement.isFactory ? '' : 'new';
+      var newKeyword = staticElementForConstructorReference(redirect).isFactory ? '' : 'new';
       // Pass along all arguments verbatim, and let the callee handle them.
       // TODO(jmesserly): we'll need something different once we have
       // rest/spread support, but this should work for now.
       var params =
           visitFormalParameterList(node.parameters, destructure: false);
 
       var fun = new JS.Fun(
           params,
           js.statement('{ return $newKeyword #(#); }',
               [_visit(redirect) as JS.Node, params]),
@@ skipping 88 matching lines @@
     var jsSuper = _superConstructorCall(cls.element, superCall);
     if (jsSuper != null) body.add(jsSuper);
 
     body.add(_visit(node.body));
     return new JS.Block(body)..sourceInformation = node;
   }
 
   @override
   JS.Statement visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
-    var ctor = node.staticElement;
+    var ctor = staticElementForConstructorReference(node);
     var cls = ctor.enclosingElement;
     // We can't dispatch to the constructor with `this.new` as that might hit a
     // derived class constructor with the same name.
     return js.statement('#.prototype.#.call(this, #);', [
       new JS.Identifier(cls.name),
       _constructorName(ctor),
       _visit(node.argumentList)
     ]);
   }
 
@@ skipping 156 matching lines @@
             _defaultParamValue(param),
           ]));
         } else if (param.kind == ParameterKind.POSITIONAL) {
           body.add(js.statement('if (# === void 0) # = #;',
               [jsParam, jsParam, _defaultParamValue(param)]));
         }
       }
 
       // TODO(jmesserly): various problems here, see:
       // https://github.com/dart-lang/dev_compiler/issues/116
-      var paramType = param.element.type;
+      var paramType = elementForFormalParameter(param).type;
       if (node is MethodDeclaration &&
-          (param.element.isCovariant || _unsoundCovariant(paramType, true)) &&
+          (elementForFormalParameter(param).isCovariant || _unsoundCovariant(paramType, true)) &&
           !_inWhitelistCode(node)) {
         var castType = _emitType(paramType,
             nameType: options.nameTypeTests || options.hoistTypeTests,
             hoistType: options.hoistTypeTests);
         body.add(js.statement('#._check(#);', [castType, jsParam]));
       }
     }
     return body.isEmpty ? null : _statement(body);
   }
 
@@ skipping 124 matching lines @@
     }
 
     var body = <JS.Statement>[];
     var fn = _emitFunction(node.functionExpression);
 
     if (currentLibrary.source.isInSystemLibrary &&
         _isInlineJSFunction(node.functionExpression)) {
       fn = _simplifyPassThroughArrowFunCallBody(fn);
     }
 
-    var element = node.element;
+    var element = elementForFunctionDeclaration(node);
     var nameExpr = _emitTopLevelName(element);
     body.add(annotate(js.statement('# = #', [nameExpr, fn]), node, element));
     if (!_isDartRuntime(element.library)) {
       body.add(_emitFunctionTagged(nameExpr, element.type, topLevel: true)
           .toStatement());
     }
 
     return _statement(body);
   }
 
@@ skipping 247 matching lines @@
     JS.Statement declareFn;
     if (JS.This.foundIn(fn)) {
       declareFn = js.statement('const # = #.bind(this);', [name, fn]);
     } else {
       declareFn = new JS.FunctionDeclaration(name, fn);
     }
     declareFn = annotate(declareFn, node, node.functionDeclaration.element);
 
     return new JS.Block([
       declareFn,
-      _emitFunctionTagged(name, func.element.type).toStatement()
+      _emitFunctionTagged(name, elementForFunctionDeclaration(func).type).toStatement()
     ]);
   }
 
   /// Emits a simple identifier, including handling an inferred generic
   /// function instantiation.
   @override
   JS.Expression visitSimpleIdentifier(SimpleIdentifier node) {
     var typeArgs = _getTypeArgs(node.staticElement, node.staticType);
     var simpleId = _emitSimpleIdentifier(node);
     if (typeArgs == null) {
       return simpleId;
     }
     return _callHelper('gbind(#, #)', [simpleId, typeArgs]);
   }
 
   /// Emits a simple identifier, handling implicit `this` as well as
   /// going through the qualified library name if necessary, but *not* handling
   /// inferred generic function instantiation.
   JS.Expression _emitSimpleIdentifier(SimpleIdentifier node) {
-    var accessor = node.staticElement;
+    var accessor = staticElementForIdentifier(node);
     if (accessor == null) {
       return js.commentExpression(
           'Unimplemented unknown name', new JS.Identifier(node.name));
     }
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
@@ skipping 510 matching lines @@
 
   /// Emits assignment to a simple identifier. Handles all legal simple
   /// identifier assignment targets (local, top level library member, implicit
   /// `this` or class, etc.)
   JS.Expression _emitSetSimpleIdentifier(
       SimpleIdentifier node, Expression rhs) {
     JS.Expression unimplemented() {
       return _badAssignment("Unimplemented: unknown name '$node'", node, rhs);
     }
 
-    var accessor = node.staticElement;
+    var accessor = staticElementForIdentifier(node);
     if (accessor == null) return unimplemented();
 
     // Get the original declaring element. If we had a property accessor, this
     // indirects back to a (possibly synthetic) field.
     var element = accessor;
     if (accessor is PropertyAccessorElement) element = accessor.variable;
 
     _declareBeforeUse(element);
 
     if (element is LocalVariableElement || element is ParameterElement) {
@@ skipping 141 matching lines @@
     }
 
     var result = _emitForeignJS(node);
     if (result != null) return result;
 
     var target = _getTarget(node);
     if (target == null || isLibraryPrefix(target)) {
       return _emitFunctionCall(node);
     }
     if (node.methodName.name == 'call') {
-      var targetType = target.staticType;
+      var targetType = staticTypeForExpression(target);
       if (targetType is FunctionType) {
         // Call methods on function types should be handled as regular function
         // invocations.
         return _emitFunctionCall(node, node.target);
       }
       if (targetType.isDartCoreFunction || targetType.isDynamic) {
         // TODO(vsm): Can a call method take generic type parameters?
         return _emitDynamicInvoke(node, _visit(target),
             _visit(node.argumentList) as List<JS.Expression>);
       }
@@ skipping 454 matching lines @@
 
   @override
   visitVariableDeclaration(VariableDeclaration node) {
     if (node.element is PropertyInducingElement) {
       // Static and instance fields are handled elsewhere.
       assert(node.element is TopLevelVariableElement);
       return _emitTopLevelField(node);
     }
 
     var name =
-        new JS.Identifier(node.name.name, type: emitTypeRef(node.element.type));
+        new JS.Identifier(node.name.name, type: emitTypeRef(elementForVariableDeclaration(node).type));
     return new JS.VariableInitialization(name, _visitInitializer(node));
   }
 
   /// Try to emit a constant static field.
   ///
   /// If the field's initializer does not cause side effects, and if all of
   /// dependencies are safe to refer to while we are initializing the class,
   /// then we can initialize it eagerly:
   ///
   ///     // Baz must be const constructor, and the name "Baz" must be defined
@@ skipping 196 matching lines @@
     var args = _visit(argumentList) as List<JS.Expression>;
     if (args.isEmpty) {
       return js.call('{}');
     }
     assert(args.single is JS.ObjectInitializer);
     return args.single;
   }
 
   @override
   visitInstanceCreationExpression(InstanceCreationExpression node) {
-    var element = node.staticElement;
+    var element = staticElementForConstructorReference(node);
     var constructor = node.constructorName;
     var name = constructor.name;
     var type = constructor.type.type;
     if (node.isConst &&
         element?.name == 'fromEnvironment' &&
         element.library.isDartCore) {
       var value = node.accept(_constants.constantVisitor);
 
       if (value == null || value.isNull) {
         return new JS.LiteralNull();
@@ skipping 1668 matching lines @@
 bool _isDeferredLoadLibrary(Expression target, SimpleIdentifier name) {
   if (name.name != "loadLibrary") return false;
 
   if (target is! SimpleIdentifier) return false;
   var targetIdentifier = target as SimpleIdentifier;
 
   if (targetIdentifier.staticElement is! PrefixElement) return false;
   var prefix = targetIdentifier.staticElement as PrefixElement;
 
   // The library the prefix is referring to must come from a deferred import.
-  var containingLibrary = (target.root as CompilationUnit).element.library;
+  var containingLibrary = elementForCompilationUnit(target.root as CompilationUnit).library;
   var imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }