Initial support for f-bound quantification patterns

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, SplayTreeSet;
 
 import 'package:analyzer/analyzer.dart' hide ConstantEvaluator;
 import 'package:analyzer/src/generated/ast.dart' hide ConstantEvaluator;
@@ skipping 548 matching lines @@
 
   JS.Statement _emitGenericClassDef(ParameterizedType type, JS.Statement body) {
     var name = type.name;
     var genericName = '$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]);
   }
 
+  final _hasDeferredSupertype = new HashSet<ClassElement>();
+
+  bool _deferIfNeeded(DartType type, ClassElement current) {
+    if (type is ParameterizedType) {
+      var typeArguments = type.typeArguments;
+      for (var typeArg in typeArguments) {
+        var typeElement = typeArg.element;
+        // FIXME(vsm): This does not track mutual recursive dependences.
+        if (current == typeElement || _deferIfNeeded(typeArg, current)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
   JS.Expression _classHeritage(ClassElement element) {
     var type = element.type;
     if (type.isObject) return null;
 
     // Assume we can load eagerly, until proven otherwise.
     _loader.startTopLevel(element);
 
-    JS.Expression heritage = _emitTypeName(type.superclass);
+    // Find the super type
+    JS.Expression heritage;
+    var supertype = type.superclass;
+    if (_deferIfNeeded(supertype, element)) {
+      // Fall back to raw type.
+      supertype = fillDynamicTypeArgs(supertype.element.type, rules.provider);
+      _hasDeferredSupertype.add(element);
+    }
+    heritage = _emitTypeName(supertype);
+
     if (type.mixins.isNotEmpty) {
       var mixins = type.mixins.map(_emitTypeName).toList();
       mixins.insert(0, heritage);
       heritage = js.call('dart.mixin(#)', [mixins]);
     }
 
     _loader.finishTopLevel(element);
     return heritage;
   }
 
@@ skipping 107 matching lines @@
     }
 
     body.add(new JS.ClassDeclaration(cls));
 
     // TODO(jmesserly): we should really just extend native Array.
     if (jsPeerName != null && classElem.typeParameters.isNotEmpty) {
       body.add(js.statement('dart.setBaseClass(#, dart.global.#);',
           [classElem.name, _propertyName(jsPeerName)]));
     }
 
+    // Deferred Superclass
+    if (_hasDeferredSupertype.contains(classElem)) {
+      body.add(js.statement('#.prototype.__proto__ = #.prototype;',
+          [name, _emitTypeName(classElem.type.superclass)]));
+    }
+
     // Interfaces
     if (classElem.interfaces.isNotEmpty) {
       body.add(js.statement('#[dart.implements] = () => #;', [
         name,
         new JS.ArrayInitializer(new List<JS.Expression>.from(
             classElem.interfaces.map(_emitTypeName)))
       ]));
     }
 
     // Named constructors
@@ skipping 2602 matching lines @@
 
 /// A special kind of element created by the compiler, signifying a temporary
 /// variable. These objects use instance equality, and should be shared
 /// everywhere in the tree where they are treated as the same variable.
 class TemporaryVariableElement extends LocalVariableElementImpl {
   TemporaryVariableElement.forNode(Identifier name) : super.forNode(name);
 
   int get hashCode => identityHashCode(this);
   bool operator ==(Object other) => identical(this, other);
 }