Fix "extends" checks. Move them out of resolve phase and do them on demand.

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 /**
  * Generates a dynamic call stub for a function.
  * Our goal is to create a stub method like this on-the-fly:
  *   function($0, $1, capture) { return this($0, $1, true, capture); }
  *
  * This stub then replaces the dynamic one on Function, with one that is
  * specialized for that particular function, taking into account its default
@@ skipping 1994 matching lines @@
       $globals.world.error(('' + baseType.get$name() + ' is not generic'), typeRef.span);
       return null;
     }
     if (typeRef.typeArguments.length != baseType.get$typeParameters().length) {
       $globals.world.error('wrong number of type arguments', typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = 0;
      i < typeRef.typeArguments.length; i++) {
-      var extendsType = baseType.get$typeParameters().$index(i).get$extendsType();
-      var typeArg = this.resolveType(typeRef.typeArguments.$index(i), typeErrors);
-      typeArgs.add$1(typeArg);
-      if ($ne(extendsType, null) && !(typeArg instanceof ParameterType)) {
-        typeArg.ensureSubtypeOf$3(extendsType, typeRef.typeArguments.$index(i).get$span(), typeErrors);
-      }
+      typeArgs.add$1(this.resolveType(typeRef.typeArguments.$index(i), typeErrors));
     }
     typeRef.type = baseType.getOrMakeConcreteType$1(typeArgs);
   }
   else if ((node instanceof FunctionTypeReference)) {
     var typeRef = node;
     var name = '';
     if (typeRef.func.name != null) {
       name = typeRef.func.name.name;
     }
     typeRef.type = this.get$library().getOrAddFunctionType(this, name, typeRef.func);
@@ skipping 8447 matching lines @@
 }
 Type.prototype.get$hasNativeSubtypes = function() {
   if (this._hasNativeSubtypes == null) {
     this._hasNativeSubtypes = this.get$subtypes().some((function (t) {
       return t.get$isNative();
     })
     );
   }
   return this._hasNativeSubtypes;
 }
+Type.prototype._checkExtends = function() {
+  var typeParams = this.get$genericType().typeParameters;
+  if ($ne(typeParams, null) && $ne(this.get$typeArgsInOrder(), null)) {
+    var args = this.get$typeArgsInOrder().iterator$0();
+    var params = typeParams.iterator$0();
+    while (args.hasNext$0() && params.hasNext$0()) {
+      var typeParam = params.next$0();
+      var typeArg = args.next$0();
+      if ($ne(typeParam.get$extendsType(), null) && $ne(typeArg, null)) {
+        typeArg.ensureSubtypeOf$3(typeParam.get$extendsType(), typeParam.get$span(), true);
+      }
+    }
+  }
+  if (this.get$interfaces() != null) {
+    var $$list = this.get$interfaces();
+    for (var $$i = 0;$$i < $$list.length; $$i++) {
+      var i = $$list.$index($$i);
+      i._checkExtends();
+    }
+  }
+}
 Type.prototype._checkOverride = function(member) {
   var parentMember = this._getMemberInParents(member.name);
   if ($ne(parentMember, null)) {
     if (!member.get$isPrivate() || $eq(member.get$library(), parentMember.get$library())) {
       member.override(parentMember);
     }
   }
 }
 Type.prototype._createNotEqualMember = function() {
   var eq = this.get$members().$index(':eq');
@@ skipping 344 matching lines @@
 NonNullableType.prototype.addDirectSubtype$1 = NonNullableType.prototype.addDirectSubtype;
 NonNullableType.prototype.getConstructor$1 = NonNullableType.prototype.getConstructor;
 NonNullableType.prototype.getFactory$2 = NonNullableType.prototype.getFactory;
 NonNullableType.prototype.getMember$1 = NonNullableType.prototype.getMember;
 NonNullableType.prototype.getOrMakeConcreteType$1 = NonNullableType.prototype.getOrMakeConcreteType;
 NonNullableType.prototype.isSubtypeOf$1 = NonNullableType.prototype.isSubtypeOf;
 NonNullableType.prototype.markUsed$0 = NonNullableType.prototype.markUsed;
 NonNullableType.prototype.resolveTypeParams$1 = NonNullableType.prototype.resolveTypeParams;
 // ********** Code for ConcreteType **************
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
+  this.isUsed = false
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = new HashMapImplementation();
   this.members = new HashMapImplementation();
   this.factories = new FactoryMap();
   // Initializers done
   Type.call(this, name);
 }
 $inherits(ConcreteType, Type);
@@ skipping 11 matching lines @@
 }
 ConcreteType.prototype.get$span = function() {
   return this.genericType.get$span();
 }
 ConcreteType.prototype.get$hasTypeParams = function() {
   return this.typeArguments.getValues().some$1((function (e) {
     return (e instanceof ParameterType);
   })
   );
 }
+ConcreteType.prototype.get$isUsed = function() { return this.isUsed; };
+ConcreteType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 ConcreteType.prototype.get$members = function() { return this.members; };
 ConcreteType.prototype.set$members = function(value) { return this.members = value; };
 ConcreteType.prototype.get$constructors = function() { return this.constructors; };
 ConcreteType.prototype.set$constructors = function(value) { return this.constructors = value; };
 ConcreteType.prototype.get$factories = function() { return this.factories; };
 ConcreteType.prototype.set$factories = function(value) { return this.factories = value; };
 ConcreteType.prototype.resolveTypeParams = function(inType) {
   var newTypeArgs = [];
   var needsNewType = false;
   var $$list = this.typeArgsInOrder;
@@ skipping 46 matching lines @@
   for (var $$i = result.getKeys$0().iterator$0(); $$i.hasNext$0(); ) {
     var memberName = $$i.next$0();
     var myMember = this.members.$index(memberName);
     if ($ne(myMember, null)) {
       result.$setindex(memberName, myMember);
     }
   }
   return result;
 }
 ConcreteType.prototype.markUsed = function() {
+  if (this.isUsed) return;
+  this.isUsed = true;
+  this._checkExtends();
   this.genericType.markUsed();
 }
 ConcreteType.prototype.genMethod = function(method) {
-  this.genericType.genMethod(method);
+  return this.genericType.genMethod(method);
 }
 ConcreteType.prototype.getFactory = function(type, constructorName) {
   return this.genericType.getFactory(type, constructorName);
 }
 ConcreteType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if ($ne(ret, null)) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if ($ne(ret, null)) return ret;
   var genericMember = this.genericType.getConstructor(constructorName);
@@ skipping 145 matching lines @@
 }
 DefinedType.prototype.getCallMethod = function() {
   return this.members.$index(':call');
 }
 DefinedType.prototype.getAllMembers = function() {
   return HashMapImplementation.HashMapImplementation$from$factory(this.members);
 }
 DefinedType.prototype.markUsed = function() {
   if (this.isUsed) return;
   this.isUsed = true;
+  this._checkExtends();
   if (this._lazyGenMethods != null) {
     var $$list = orderValuesByKeys(this._lazyGenMethods);
     for (var $$i = 0;$$i < $$list.length; $$i++) {
       var method = $$list.$index($$i);
       $globals.world.gen.genMethod(method);
     }
     this._lazyGenMethods = null;
   }
   if (this.get$parent() != null) this.get$parent().markUsed();
 }
@@ skipping 1810 matching lines @@
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, DoubleLinkedQueueEntry_KeyValuePair_K$V);
 //  ********** Globals **************
 function $static_init(){
 }
 var const$0 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var $globals = {};
 $static_init();
 main();