implement mixins in subtype checks, more codegen fixes

lib/src/codegen/js_codegen.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.
 
 library dev_compiler.src.codegen.js_codegen;
 
 import 'dart:collection' show HashSet, HashMap;
 import 'dart:io' show Directory, File;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
@@ skipping 50 matching lines @@
   ConstantEvaluator _constEvaluator;
 
   final _exports = <String>[];
   final _lazyFields = <VariableDeclaration>[];
   final _properties = <FunctionDeclaration>[];
   final _privateNames = new HashSet<String>();
   final _pendingPrivateNames = <String>[];
 
   /// Classes we have not emitted yet. Values can be [ClassDeclaration] or
   /// [ClassTypeAlias].
-  final _pendingClasses = new HashMap<ClassElement, CompilationUnitMember>();
+  final _pendingClasses = new HashMap<Element, CompilationUnitMember>();
 
   /// Memoized results of [_lazyClass].
-  final _lazyClassMemo = new HashMap<ClassElement, bool>();
+  final _lazyClassMemo = new HashMap<Element, bool>();
 
   /// Memoized results of [_inLibraryCycle].
   final _libraryCycleMemo = new HashMap<LibraryElement, bool>();
 
   JSCodegenVisitor(this.libraryInfo, this.rules, this._checkerReporter);
 
   LibraryElement get currentLibrary => libraryInfo.library;
 
   /// The name for the library's exports inside itself.
   /// This much be a constant because we interpolate it into template strings,
@@ skipping 16 matching lines @@
         }
       }
     }
     var body = <JS.Statement>[];
 
     // Collect classes we need to emit, used for:
     // * tracks what we've emitted so we don't emit twice
     // * provides a mapping from ClassElement back to the ClassDeclaration.
     for (var unit in library.partsThenLibrary) {
       for (var decl in unit.declarations) {
-        if (decl is ClassDeclaration || decl is ClassTypeAlias) {
+        if (decl is ClassDeclaration ||
+            decl is ClassTypeAlias ||
+            decl is FunctionTypeAlias) {
           _pendingClasses[decl.element] = decl;
         }
       }
     }
 
     for (var unit in library.partsThenLibrary) body.add(_visit(unit));
 
     assert(_pendingClasses.isEmpty);
 
     if (_exports.isNotEmpty) body.add(js.comment('Exports:'));
@@ skipping 131 matching lines @@
 
   String _jsTypeofName(DartType t) {
     if (rules.isIntType(t) || rules.isDoubleType(t)) return 'number';
     if (rules.isStringType(t)) return 'string';
     if (rules.isBoolType(t)) return 'boolean';
     return null;
   }
 
   @override
   visitFunctionTypeAlias(FunctionTypeAlias node) {
-    // TODO(vsm): Do we need to record type info the generated code for a

[Jennifer Messerly, 2015/04/01 22:31:31]

all of these changes were because we do a type check against Comparator in
corelib. Hah.

-    // typedef?
+    // If we've already emitted this class, skip it.
+    var type = node.element.type;
+    if (_pendingClasses.remove(node.element) == null) return null;
+
+    var classDecl = new JS.ClassDeclaration(new JS.ClassExpression(

[Jennifer Messerly, 2015/04/01 22:31:31]

not sure if class is really what we want long term, but it's something.

[vsm, 2015/04/01 23:04:57]

We might want this to be some sort of type object.

[Jennifer Messerly, 2015/04/01 23:22:56]

yeah, something that is an instance of Type. Right now classes do that for us,
but there's other ways we could represent it that are probably easier.

The reason I started with classes is they already have generic support.

+        new JS.Identifier(type.name),
+        _emitTypeName(rules.provider.functionType), []));
+
+    return _finishClassDef(type, classDecl);
   }
 
   @override
   JS.Expression visitTypeName(TypeName node) => _emitTypeName(node.type);
 
   @override
   JS.Statement visitClassTypeAlias(ClassTypeAlias node) {
     // If we've already emitted this class, skip it.
-    var classElem = node.element;
-    if (_pendingClasses.remove(classElem) == null) return null;
+    var type = node.element.type;
+    if (_pendingClasses.remove(node.element) == null) return null;
 
     var name = node.name.name;
     var heritage =
         js.call('dart.mixin(#)', [_visitList(node.withClause.mixinTypes)]);
     var classDecl = new JS.ClassDeclaration(
         new JS.ClassExpression(new JS.Identifier(name), heritage, []));
 
-    return _finishClassDef(classElem, classDecl);
+    return _finishClassDef(type, classDecl);
   }
 
   @override
   JS.Statement visitClassDeclaration(ClassDeclaration node) {
     // If we've already emitted this class, skip it.
-    var classElem = node.element;
-    if (_pendingClasses.remove(classElem) == null) return null;
+    var type = node.element.type;
+    if (_pendingClasses.remove(node.element) == null) return null;
     if (_getJsNameAnnotation(node) != null) return null;
 
     currentClass = node;
 
     var ctors = <ConstructorDeclaration>[];
     var fields = <FieldDeclaration>[];
     var staticFields = <FieldDeclaration>[];
     for (var member in node.members) {
       if (member is ConstructorDeclaration) {
         ctors.add(member);
       } else if (member is FieldDeclaration) {
         (member.isStatic ? staticFields : fields).add(member);
       }
     }
 
-    var classExpr = new JS.ClassExpression(new JS.Identifier(classElem.name),
+    var classExpr = new JS.ClassExpression(new JS.Identifier(type.name),
         _classHeritage(node), _emitClassMethods(node, ctors, fields));
 
-    var body = _finishClassMembers(classElem, classExpr, ctors, staticFields);
+    var body =
+        _finishClassMembers(node.element, classExpr, ctors, staticFields);
     currentClass = null;
 
-    return _finishClassDef(classElem, body);
+    return _finishClassDef(type, body);
   }
 
   @override
   JS.Statement visitEnumDeclaration(EnumDeclaration node) =>
       _unimplementedCall("Unimplemented enum: $node").toStatement();
 
   /// Given a class element and body, complete the class declaration.
   /// This handles generic type parameters, laziness (in library-cycle cases),
   /// and ensuring dependencies are loaded first.
-  JS.Statement _finishClassDef(ClassElement classElem, JS.Statement body) {
-    var name = classElem.name;
+  JS.Statement _finishClassDef(ParameterizedType type, JS.Statement body) {
+    var name = type.name;
     var genericName = '$name\$';
 
     JS.Statement genericDef;
     JS.Expression genericInst;
-    if (classElem.typeParameters.isNotEmpty) {
-      genericDef = _emitGenericClassDef(classElem, body);
-      var dynamicArgs = new List.filled(
-          classElem.typeParameters.length, js.call('dart.dynamic'));

[vsm, 2015/04/01 23:04:57]

Shouldn't we fill in with core.Object?

[Jennifer Messerly, 2015/04/01 23:22:56]

It's handled in dart_runtime by the generic function. We can change it to
whatever. But regardless, there's no value in emitting it here.

I'm happy with core.Object, but I thought we left the discussion as: keep
dart.dynamic, but generally treat it the same as Object in type tests, except
for the function parameter case.

Where the user would see this:


typedef void MyFunc<B>(B b);

class Foo<B> {
  void foo(MyFunc<B> f) {  
  }
}

new Foo().foo(...)

Did we substitute dynamic for B in that function type?

[vsm, 2015/04/01 23:34:47]

If we have x is T somewhere in the body of the class, we're instantiating T with
undefined if we omit, right?  Are we mapping undefined to Object somewhere?
Semantically, we want Object for B.  I.e.,:

dynamic f = (int x) => print(x+x);
new Foo().foo(f);

should fail as int->void is not a subtype of Object->void (but is of
dynamic->void).

[Jennifer Messerly, 2015/04/02 16:11:08]

yes, like I said it happens in dart_runtime :)
https://github.com/dart-lang/dev_compiler/blob/master/lib/runtime/dart_runtim...
In other words, I haven't changed any behavior, I'm just removing some
unnecessary codegen.
Yeah, sounds good to me. It's different from this CL but I'm happy to change
that line from dart_runtime.js, whenever is a good time.

[vsm, 2015/04/02 16:30:54]

Aha!  :-)

-
+    if (type.typeParameters.isNotEmpty) {
+      genericDef = _emitGenericClassDef(type, body);
       var target = genericName;
-      if (_needQualifiedName(classElem)) {
+      if (_needQualifiedName(type.element)) {
         target = js.call('#.#', [_exportsVar, genericName]);
       }
-      genericInst = js.call('#(#)', [target, dynamicArgs]);
+      genericInst = js.call('#()', [target]);
     }
 
     // The base class and all mixins must be declared before this class.
-    if (_lazyClass(classElem)) {
+    if (_lazyClass(type)) {
       // TODO(jmesserly): the lazy class def is a simple solution for now.
       // We may want to consider other options in the future.
 
       if (genericDef != null) {
         return js.statement(
             '{ #; dart.defineLazyClassGeneric(#, #, { get: # }); }', [
           genericDef,
           _exportsVar,
           js.string(name, "'"),
           genericName
         ]);
       }
 
       return js.statement(
           'dart.defineLazyClass(#, { get #() { #; return #; } });', [
         _exportsVar,
         _propertyName(name),
         body,
         name
       ]);
     }
 
     if (isPublic(name)) _exports.add(name);
 
     if (genericDef != null) {
       body = js.statement('{ #; let # = #; }', [genericDef, name, genericInst]);
-      if (isPublic(name)) _exports.add(genericName);
     }
 
-    if (classElem.type.isObject) return body;
+    if (type.isObject) return body;
 
     // If we're not lazy, we still need to ensure our dependencies are
     // generated first.
     var classDefs = <JS.Statement>[];
-    _emitClassIfNeeded(classDefs, classElem.supertype.element);
-    for (var m in classElem.mixins) {
-      _emitClassIfNeeded(classDefs, m.element);
+    if (type is InterfaceType) {
+      _emitClassIfNeeded(classDefs, type.superclass);
+      for (var m in type.element.mixins) {
+        _emitClassIfNeeded(classDefs, m);
+      }
+    } else if (type is FunctionType) {
+      _emitClassIfNeeded(classDefs, rules.provider.functionType);
     }
     classDefs.add(body);
     return _statement(classDefs);
   }
 
-  void _emitClassIfNeeded(List<JS.Statement> defs, ClassElement base) {
+  void _emitClassIfNeeded(List<JS.Statement> defs, DartType base) {
     // We can only emit classes from this library.
-    if (base.library != currentLibrary) return;
+    if (base.element.library != currentLibrary) return;
 
-    var baseNode = _pendingClasses[base];
+    var baseNode = _pendingClasses[base.element];
     if (baseNode != null) defs.add(visitClassDeclaration(baseNode));
   }
 
   /// Returns true if the supertype or mixins aren't loaded.
   /// If that is the case, we'll emit a lazy class definition.
-  bool _lazyClass(ClassElement cls) {
-    if (cls.type.isObject) return false;
+  bool _lazyClass(DartType type) {
+    if (type.isObject) return false;
 
-    assert(cls.library == currentLibrary);
-    var result = _lazyClassMemo[cls];
+    // Use the element as the key, as those are unique whereas generic types
+    // can have their arguments substituted.
+    assert(type.element.library == currentLibrary);
+    var result = _lazyClassMemo[type.element];
     if (result != null) return result;
 
-    result = _classMightNotBeLoaded(cls.supertype.element);
-    for (var mixin in cls.mixins) {
-      if (result) break;
-      result = _classMightNotBeLoaded(mixin.element);
+    if (type is InterfaceType) {
+      result = _typeMightNotBeLoaded(type.superclass) ||
+          type.mixins.any(_typeMightNotBeLoaded);
+    } else if (type is FunctionType) {
+      result = _typeMightNotBeLoaded(rules.provider.functionType);
     }
-    return _lazyClassMemo[cls] = result;
+    return _lazyClassMemo[type.element] = result;
   }
 
   /// Curated order to minimize lazy classes needed by dart:core and its
   /// transitive SDK imports.
   static const CORELIB_ORDER = const [
     'dart.core',
     'dart.collection',
     'dart._internal'
   ];
 
   /// Returns true if the class might not be loaded.
   ///
   /// If the class is from our library, this can happen because it's lazy.
   ///
   /// If the class is from a different library, it could happen if we're in
   /// a library cycle. In other words, if that different library depends back
   /// on this library via some transitive import path.
   ///
   /// If we could control the global import ordering, we could eliminate some
   /// of these cases, by ordering the imports of the cyclic libraries in an
   /// optimal way. For example, we could order the libraries in a cycle to
   /// minimize laziness. However, we currently assume we cannot control the
   /// order that the cycle of libraries will be loaded in.
-  bool _classMightNotBeLoaded(ClassElement cls) {
-    if (cls.library == currentLibrary) return _lazyClass(cls);
+  bool _typeMightNotBeLoaded(DartType type) {
+    var library = type.element.library;
+    if (library == currentLibrary) return _lazyClass(type);
 
     // The SDK is a special case: we optimize the order to prevent laziness.
-    if (cls.library.isInSdk) {
+    if (library.isInSdk) {
       // SDK is loaded before non-SDK libraies
       if (!currentLibrary.isInSdk) return false;
 
       // Compute the order of both SDK libraries. If unknown, assume it's after.
-      var classOrder = CORELIB_ORDER.indexOf(cls.library.name);
+      var classOrder = CORELIB_ORDER.indexOf(library.name);
       if (classOrder == -1) classOrder = CORELIB_ORDER.length;
 
       var currentOrder = CORELIB_ORDER.indexOf(currentLibrary.name);
       if (currentOrder == -1) currentOrder = CORELIB_ORDER.length;
 
       // If the dart:* library we are currently compiling is loaded after the
       // class's library, then we know the class is available.
       if (classOrder != currentOrder) return currentOrder < classOrder;
 
       // If we don't know the order of the class's library or the current
       // library, do the normal cycle check. (Not all SDK libs are cycles.)
     }
 
-    return _inLibraryCycle(cls.library);
+    return _inLibraryCycle(library);
   }
 
   /// Returns true if [library] depends on the [currentLibrary] via some
   /// transitive import.
   bool _inLibraryCycle(LibraryElement library) {
     // SDK libs don't depend on things outside the SDK.
     // (We can reach this via the recursive call below.)
     if (library.isInSdk && !currentLibrary.isInSdk) return false;
 
     var result = _libraryCycleMemo[library];
     if (result != null) return result;
 
     result = library == currentLibrary;
     _libraryCycleMemo[library] = result;
     for (var e in library.imports) {
       if (result) break;
       result = _inLibraryCycle(e.importedLibrary);
     }
     for (var e in library.exports) {
       if (result) break;
       result = _inLibraryCycle(e.exportedLibrary);
     }
     return _libraryCycleMemo[library] = result;
   }
 
-  JS.Statement _emitGenericClassDef(ClassElement cls, JS.Statement body) {
-    var name = cls.name;
+  JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
+    var name = type.name;
     var genericName = '$name\$';
-    var typeParams = cls.typeParameters.map((p) => p.name);
+    var typeParams = type.typeParameters.map((p) => p.name);
+    if (isPublic(name)) _exports.add(genericName);
     return js.statement('let # = dart.generic(function(#) { #; return #; });', [
       genericName,
       typeParams,
       body,
       name
     ]);
   }
 
   JS.Expression _classHeritage(ClassDeclaration node) {
     if (node.element.type.isObject) return null;
@@ skipping 136 matching lines @@
       // Instead we use the same trick as named constructors, and do them as
       // instance methods that perform initialization.
       // TODO(jmesserly): we'll need to rethink this once the ES6 spec and V8
       // settles. See <https://github.com/dart-lang/dev_compiler/issues/51>.
       // Performance of this pattern is likely to be bad.
       name = js.string('constructor', "'");
       // Mark the parameter as no-rename.
       var args = new JS.Identifier('arguments', allowRename: false);
       body = js.statement('''{
         // Get the class name for this instance.
-        var name = this.constructor.name;
+        let name = this.constructor.name;
         // Call the default constructor.
-        var init = this[name];
-        var result = void 0;
+        let init = this[name];
+        let result = void 0;
         if (init) result = init.apply(this, #);
         return result === void 0 ? this : result;
       }''', args);
     } else {
       body = _emitConstructorBody(node, fields);
     }
 
     // We generate constructors as initializer methods in the class;
     // this allows use of `super` for instance methods/properties.
     // It also avoids V8 restrictions on `super` in default constructors.
@@ skipping 367 matching lines @@
     }
 
     if (typeArgs != null) {
       result = js.call('#(#)', [result, typeArgs]);
     }
     return result;
   }
 
   bool _needQualifiedName(Element element) {
     var lib = element.library;
-
-    return lib != null &&
-        (lib != currentLibrary ||
-            element is ClassElement && _lazyClass(element));
+    if (lib == null) return false;
+    if (lib != currentLibrary) return true;
+    if (element is ClassElement) return _lazyClass(element.type);
+    if (element is FunctionTypeAliasElement) return _lazyClass(element.type);
+    return false;
   }
 
   JS.Node _emitDPutIfDynamic(
       Expression target, SimpleIdentifier id, Expression rhs) {
     if (rules.isDynamicTarget(target)) {
       return js.call('dart.dput(#, #, #)', [
         _visit(target),
         js.string(id.name, "'"),
         _visit(rhs)
       ]);
@@ skipping 1341 matching lines @@
 
     // TODO(jmesserly): in many cases marking the end will be unncessary.
     printer.mark(_location(node.end));
   }
 
   String _getIdentifier(AstNode node) {
     if (node is SimpleIdentifier) return node.name;
     return null;
   }
 }