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 ||

[Jennifer Messerly, 2016/11/22 18:18:19]

nice fix. I'm curious, do you know how this happens? I would expect every
element to belong to a library, even in erroneous code.

[Jacob, 2016/11/22 18:51:37]

I suspect one of dynamic or bottom doesn't show up as a specific library given
I'm now checking for interop before checking for those types.

+        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.

[Jennifer Messerly, 2016/11/22 18:18:19]

comment nit: I don't think you want two brackets, [type] should be enough

[Jacob, 2016/11/22 18:51:37]

[[[done]]]

+  ///
+  /// 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,

[Jennifer Messerly, 2016/11/22 18:18:19]

just wanted to say, this is factored in a lovely way :)

_emitStaticAccess and _emitConstructorAccess read so nicely!

[Jacob, 2016/11/22 18:51:36]

yay!

+      {bool nameType: true, bool hoistType: true}) {
+    var interop = _emitJSInterop(type.element);

[Jennifer Messerly, 2016/11/22 18:18:19]

this could be:


return _emitJSInterop(type.element) ??
    _emitType(type, nameType: nameType, hoistType: hoistType);

not sure if better but something to consider :)

[Jacob, 2016/11/22 18:51:36]

Done.

+    if (interop != null) return interop;
+
+    // TODO(jacobr): we could consider duplicating logic instead of calling

[Jennifer Messerly, 2016/11/22 18:18:19]

personally I'm not sure we need this TODO ... we can always split out the logic
when an actual divergence happens, until then it's nice to reuse as much code as
possible. Less copies == goodness :)

[Jacob, 2016/11/22 18:51:36]

sounds good. My only concern is that this is only alright because certain code
paths inside _emitType are never hit (the JS interop ones) which seems like a
code smell.
Perhaps slightly cleaner and a tiny optimization  would be to add an 
_emitTypeNoInterop helper that doesn't perform the interop checks.

+    // through to the somewhat unrelated _emitType mode. Calling _emitType here
+    // is acceptable as the type cannot be a JS interop type.
+    return _emitType(type, nameType: nameType, hoistType: hoistType);
+  }
+
+  /// Emits an expression that lets you access statics on a [[type]] from code.

[Jennifer Messerly, 2016/11/22 18:18:19]

comment nit again: [type] instead of [[type]]

[Jacob, 2016/11/22 18:51:36]

Done.

+  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.

[Jennifer Messerly, 2016/11/22 18:18:19]

should we error out if the type is generic?

I'm guessing it won't be, because that wouldn't work.

[Jacob, 2016/11/22 18:51:36]

Would really like to allow it assuming JS interop generics are allowed but are
unreified. For example:

@JS()
class Foo<T> {
  external T get foo;
}

A type check for Foo<num> will with this code just become a type check for Foo
which is what you want as generics on JS types are not reified.

+    // We have to use lazy JS types because until we have proper module

[Jennifer Messerly, 2016/11/22 18:18:19]

This comment is good, but maybe a code example would help? I'm thinking of a way
to make it more clear to someone new to the compiler codebase. Perhaps like
this:

// Given a JS type such as:
//     @JS('MyType')
//     class MyType { ... }
// We can't emit a reference to MyType because the JS file that defines it
// may be loaded after our code, and we can't import the JS module yet.
// So for now, we use a special lazy type object to represent MyType.

[Jacob, 2016/11/22 18:51:37]

Done.

+    // loading for JS libraries bundled with Dart libraries, we will sometimes
+    // need to load Dart libraries before the corresponding JS libraries are
+    // actually loaded.
+    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;

[Jennifer Messerly, 2016/11/22 18:18:19]

nice!

[Jacob, 2016/11/22 18:51:36]

Acknowledged.

 
     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 59 matching lines @@
   visitMethodInvocation(MethodInvocation node) {
     if (_isDeferredLoadLibrary(node.target, node.methodName)) {
       // We are calling loadLibrary() on a deferred library prefix.
       return _callHelper('loadLibrary()');
     }
 
     if (node.operator?.lexeme == '?.') {
       return _emitNullSafe(node);
     }
 
+    // SSS

[Jennifer Messerly, 2016/11/22 18:18:19]

remove this?

[Jacob, 2016/11/22 18:51:37]

Done.

     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;
       if (targetType is FunctionType) {
@@ skipping 51 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);

[Jennifer Messerly, 2016/11/22 18:18:19]

style nit: should have curly braces if it's more than one line

[Jacob, 2016/11/22 18:51:36]

Done.

+      if (element is ExecutableElement)
+        return _emitStaticAccess(

[Jennifer Messerly, 2016/11/22 18:18:19]

same here

[Jacob, 2016/11/22 18:51:36]

Done.

+            (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;
 }