Support lazy JS types.

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';
@@ skipping 290 matching lines @@
     items.addAll(_typeTable.discharge());
 
     // Add the module's code (produced by visiting compilation units, above)
     _copyAndFlattenBlocks(items, _moduleItems);
 
     // Build the module.
     return new JS.Program(items, name: _buildUnit.name);
   }
 
   List<String> _getJSName(Element e) {
-    if (findAnnotation(e.library, isPublicJSAnnotation) == null) {
+    if (e.library == null ||
+        findAnnotation(e.library, isPublicJSAnnotation) == null) {
       return null;
     }
 
     var libraryJSName = getAnnotationName(e.library, isPublicJSAnnotation);
     var libraryPrefix = <String>[];
     if (libraryJSName != null && libraryJSName.isNotEmpty) {
       libraryPrefix.addAll(libraryJSName.split('.'));
     }
 
     String elementJSName;
     if (findAnnotation(e, isPublicJSAnnotation) != null) {
       elementJSName = getAnnotationName(e, isPublicJSAnnotation) ?? '';
     }
+
     if (e is TopLevelVariableElement &&
         e.getter != null &&
         (e.getter.isExternal ||
             findAnnotation(e.getter, isPublicJSAnnotation) != null)) {
       elementJSName = getAnnotationName(e.getter, isPublicJSAnnotation) ?? '';
     }
     if (elementJSName == null) return null;
 
     var elementJSParts = <String>[];
     if (elementJSName.isNotEmpty) {
@@ skipping 2363 matching lines @@
 
     var name = element.name;
 
     // Unqualified class member. This could mean implicit-this, or implicit
     // call to a static from the same class.
     if (element is ClassMemberElement && element is! ConstructorElement) {
       bool isStatic = element.isStatic;
       var type = element.enclosingElement.type;
       var member = _emitMemberName(name, isStatic: isStatic, type: type);
 
-      // For static methods, we add the raw type name, without generics or
-      // library prefix. We don't need those because static calls can't use
-      // the generic type.
       if (isStatic) {
-        var dynType = _emitType(fillDynamicTypeArgs(type));
+        var dynType = _emitStaticAccess(type);
         return new JS.PropertyAccess(dynType, member);
       }
 
       // For instance members, we add implicit-this.
       // For method tear-offs, we ensure it's a bound method.
       var tearOff = element is MethodElement && !inInvocationContext(node);
       if (tearOff) return _callHelper('bind(this, #)', member);
       return js.call('this.#', member);
     }
 
@@ skipping 178 matching lines @@
         ];
       } else {
         typeParts = [
           js.call('(#) => {#; return #;}', [tf, names, parts])
         ];
       }
     }
     return typeParts;
   }
 
+  /// Emits an expression that lets you access statics on a [type] from code.
+  ///
+  /// If [nameType] is true, then the type will be named.  In addition,
+  /// if [hoistType] is true, then the named type will be hoisted.
+  JS.Expression _emitConstructorAccess(DartType type,
+      {bool nameType: true, bool hoistType: true}) {
+    return _emitJSInterop(type.element) ??
+        _emitType(type, nameType: nameType, hoistType: hoistType);
+  }
+
+  /// Emits an expression that lets you access statics on a [type] from code.
+  JS.Expression _emitStaticAccess(DartType type) {
+    // Make sure we aren't attempting to emit a static access path to a type
+    // that does not have a valid static access path.
+    assert(!type.isVoid &&
+        !type.isDynamic &&
+        !type.isBottom &&
+        type is! TypeParameterType);
+
+    // For statics, we add the raw type name, without generics or
+    // library prefix. We don't need those because static calls can't use
+    // the generic type.
+    type = fillDynamicTypeArgs(type);
+    var element = type.element;
+    _declareBeforeUse(element);
+
+    var interop = _emitJSInterop(element);
+    if (interop != null) return interop;
+
+    assert(type.name != '' && type.name != null);
+
+    return _emitTopLevelNameNoInterop(element);
+  }
+
   /// Emits a Dart [type] into code.
   ///
   /// If [lowerTypedef] is set, a typedef will be expanded as if it were a
   /// function type. Similarly if [lowerGeneric] is set, the `List$()` form
   /// will be used instead of `List`. These flags are used when generating
   /// the definitions for typedefs and generic types, respectively.
   ///
   /// If [subClass] is set, then we are setting the base class for the given
   /// class and should emit the given [className], which will already be
   /// defined.
   ///
   /// If [nameType] is true, then the type will be named.  In addition,
   /// if [hoistType] is true, then the named type will be hoisted.
   JS.Expression _emitType(DartType type,
       {bool lowerTypedef: false,
       bool lowerGeneric: false,
       bool nameType: true,
       bool hoistType: true,
       ClassElement subClass,
       JS.Expression className}) {
     // The void and dynamic types are not defined in core.
     if (type.isVoid) {
       return _callHelper('void');
     } else if (type.isDynamic) {
       return _callHelper('dynamic');
     } else if (type.isBottom) {
       return _callHelper('bottom');
     }
 
-    _declareBeforeUse(type.element);
+    var element = type.element;
+    _declareBeforeUse(element);
+
+    var interop = _emitJSInterop(element);
+    // Type parameters don't matter as JS interop types cannot be reified.
+    // We have to use lazy JS types because until we have proper module
+    // loading for JS libraries bundled with Dart libraries, we will sometimes
+    // need to load Dart libraries before the corresponding JS libraries are
+    // actually loaded.
+    // Given a JS type such as:
+    //     @JS('google.maps.Location')
+    //     class Location { ... }
+    // We can't emit a reference to MyType because the JS library that defines
+    // it may be loaded after our code. So for now, we use a special lazy type
+    // object to represent MyType.
+    // Anonymous JS types do not have a corresponding concrete JS type so we
+    // have to use a helper to define them.
+    if (interop != null) {
+      if (_isObjectLiteral(element)) {
+        return _callHelper(
+            'lazyAnonymousJSType(#)', js.string(element.displayName));
+      } else {
+        return _callHelper('lazyJSType(() => #, #)',
+            [interop, js.string(_getJSName(element).join('.'))]);
+      }
+    }
 
     // TODO(jmesserly): like constants, should we hoist function types out of
     // methods? Similar issue with generic types. For all of these, we may want
     // to canonicalize them too, at least when inside the same library.
     var name = type.name;
-    var element = type.element;
     if (name == '' || name == null || lowerTypedef) {
       // TODO(jmesserly): should we change how typedefs work? They currently
       // go through use similar logic as generic classes. This makes them
       // different from universal function types.
       return _emitFunctionType(type as FunctionType,
           lowerTypedef: lowerTypedef, nameType: nameType, hoistType: hoistType);
     }
 
     if (type is TypeParameterType) {
       _typeParamInConst?.add(type);
       return new JS.Identifier(name);
     }
 
-    if (type == subClass?.type) {
-      return className;
-    }
+    if (type == subClass?.type) return className;
 
     if (type is ParameterizedType) {
       var args = type.typeArguments;
       Iterable jsArgs = null;
       if (args.any((a) => !a.isDynamic)) {
         jsArgs = args.map((x) => _emitType(x,
             nameType: nameType,
             hoistType: hoistType,
             subClass: subClass,
             className: className));
       } else if (lowerGeneric || element == subClass) {
         jsArgs = [];
       }
       if (jsArgs != null) {
         var genericName = _emitTopLevelName(element, suffix: '\$');
         var typeRep = js.call('#(#)', [genericName, jsArgs]);
         return nameType
             ? _typeTable.nameType(type, typeRep, hoistType: hoistType)
             : typeRep;
       }
     }
 
-    return _emitTopLevelName(element);
+    return _emitTopLevelNameNoInterop(element);
   }
 
   JS.PropertyAccess _emitTopLevelName(Element e, {String suffix: ''}) {
     var interop = _emitJSInterop(e);
     if (interop != null) return interop;
+    return _emitTopLevelNameNoInterop(e, suffix: suffix);
+  }
+
+  JS.PropertyAccess _emitTopLevelNameNoInterop(Element e, {String suffix: ''}) {
     String name = getJSExportName(e) + suffix;
     return new JS.PropertyAccess(
         emitLibraryName(e.library), _propertyName(name));
   }
 
   @override
   JS.Expression visitAssignmentExpression(AssignmentExpression node) {
     var left = node.leftHandSide;
     var right = node.rightHandSide;
     if (node.operator.type == TokenType.EQ) return _emitSet(left, right);
@@ skipping 203 matching lines @@
   }
 
   /// Emits assignment to a static field element or property.
   JS.Expression _emitSetStaticProperty(
       Expression lhs, Element element, Expression rhs) {
     // For static methods, we add the raw type name, without generics or
     // library prefix. We don't need those because static calls can't use
     // the generic type.
     ClassElement classElement = element.enclosingElement;
     var type = classElement.type;
-    var dynType = _emitType(fillDynamicTypeArgs(type));
+    var dynType = _emitStaticAccess(type);
     var member = _emitMemberName(element.name, isStatic: true, type: type);
     return _visit(rhs).toAssignExpression(
         annotate(new JS.PropertyAccess(dynType, member), lhs));
   }
 
   /// Emits an assignment to the [element] property of instance referenced by
   /// [jsTarget].
   JS.Expression _emitWriteInstanceProperty(Expression lhs,
       JS.Expression jsTarget, Element element, JS.Expression value) {
     String memberName = element.name;
@@ skipping 130 matching lines @@
   JS.Expression _getSuperHelperFor(String name, JS.Expression forwardedCall,
       List<JS.Expression> helperArgs) {
     var helperMethod =
         new JS.Fun(helperArgs, new JS.Block([new JS.Return(forwardedCall)]));
     var helperMethodName = new JS.TemporaryId('super\$$name');
     _superHelperSymbols.add(helperMethodName);
     _superHelpers.add(new JS.Method(helperMethodName, helperMethod));
     return helperMethodName;
   }
 
+  JS.Expression _emitTarget(Expression target, Element element, bool isStatic) {
+    if (isStatic) {
+      if (element is ConstructorElement) {
+        return _emitConstructorAccess(element.enclosingElement.type);
+      }
+      if (element is ExecutableElement) {
+        return _emitStaticAccess(
+            (element.enclosingElement as ClassElement).type);
+      }
+    }
+    return _visit(target);
+  }
+
   /// Emits a (possibly generic) instance method call.
   JS.Expression _emitMethodCallInternal(
       Expression target,
       MethodInvocation node,
       List<JS.Expression> args,
       List<JS.Expression> typeArgs) {
     var type = getStaticType(target);
     var name = node.methodName.name;
     var element = node.methodName.staticElement;
     bool isStatic = element is ExecutableElement && element.isStatic;
     var memberName = _emitMemberName(name, type: type, isStatic: isStatic);
 
-    JS.Expression jsTarget = _visit(target);
+    JS.Expression jsTarget = _emitTarget(target, element, isStatic);
     if (isDynamicInvoke(target) || isDynamicInvoke(node.methodName)) {
       if (_inWhitelistCode(target)) {
         var vars = <JS.MetaLetVariable, JS.Expression>{};
         var l = _visit(_bindValue(vars, 'l', target));
         jsTarget = new JS.MetaLet(vars, [
           js.call('(#[(#[#._extensionType]) ? #[#] : #]).bind(#)', [
             l,
             l,
             _runtimeModule,
             _extensionSymbolsModule,
@@ skipping 504 matching lines @@
           : parent.getSetter(element.name);
     }
     return null;
   }
 
   JS.Expression _emitConstructorName(
       ConstructorElement element, DartType type, SimpleIdentifier name) {
     var classElem = element.enclosingElement;
     var interop = _emitJSInterop(classElem);
     if (interop != null) return interop;
-    var typeName = _emitType(type);
+    var typeName = _emitConstructorAccess(type);
     if (name != null || element.isFactory) {
       var namedCtor = _constructorName(element);
       return new JS.PropertyAccess(typeName, namedCtor);
     }
     return typeName;
   }
 
   @override
   visitConstructorName(ConstructorName node) {
     return _emitConstructorName(node.staticElement, node.type.type, node.name);
   }
 
   JS.Expression _emitInstanceCreationExpression(
       ConstructorElement element,
       DartType type,
       SimpleIdentifier name,
       ArgumentList argumentList,
       bool isConst) {
     JS.Expression emitNew() {
       JS.Expression ctor;
       bool isFactory = false;
       bool isNative = false;
       if (element == null) {
         // TODO(jmesserly): this only happens if we had a static error.
         // Should we generate a throw instead?
-        ctor = _emitType(type,
+        ctor = _emitConstructorAccess(type,
             nameType: options.hoistInstanceCreation,
             hoistType: options.hoistInstanceCreation);
         if (name != null) {
           ctor = new JS.PropertyAccess(ctor, _propertyName(name.name));
         }
       } else {
         ctor = _emitConstructorName(element, type, name);
         isFactory = element.isFactory;
         var classElem = element.enclosingElement;
         isNative = _isJSNative(classElem);
@@ skipping 803 matching lines @@
         var l = _visit(_bindValue(vars, 'l', target));
         return new JS.MetaLet(vars, [
           js.call('(#[#._extensionType]) ? #[#[#]] : #.#',
               [l, _runtimeModule, l, _extensionSymbolsModule, name, l, name])
         ]);
       }
       return _callHelper('#(#, #)',
           [_emitDynamicOperationName('dload'), _visit(target), name]);
     }
 
-    var jsTarget = _visit(target);
+    var jsTarget = _emitTarget(target, member, isStatic);
     bool isSuper = jsTarget is JS.Super;
 
     if (isSuper && member is FieldElement && !member.isSynthetic) {
       // If super.x is actually a field, then x is an instance property since
       // subclasses cannot override x.
       jsTarget = new JS.This();
     }
 
     JS.Expression result;
     if (member != null && member is MethodElement && !isStatic) {
@@ skipping 353 matching lines @@
 
   @override
   visitNullLiteral(NullLiteral node) => new JS.LiteralNull();
 
   @override
   visitSymbolLiteral(SymbolLiteral node) {
     JS.Expression emitSymbol() {
       // TODO(vsm): When we canonicalize, we need to treat private symbols
       // correctly.
       var name = js.string(node.components.join('.'), "'");
-      return js.call('#.new(#)', [_emitType(types.symbolType), name]);
+      return js
+          .call('#.new(#)', [_emitConstructorAccess(types.symbolType), name]);
     }
 
     return _emitConst(emitSymbol);
   }
 
   @override
   visitListLiteral(ListLiteral node) {
     var isConst = node.constKeyword != null;
     JS.Expression emitList() {
       JS.Expression list = new JS.ArrayInitializer(
@@ skipping 507 matching lines @@
   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 imports = containingLibrary.getImportsWithPrefix(prefix);
   return imports.length == 1 && imports[0].isDeferred;
 }