Fix factories in Frog to correspond to the new syntax.

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 379 matching lines @@
   return this.noSuchMethod("writeDefinition", [$0, $1]);
 };
 // ********** Code for Clock **************
 function Clock() {}
 Clock.now = function() {
   return new Date().getTime();
 }
 Clock.frequency = function() {
   return 1000;
 }
+// ********** Code for IllegalAccessException **************
+function IllegalAccessException() {
+  // Initializers done
+}
+IllegalAccessException.prototype.toString = function() {
+  return "Attempt to modify an immutable object";
+}
+IllegalAccessException.prototype.toString$0 = IllegalAccessException.prototype.toString;
 // ********** Code for NoSuchMethodException **************
 function NoSuchMethodException(_receiver, _functionName, _arguments) {
   this._receiver = _receiver;
   this._functionName = _functionName;
   this._arguments = _arguments;
   // Initializers done
 }
 NoSuchMethodException.prototype.toString = function() {
   var sb = new StringBufferImpl("");
   for (var i = 0;
@@ skipping 257 matching lines @@
   return this._array.length > this._dart_coreimpl_pos;
 }
 ListIterator.prototype.next = function() {
   if (!this.hasNext()) {
     $throw(const$8/*const NoMoreElementsException()*/);
   }
   return this._array.$index(this._dart_coreimpl_pos++);
 }
 ListIterator.prototype.hasNext$0 = ListIterator.prototype.hasNext;
 ListIterator.prototype.next$0 = ListIterator.prototype.next;
+// ********** Code for ImmutableList **************
+/** Implements extends for Dart classes on JavaScript prototypes. */
+function $inherits(child, parent) {
+  if (child.prototype.__proto__) {
+    child.prototype.__proto__ = parent.prototype;
+  } else {
+    function tmp() {};
+    tmp.prototype = parent.prototype;
+    child.prototype = new tmp();
+    child.prototype.constructor = child;
+  }
+}
+$inherits(ImmutableList, ListFactory_E);
+function ImmutableList(length) {
+  this._length = length;
+  // Initializers done
+  ListFactory_E.call(this, length);
+}
+ImmutableList.ImmutableList$from$factory = function(other) {
+  var list = new ImmutableList(other.length);
+  for (var i = 0;
+   i < other.length; i++) {
+    list._setindex(i, other.$index(i));
+  }
+  return list;
+}
+ImmutableList.prototype.get$length = function() {
+  return this._length;
+}
+ImmutableList.prototype.set$length = function(length) {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+Object.defineProperty(ImmutableList.prototype, "length", {
+  get: ImmutableList.prototype.get$length,
+  set: ImmutableList.prototype.set$length
+});
+ImmutableList.prototype._setindex = function(index, value) {
+  return this[index] = value;
+}
+ImmutableList.prototype.$setindex = function(index, value) {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.sort = function(compare) {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.add = function(element) {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.addLast = function(element) {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.addAll = function(elements) {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.clear = function() {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.removeLast = function() {
+  $throw(const$127/*const IllegalAccessException()*/);
+}
+ImmutableList.prototype.toString = function() {
+  return ListFactory.ListFactory$from$factory(this).toString();
+}
+ImmutableList.prototype.add$1 = ImmutableList.prototype.add;
+ImmutableList.prototype.addAll$1 = ImmutableList.prototype.addAll;
+ImmutableList.prototype.removeLast$0 = ImmutableList.prototype.removeLast;
+ImmutableList.prototype.sort$1 = function($0) {
+  return this.sort(to$call$2($0));
+};
+ImmutableList.prototype.toString$0 = ImmutableList.prototype.toString;
 // ********** Code for NumImplementation **************
 NumImplementation = Number;
 NumImplementation.prototype.isNaN = function() {
   return isNaN(this);
 }
 NumImplementation.prototype.isNegative = function() {
   return this == 0 ? (1 / this) < 0 : this < 0;
 }
 NumImplementation.prototype.hashCode = function() {
   return this & 0xFFFFFFF;
@@ skipping 44 matching lines @@
 // ********** Code for HashMapImplementation **************
 function HashMapImplementation() {
   // Initializers done
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 HashMapImplementation.HashMapImplementation$from$factory = function(other) {
-  var result = new HashMapImplementation();
+  var result = new HashMapImplementation_K$V();
   other.forEach((function (key, value) {
     result.$setindex(key, value);
   })
   );
   return result;
 }
 HashMapImplementation._computeLoadLimit = function(capacity) {
   return $truncdiv((capacity * 3), 4);
 }
 HashMapImplementation._firstProbe = function(hashCode, length) {
@@ skipping 135 matching lines @@
   return (this._probeForLookup(key) != -1);
 }
 HashMapImplementation.prototype.containsKey$1 = HashMapImplementation.prototype.containsKey;
 HashMapImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$2($0));
 };
 HashMapImplementation.prototype.getKeys$0 = HashMapImplementation.prototype.getKeys;
 HashMapImplementation.prototype.getValues$0 = HashMapImplementation.prototype.getValues;
 HashMapImplementation.prototype.isEmpty$0 = HashMapImplementation.prototype.isEmpty;
 // ********** Code for HashMapImplementation_E$E **************
-/** Implements extends for Dart classes on JavaScript prototypes. */
-function $inherits(child, parent) {
-  if (child.prototype.__proto__) {
-    child.prototype.__proto__ = parent.prototype;
-  } else {
-    function tmp() {};
-    tmp.prototype = parent.prototype;
-    child.prototype = new tmp();
-    child.prototype.constructor = child;
-  }
-}
 $inherits(HashMapImplementation_E$E, HashMapImplementation);
 function HashMapImplementation_E$E() {
   // Initializers done
   this._numberOfEntries = 0;
   this._numberOfDeleted = 0;
   this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
   this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
 }
 HashMapImplementation_E$E._computeLoadLimit = function(capacity) {
@@ skipping 113 matching lines @@
   }
   );
   return list;
 }
 HashMapImplementation_E$E.prototype.containsKey = function(key) {
   return (this._probeForLookup(key) != -1);
 }
 // ********** Code for HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V **************
 $inherits(HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V, HashMapImplementation);
 function HashMapImplementation_K$DoubleLinkedQueueEntry_KeyValuePair_K$V() {}
+// ********** Code for HashMapImplementation_K$V **************
+$inherits(HashMapImplementation_K$V, HashMapImplementation);
+function HashMapImplementation_K$V() {
+  // Initializers done
+  this._numberOfEntries = 0;
+  this._numberOfDeleted = 0;
+  this._loadLimit = HashMapImplementation._computeLoadLimit(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  this._keys = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+  this._values = new ListFactory(8/*HashMapImplementation._INITIAL_CAPACITY*/);
+}
+HashMapImplementation_K$V._computeLoadLimit = function(capacity) {
+  return $truncdiv((capacity * 3), 4);
+}
 // ********** Code for HashMapImplementation_String$EvaluatedValue **************
 $inherits(HashMapImplementation_String$EvaluatedValue, HashMapImplementation);
 function HashMapImplementation_String$EvaluatedValue() {}
 // ********** Code for HashSetImplementation **************
 function HashSetImplementation() {
   // Initializers done
   this._backingMap = new HashMapImplementation_E$E();
 }
 HashSetImplementation.HashSetImplementation$from$factory = function(other) {
-  var set = new HashSetImplementation();
+  var set = new HashSetImplementation_E();
   for (var $$i = other.iterator(); $$i.hasNext$0(); ) {
     var e = $$i.next$0();
     set.add(e);
   }
   return set;
 }
 HashSetImplementation.prototype.add = function(value) {
   this._backingMap.$setindex(value, value);
 }
 HashSetImplementation.prototype.contains = function(value) {
@@ skipping 57 matching lines @@
 HashSetImplementation.prototype.forEach$1 = function($0) {
   return this.forEach(to$call$1($0));
 };
 HashSetImplementation.prototype.isEmpty$0 = HashSetImplementation.prototype.isEmpty;
 HashSetImplementation.prototype.iterator$0 = HashSetImplementation.prototype.iterator;
 HashSetImplementation.prototype.some$1 = function($0) {
   return this.some(to$call$1($0));
 };
 // ********** Code for HashSetImplementation_E **************
 $inherits(HashSetImplementation_E, HashSetImplementation);
-function HashSetImplementation_E() {}
+function HashSetImplementation_E() {
+  // Initializers done
+  this._backingMap = new HashMapImplementation_E$E();
+}
 // ********** Code for HashSetImplementation_Library **************
 $inherits(HashSetImplementation_Library, HashSetImplementation);
 function HashSetImplementation_Library() {}
 // ********** Code for HashSetImplementation_String **************
 $inherits(HashSetImplementation_String, HashSetImplementation);
 function HashSetImplementation_String() {}
 // ********** Code for HashSetImplementation_Type **************
 $inherits(HashSetImplementation_Type, HashSetImplementation);
 function HashSetImplementation_Type() {}
 // ********** Code for HashSetIterator **************
@@ skipping 3777 matching lines @@
           $globals.world.error('duplicate final modifier', mod.get$span());
         }
         this.isFinal = true;
       }
       else {
         $globals.world.error(('' + mod + ' modifier not allowed on field'), mod.get$span());
       }
     }
   }
   this.type = this.resolveType(this.definition.type, false);
-  if (this.isStatic && this.type.get$hasTypeParams()) {
+  if (this.isStatic && !this.get$isFactory() && this.type.get$hasTypeParams()) {
     $globals.world.error('using type parameter in static context', this.definition.type.span);
   }
   if (this.isStatic && this.isFinal && this.value == null) {
     $globals.world.error('static final field is missing initializer', this.get$span());
   }
   this.get$library()._addMember(this);
 }
 FieldMember.prototype.computeValue = function() {
   if (this.value == null) return null;
   if (this._computedValue == null) {
@@ skipping 18 matching lines @@
       this._computedValue = $globals.world.gen.globalForStaticField(this, this._computedValue, [this._computedValue]);
     }
     this._computing = false;
   }
   return this._computedValue;
 }
 FieldMember.prototype._get = function(context, node, target, isDynamic) {
   if (this.isNative && this.get$returnType() != null) {
     this.get$returnType().markUsed();
     if ((this.get$returnType() instanceof DefinedType)) {
-      var factory_ = this.get$returnType().get$genericType().factory_;
-      if (factory_ != null && factory_.get$isNative()) {
-        factory_.markUsed$0();
+      var defaultType = this.get$returnType().get$genericType().defaultType;
+      if (defaultType != null && defaultType.get$isNative()) {
+        defaultType.markUsed$0();
       }
     }
   }
   if (this.isStatic) {
     this.declaringType.markUsed();
     var cv = this.computeValue();
     if (this.isFinal) {
       return cv;
     }
     $globals.world.gen.hasStatics = true;
@@ skipping 317 matching lines @@
   this.definition = definition;
   // Initializers done
   Member.call(this, name, declaringType);
 }
 MethodMember.prototype.get$definition = function() { return this.definition; };
 MethodMember.prototype.set$definition = function(value) { return this.definition = value; };
 MethodMember.prototype.get$returnType = function() { return this.returnType; };
 MethodMember.prototype.set$returnType = function(value) { return this.returnType = value; };
 MethodMember.prototype.get$parameters = function() { return this.parameters; };
 MethodMember.prototype.set$parameters = function(value) { return this.parameters = value; };
-MethodMember.prototype.get$typeParameters = function() { return this.typeParameters; };
-MethodMember.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 MethodMember.prototype.get$isStatic = function() { return this.isStatic; };
 MethodMember.prototype.set$isStatic = function(value) { return this.isStatic = value; };
 MethodMember.prototype.get$isAbstract = function() { return this.isAbstract; };
 MethodMember.prototype.set$isAbstract = function(value) { return this.isAbstract = value; };
 MethodMember.prototype.get$isConst = function() { return this.isConst; };
 MethodMember.prototype.set$isConst = function(value) { return this.isConst = value; };
 MethodMember.prototype.get$isFactory = function() { return this.isFactory; };
 MethodMember.prototype.set$isFactory = function(value) { return this.isFactory = value; };
 MethodMember.prototype.get$isLambda = function() { return this.isLambda; };
 MethodMember.prototype.set$isLambda = function(value) { return this.isLambda = value; };
@@ skipping 637 matching lines @@
         this.isAbstract = true;
       }
       else {
         $globals.world.error(('' + mod + ' modifier not allowed on method'), mod.get$span());
       }
     }
   }
   if (this.isFactory) {
     this.isStatic = true;
   }
-  if (this.definition.typeParameters != null) {
-    if (!this.isFactory) {
-      $globals.world.error('Only factories are allowed to have explicit type parameters', this.definition.typeParameters.$index(0).get$span());
-    }
-    else {
-      this.typeParameters = this.definition.typeParameters;
-      var $$list = this.definition.typeParameters;
-      for (var $$i = 0;$$i < $$list.length; $$i++) {
-        var tp = $$list.$index($$i);
-        tp.set$enclosingElement(this);
-        tp.resolve$0();
-      }
-    }
-  }
   if (this.get$isOperator() && this.isStatic && !this.get$isCallMethod()) {
     $globals.world.error(('operator method may not be static "' + this.name + '"'), this.get$span());
   }
   if (this.isAbstract) {
     if (this.definition.body != null && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition)) {
       $globals.world.error('abstract method can not have a body', this.get$span());
     }
     if (this.isStatic && !(this.declaringType.get$definition() instanceof FunctionTypeDefinition)) {
       $globals.world.error('static method can not be abstract', this.get$span());
     }
@@ skipping 16 matching lines @@
     var param = new Parameter(formal, this);
     param.resolve$0();
     this.parameters.add(param);
   }
   if (!this.isLambda) {
     this.get$library()._addMember(this);
   }
 }
 MethodMember.prototype.resolveType = function(node, typeErrors) {
   var t = Element.prototype.resolveType.call(this, node, typeErrors);
-  if (this.isStatic && (t instanceof ParameterType) && (this.typeParameters == null || !this.typeParameters.some((function (p) {
-    return p === t;
-  })
-  ))) {
+  if (this.isStatic && !this.isFactory && (t instanceof ParameterType)) {
     $globals.world.error('using type parameter in static context.', node.span);
   }
   return t;
 }
 MethodMember.prototype._get$3 = function($0, $1, $2) {
   return this._get($0, $1, $2, false);
 };
 MethodMember.prototype._get$3$isDynamic = MethodMember.prototype._get;
 MethodMember.prototype._get$4 = MethodMember.prototype._get;
 MethodMember.prototype._set$4 = function($0, $1, $2, $3) {
@@ skipping 2373 matching lines @@
   }
   var _implements = null;
   if (this._maybeEat(77/*TokenKind.IMPLEMENTS*/)) {
     _implements = this.typeList();
   }
   var _native = null;
   if (this._maybeEat(81/*TokenKind.NATIVE*/)) {
     _native = this.maybeStringLiteral();
     if (_native != null) _native = new NativeType(_native);
   }
-  var _factory = null;
-  if (this._maybeEat(75/*TokenKind.FACTORY*/)) {
-    _factory = this.nameTypeReference();
+  var oldFactory = this._maybeEat(75/*TokenKind.FACTORY*/);
+  var defaultType = null;
+  if (oldFactory || this._maybeEat(94/*TokenKind.DEFAULT*/)) {
+    if (oldFactory) {
+      $globals.world.warning('factory no longer supported, use "default" instead', this._previousToken.get$span());
+    }
+    var baseType = this.nameTypeReference();
+    var typeParams0 = null;
     if (this._peekKind(52/*TokenKind.LT*/)) {
-      this.typeParameters();
+      typeParams0 = this.typeParameters();
     }
+    defaultType = new DefaultTypeReference(oldFactory, baseType, typeParams0, this._makeSpan(baseType.get$span().get$start()));
   }
   var body = [];
   if (this._maybeEat(6/*TokenKind.LBRACE*/)) {
     while (!this._maybeEat(7/*TokenKind.RBRACE*/)) {
       body.add$1(this.declaration(true));
       if (this._recover) {
         if (!this._recoverTo(7/*TokenKind.RBRACE*/, 10/*TokenKind.SEMICOLON*/)) break;
         this._maybeEat(10/*TokenKind.SEMICOLON*/);
       }
     }
   }
   else {
     this._errorExpected('block starting with "{" or ";"');
   }
-  return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, _factory, body, this._makeSpan(start));
+  return new TypeDefinition(kind == 73/*TokenKind.CLASS*/, name, typeParams, _extends, _implements, _native, defaultType, body, this._makeSpan(start));
 }
 Parser.prototype.functionTypeAlias = function() {
   var start = this._peekToken.start;
   this._eat(87/*TokenKind.TYPEDEF*/);
   var di = this.declaredIdentifier(false);
   var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
     typeParams = this.typeParameters();
   }
   var formals = this.formalParameterList();
   this._eatSemicolon();
-  var func = new FunctionDefinition(null, di.get$type(), di.get$name(), formals, null, null, null, null, this._makeSpan(start));
+  var func = new FunctionDefinition(null, di.get$type(), di.get$name(), formals, null, null, null, this._makeSpan(start));
   return new FunctionTypeDefinition(func, typeParams, this._makeSpan(start));
 }
 Parser.prototype.initializers = function() {
   this._inhibitLambda = true;
   var ret = [];
   do {
     ret.add$1(this.expression());
   }
   while (this._maybeEat(11/*TokenKind.COMMA*/))
   this._inhibitLambda = false;
@@ skipping 20 matching lines @@
       return this.block();
     }
   }
   else if (!inExpression) {
     if (this._maybeEat(10/*TokenKind.SEMICOLON*/)) {
       return null;
     }
   }
   this._error('Expected function body (neither { nor => found)');
 }
-Parser.prototype.finishField = function(start, modifiers, typeParams, type, name, value) {
-  if (typeParams != null) {
-    $globals.world.internalError('trying to create a generic field', this._makeSpan(start));
-  }
+Parser.prototype.finishField = function(start, modifiers, type, name, value) {
   var names = [name];
   var values = [value];
   while (this._maybeEat(11/*TokenKind.COMMA*/)) {
     names.add$1(this.identifier());
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       values.add$1(this.expression());
     }
     else {
       values.add$1();
     }
   }
   this._eatSemicolon();
   return new VariableDefinition(modifiers, type, names, values, this._makeSpan(start));
 }
-Parser.prototype.finishDefinition = function(start, modifiers, di, typeParams) {
+Parser.prototype.finishDefinition = function(start, modifiers, di) {
   switch (this._peek()) {
     case 2/*TokenKind.LPAREN*/:
 
       var formals = this.formalParameterList();
       var inits = null, native_ = null;
       if (this._maybeEat(8/*TokenKind.COLON*/)) {
         inits = this.initializers();
       }
       if (this._maybeEat(81/*TokenKind.NATIVE*/)) {
         native_ = this.maybeStringLiteral();
         if (native_ == null) native_ = '';
       }
       var body = this.functionBody(false);
       if (di.get$name() == null) {
         di.set$name(di.get$type().get$name());
       }
-      return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, typeParams, inits, native_, body, this._makeSpan(start));
+      return new FunctionDefinition(modifiers, di.get$type(), di.get$name(), formals, inits, native_, body, this._makeSpan(start));
 
     case 20/*TokenKind.ASSIGN*/:
 
       this._eat(20/*TokenKind.ASSIGN*/);
       var value = this.expression();
-      return this.finishField(start, modifiers, typeParams, di.get$type(), di.get$name(), value);
+      return this.finishField(start, modifiers, di.get$type(), di.get$name(), value);
 
     case 11/*TokenKind.COMMA*/:
     case 10/*TokenKind.SEMICOLON*/:
 
-      return this.finishField(start, modifiers, typeParams, di.get$type(), di.get$name(), null);
+      return this.finishField(start, modifiers, di.get$type(), di.get$name(), null);
 
     default:
 
       this._errorExpected('declaration');
       return null;
 
   }
 }
 Parser.prototype.declaration = function(includeOperators) {
   var start = this._peekToken.start;
   if (this._peekKind(75/*TokenKind.FACTORY*/)) {
     return this.factoryConstructorDeclaration();
   }
   var modifiers = this._readModifiers();
-  return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators), null);
+  return this.finishDefinition(start, modifiers, this.declaredIdentifier(includeOperators));
 }
 Parser.prototype.factoryConstructorDeclaration = function() {
   var start = this._peekToken.start;
   var factoryToken = this._next();
   var names = [this.identifier()];
   while (this._maybeEat(14/*TokenKind.DOT*/)) {
     names.add$1(this.identifier());
   }
-  var typeParams = null;
   if (this._peekKind(52/*TokenKind.LT*/)) {
-    typeParams = this.typeParameters();
+    var tp = this.typeParameters();
+    $globals.world.warning('type parameters on factories are no longer supported, place them on the class instead'/*'type parameters on factories are no longer supported, '
+              + 'place them on the class instead'*/, this._makeSpan(tp.$index(0).get$span().get$start()));
   }
   var name = null;
   var type = null;
   if (this._maybeEat(14/*TokenKind.DOT*/)) {
     name = this.identifier();
   }
-  else if (typeParams == null) {
+  else {
     if (names.length > 1) {
       name = names.removeLast$0();
     }
     else {
       name = new Identifier('', names.$index(0).get$span());
     }
   }
-  else {
-    name = new Identifier('', names.$index(0).get$span());
-  }
   if (names.length > 1) {
     this._error('unsupported qualified name for factory', names.$index(0).get$span());
   }
   type = new NameTypeReference(false, names.$index(0), null, names.$index(0).get$span());
   var di = new DeclaredIdentifier(type, name, this._makeSpan(start));
-  return this.finishDefinition(start, [factoryToken], di, typeParams);
+  return this.finishDefinition(start, [factoryToken], di);
 }
 Parser.prototype.statement = function() {
   switch (this._peek()) {
     case 89/*TokenKind.BREAK*/:
 
       return this.breakStatement();
 
     case 93/*TokenKind.CONTINUE*/:
 
       return this.continueStatement();
@@ skipping 67 matching lines @@
       this._eatSemicolon();
       expr.get$func().set$span(this._makeSpan(start));
     }
     return expr.get$func();
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     var value = null;
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       value = this.expression();
     }
-    return this.finishField(start, null, null, expr.get$type(), expr.get$name(), value);
+    return this.finishField(start, null, expr.get$type(), expr.get$name(), value);
   }
   else if (this._isBin(expr, 20/*TokenKind.ASSIGN*/) && ((expr.get$x() instanceof DeclaredIdentifier))) {
     var di = expr.get$x();
-    return this.finishField(start, null, null, di.type, di.name, expr.get$y());
+    return this.finishField(start, null, di.type, di.name, expr.get$y());
   }
   else if (this._isBin(expr, 52/*TokenKind.LT*/) && this._maybeEat(11/*TokenKind.COMMA*/)) {
     var baseType = this._makeType(expr.get$x());
     var typeArgs = [this._makeType(expr.get$y())];
     var gt = this._finishTypeArguments(baseType, 0, typeArgs);
     var name = this.identifier();
     var value = null;
     if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
       value = this.expression();
     }
-    return this.finishField(expr.get$span().get$start(), null, null, gt, name, value);
+    return this.finishField(expr.get$span().get$start(), null, gt, name, value);
   }
   else {
     this._eatSemicolon();
     return new ExpressionStatement(expr, this._makeSpan(expr.get$span().get$start()));
   }
 }
 Parser.prototype.testCondition = function() {
   this._eatLeftParen();
   var ret = this.expression();
   this._eat(3/*TokenKind.RPAREN*/);
@@ skipping 611 matching lines @@
     this._next();
     this._errorExpected('string literal, but found incomplete string');
   }
   return null;
 }
 Parser.prototype._parenOrLambda = function() {
   var start = this._peekToken.start;
   if (this._atClosureParameters()) {
     var formals = this.formalParameterList();
     var body = this.functionBody(true);
-    var func = new FunctionDefinition(null, null, null, formals, null, null, null, body, this._makeSpan(start));
+    var func = new FunctionDefinition(null, null, null, formals, null, null, body, this._makeSpan(start));
     return new LambdaExpression(func, func.get$span());
   }
   else {
     this._eatLeftParen();
     var saved = this._inhibitLambda;
     this._inhibitLambda = false;
     var expr = this.expression();
     this._eat(3/*TokenKind.RPAREN*/);
     this._inhibitLambda = saved;
     return new ParenExpression(expr, this._makeSpan(start));
@@ skipping 381 matching lines @@
   var name = di.get$name();
   var value = null;
   if (this._maybeEat(20/*TokenKind.ASSIGN*/)) {
     if (!inOptionalBlock) {
       this._error('default values only allowed inside [optional] section');
     }
     value = this.expression();
   }
   else if (this._peekKind(2/*TokenKind.LPAREN*/)) {
     var formals = this.formalParameterList();
-    var func = new FunctionDefinition(null, type, name, formals, null, null, null, null, this._makeSpan(start));
+    var func = new FunctionDefinition(null, type, name, formals, null, null, null, this._makeSpan(start));
     type = new FunctionTypeReference(false, func, func.get$span());
   }
   if (inOptionalBlock && value == null) {
     value = new NullExpression(this._makeSpan(start));
   }
   return new FormalNode(isThis, isRest, type, name, value, this._makeSpan(start));
 }
 Parser.prototype.formalParameterList = function() {
   this._eatLeftParen();
   var formals = [];
@@ skipping 33 matching lines @@
     type = null;
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     name = expr.get$name();
     type = expr.get$type();
   }
   else {
     this._error('bad function body', expr.get$span());
   }
   var span = new SourceSpan(expr.get$span().get$file(), expr.get$span().get$start(), body.get$span().get$end());
-  var func = new FunctionDefinition(null, type, name, formals, null, null, null, body, span);
+  var func = new FunctionDefinition(null, type, name, formals, null, null, body, span);
   return new LambdaExpression(func, func.get$span());
 }
 Parser.prototype._makeDeclaredIdentifier = function(e) {
   if ((e instanceof VarExpression)) {
     return new DeclaredIdentifier(null, e.get$name(), e.get$span());
   }
   else if ((e instanceof DeclaredIdentifier)) {
     return e;
   }
   else {
@@ skipping 97 matching lines @@
 DirectiveDefinition.prototype.get$name = function() { return this.name; };
 DirectiveDefinition.prototype.set$name = function(value) { return this.name = value; };
 DirectiveDefinition.prototype.get$arguments = function() { return this.arguments; };
 DirectiveDefinition.prototype.set$arguments = function(value) { return this.arguments = value; };
 DirectiveDefinition.prototype.visit = function(visitor) {
   return visitor.visitDirectiveDefinition(this);
 }
 DirectiveDefinition.prototype.visit$1 = DirectiveDefinition.prototype.visit;
 // ********** Code for TypeDefinition **************
 $inherits(TypeDefinition, Definition);
-function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, factoryType, body, span) {
+function TypeDefinition(isClass, name, typeParameters, extendsTypes, implementsTypes, nativeType, defaultType, body, span) {
   this.isClass = isClass;
   this.name = name;
   this.typeParameters = typeParameters;
   this.extendsTypes = extendsTypes;
   this.implementsTypes = implementsTypes;
   this.nativeType = nativeType;
-  this.factoryType = factoryType;
+  this.defaultType = defaultType;
   this.body = body;
   // Initializers done
   Definition.call(this, span);
 }
 TypeDefinition.prototype.get$isClass = function() { return this.isClass; };
 TypeDefinition.prototype.set$isClass = function(value) { return this.isClass = value; };
 TypeDefinition.prototype.get$name = function() { return this.name; };
 TypeDefinition.prototype.set$name = function(value) { return this.name = value; };
 TypeDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
 TypeDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
@@ skipping 36 matching lines @@
 VariableDefinition.prototype.get$names = function() { return this.names; };
 VariableDefinition.prototype.set$names = function(value) { return this.names = value; };
 VariableDefinition.prototype.get$values = function() { return this.values; };
 VariableDefinition.prototype.set$values = function(value) { return this.values = value; };
 VariableDefinition.prototype.visit = function(visitor) {
   return visitor.visitVariableDefinition(this);
 }
 VariableDefinition.prototype.visit$1 = VariableDefinition.prototype.visit;
 // ********** Code for FunctionDefinition **************
 $inherits(FunctionDefinition, Definition);
-function FunctionDefinition(modifiers, returnType, name, formals, typeParameters, initializers, nativeBody, body, span) {
+function FunctionDefinition(modifiers, returnType, name, formals, initializers, nativeBody, body, span) {
   this.modifiers = modifiers;
   this.returnType = returnType;
   this.name = name;
   this.formals = formals;
-  this.typeParameters = typeParameters;
   this.initializers = initializers;
   this.nativeBody = nativeBody;
   this.body = body;
   // Initializers done
   Definition.call(this, span);
 }
 FunctionDefinition.prototype.get$returnType = function() { return this.returnType; };
 FunctionDefinition.prototype.set$returnType = function(value) { return this.returnType = value; };
 FunctionDefinition.prototype.get$name = function() { return this.name; };
 FunctionDefinition.prototype.set$name = function(value) { return this.name = value; };
-FunctionDefinition.prototype.get$typeParameters = function() { return this.typeParameters; };
-FunctionDefinition.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
 FunctionDefinition.prototype.get$initializers = function() { return this.initializers; };
 FunctionDefinition.prototype.set$initializers = function(value) { return this.initializers = value; };
 FunctionDefinition.prototype.get$nativeBody = function() { return this.nativeBody; };
 FunctionDefinition.prototype.set$nativeBody = function(value) { return this.nativeBody = value; };
 FunctionDefinition.prototype.get$body = function() { return this.body; };
 FunctionDefinition.prototype.set$body = function(value) { return this.body = value; };
 FunctionDefinition.prototype.visit = function(visitor) {
   return visitor.visitFunctionDefinition(this);
 }
 FunctionDefinition.prototype.visit$1 = FunctionDefinition.prototype.visit;
@@ skipping 556 matching lines @@
   TypeReference.call(this, span);
 }
 FunctionTypeReference.prototype.get$isFinal = function() { return this.isFinal; };
 FunctionTypeReference.prototype.set$isFinal = function(value) { return this.isFinal = value; };
 FunctionTypeReference.prototype.get$func = function() { return this.func; };
 FunctionTypeReference.prototype.set$func = function(value) { return this.func = value; };
 FunctionTypeReference.prototype.visit = function(visitor) {
   return visitor.visitFunctionTypeReference(this);
 }
 FunctionTypeReference.prototype.visit$1 = FunctionTypeReference.prototype.visit;
+// ********** Code for DefaultTypeReference **************
+$inherits(DefaultTypeReference, TypeReference);
+function DefaultTypeReference(oldFactory, baseType, typeParameters, span) {
+  this.oldFactory = oldFactory;
+  this.baseType = baseType;
+  this.typeParameters = typeParameters;
+  // Initializers done
+  TypeReference.call(this, span);
+}
+DefaultTypeReference.prototype.get$baseType = function() { return this.baseType; };
+DefaultTypeReference.prototype.set$baseType = function(value) { return this.baseType = value; };
+DefaultTypeReference.prototype.get$typeParameters = function() { return this.typeParameters; };
+DefaultTypeReference.prototype.set$typeParameters = function(value) { return this.typeParameters = value; };
+DefaultTypeReference.prototype.visit = function(visitor) {
+  return visitor.visitDefaultTypeReference(this);
+}
+DefaultTypeReference.prototype.visit$1 = DefaultTypeReference.prototype.visit;
 // ********** Code for ArgumentNode **************
 $inherits(ArgumentNode, Node);
 function ArgumentNode(label, value, span) {
   this.label = label;
   this.value = value;
   // Initializers done
   Node.call(this, span);
 }
 ArgumentNode.prototype.get$label = function() { return this.label; };
 ArgumentNode.prototype.set$label = function(value) { return this.label = value; };
@@ skipping 1016 matching lines @@
           $globals.world.error(('class "' + this.name + '" has a cycle in its inheritance chain'), extendsTypeRef.get$span());
         }
       }
       else {
         if (!this.get$isObject()) {
           this.set$parent($globals.world.objectType);
           this.get$parent().addDirectSubtype(this);
         }
       }
       this.interfaces = this._resolveInterfaces(typeDef.implementsTypes);
-      if (typeDef.factoryType != null) {
-        $globals.world.error('factory not allowed on classes', typeDef.factoryType.span);
+      if (typeDef.defaultType != null) {
+        $globals.world.error('default not allowed on classes', typeDef.defaultType.span);
       }
     }
     else {
       if (typeDef.implementsTypes != null && typeDef.implementsTypes.length > 0) {
         $globals.world.error('implements not allowed on interfaces (use extends)', typeDef.implementsTypes.$index(0).get$span());
       }
       this.interfaces = this._resolveInterfaces(typeDef.extendsTypes);
       var res = this._cycleInInterfaceExtends();
       if (res >= 0) {
         $globals.world.error(('interface "' + this.name + '" has a cycle in its inheritance chain'), typeDef.extendsTypes.$index(res).get$span());
       }
-      if (typeDef.factoryType != null) {
-        this.factory_ = this.resolveType(typeDef.factoryType, true);
-        if (this.factory_ == null) {
-          $globals.world.warning('unresolved factory', typeDef.factoryType.span);
+      if (typeDef.defaultType != null) {
+        this.defaultType = this.resolveType(typeDef.defaultType.baseType, true);
+        if (this.defaultType == null) {
+          $globals.world.warning('unresolved default class', typeDef.defaultType.span);
+        }
+        else {
+          this.defaultType._resolveTypeParams(typeDef.defaultType.typeParameters);
         }
       }
     }
   }
   else if ((this.definition instanceof FunctionTypeDefinition)) {
     this.interfaces = [$globals.world.functionType];
   }
-  if (this.typeParameters != null) {
-    var $$list = this.typeParameters;
-    for (var $$i = 0;$$i < $$list.length; $$i++) {
-      var tp = $$list.$index($$i);
-      tp.set$enclosingElement(this);
-      tp.resolve$0();
-    }
-  }
+  this._resolveTypeParams(this.typeParameters);
   if (this.get$isObject()) this._createNotEqualMember();
   $globals.world._addType(this);
   var $$list = this.constructors.getValues();
   for (var $$i = this.constructors.getValues().iterator$0(); $$i.hasNext$0(); ) {
     var c = $$i.next$0();
     c.resolve$0();
   }
   var $list0 = this.members.getValues();
   for (var $$i = this.members.getValues().iterator$0(); $$i.hasNext$0(); ) {
     var m = $$i.next$0();
     m.resolve$0();
   }
   this.factories.forEach((function (f) {
     return f.resolve$0();
   })
   );
   if (this.get$isJsGlobalObject()) {
     var $list1 = this.members.getValues();
     for (var $$i = this.members.getValues().iterator$0(); $$i.hasNext$0(); ) {
       var m0 = $$i.next$0();
       if (!m0.get$isStatic()) $globals.world._addTopName(m0);
     }
   }
 }
+DefinedType.prototype._resolveTypeParams = function(params) {
+  if (params == null) return;
+  for (var $$i = 0;$$i < params.length; $$i++) {
+    var tp = params.$index($$i);
+    tp.set$enclosingElement(this);
+    tp.resolve$0();
+  }
+}
 DefinedType.prototype.addMethod = function(methodName, definition) {
   if (methodName == null) methodName = definition.name.name;
   var method = new MethodMember(methodName, this, definition);
   if (method.get$isConstructor()) {
     if (this.constructors.containsKey(method.get$constructorName())) {
       $globals.world.error(('duplicate constructor definition of ' + method.get$name()), definition.span);
       return;
     }
     this.constructors.$setindex(method.get$constructorName(), method);
     return;
@@ skipping 61 matching lines @@
   if (ret != null) return ret;
   ret = this.factories.getFactory(this.name, constructorName);
   if (ret != null) return ret;
   ret = this.constructors.$index(constructorName);
   if (ret != null) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
 DefinedType.prototype.getConstructor = function(constructorName) {
   var ret = this.constructors.$index(constructorName);
   if (ret != null) {
-    if (this.factory_ != null) {
-      return this.factory_.getFactory(this, constructorName);
+    if (this.defaultType != null) {
+      this._checkDefaultTypeParams();
+      return this.defaultType.getFactory(this, constructorName);
     }
     return ret;
   }
   ret = this.factories.getFactory(this.name, constructorName);
   if (ret != null) return ret;
   return this._tryCreateDefaultConstructor(constructorName);
 }
+DefinedType.prototype._checkDefaultTypeParams = function() {
+  function toList(list) {
+    return (list != null ? list : const$128/*const []*/);
+  }
+  var typeDef = this.definition;
+  if (typeDef.defaultType.oldFactory) {
+    return;
+  }
+  var interfaceParams = toList(this.typeParameters);
+  var defaultParams = toList(typeDef.defaultType.typeParameters);
+  var classParams = toList(this.defaultType.typeParameters);
+  if ($ne(interfaceParams.length, defaultParams.length) || $ne(defaultParams.length, classParams.length)) {
+    $globals.world.error('"default" must have the same number of type parameters as the class and interface do'/*'"default" must have the same number of type parameters as '
+              + 'the class and interface do'*/, this.get$span(), typeDef.defaultType.span, this.defaultType.get$span());
+    return;
+  }
+  for (var i = 0;
+   i < interfaceParams.length; i++) {
+    var ip = interfaceParams.$index(i);
+    var dp = defaultParams.$index(i);
+    var cp = classParams.$index(i);
+    dp.resolve$0();
+    if ($ne(ip.get$name(), dp.get$name()) || $ne(dp.get$name(), cp.get$name())) {
+      $globals.world.error('default class must have the same type parameter names as the class and interface'/*'default class must have the same type parameter names as '
+                  + 'the class and interface'*/, ip.get$span(), dp.get$span(), cp.get$span());
+    }
+    else if ($ne(dp.get$extendsType(), cp.get$extendsType())) {
+      $globals.world.error('default class type parameters must have the same extends as the class does'/*'default class type parameters must have the same extends '
+                  + 'as the class does'*/, dp.get$span(), cp.get$span());
+    }
+    else if (!dp.get$extendsType().isSubtypeOf$1(ip.get$extendsType())) {
+      $globals.world.warning('"default" can only have tighter type parameter "extends" than the interface'/*'"default" can only have tighter type parameter "extends"'
+                  + ' than the interface'*/, dp.get$span(), ip.get$span());
+    }
+  }
+}
 DefinedType.prototype._tryCreateDefaultConstructor = function(name) {
   if (name == '' && this.definition != null && this.isClass && this.constructors.get$length() == 0) {
     var span = this.definition.span;
     var inits = null, native_ = null, body = null;
     if (this.isNative) {
       native_ = '';
       inits = null;
     }
     else {
       body = null;
       inits = [new CallExpression(new SuperExpression(span), [], span)];
     }
     var typeDef = this.definition;
-    var c = new FunctionDefinition(null, null, typeDef.name, [], null, inits, native_, body, span);
+    var c = new FunctionDefinition(null, null, typeDef.name, [], inits, native_, body, span);
     this.addMethod(null, c);
     this.constructors.$index('').resolve$0();
     return this.constructors.$index('');
   }
   return null;
 }
 DefinedType.prototype.getMember = function(memberName) {
   var member = this.members.$index(memberName);
   if (member != null) {
     this._checkOverride(member);
@@ skipping 1582 matching lines @@
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_E, DoubleLinkedQueueEntry_E);
 $inheritsMembers(_DoubleLinkedQueueEntrySentinel_KeyValuePair_K$V, DoubleLinkedQueueEntry_KeyValuePair_K$V);
 //  ********** Globals **************
 function $static_init(){
   $globals._GREEN_COLOR = '\u001b[32m';
   $globals._MAGENTA_COLOR = '\u001b[35m';
   $globals._NO_COLOR = '\u001b[0m';
   $globals._RED_COLOR = '\u001b[31m';
 }
 var const$0 = new EnvMap()/*const EnvMap()*/;
+var const$127 = new IllegalAccessException()/*const IllegalAccessException()*/;
+var const$128 = ImmutableList.ImmutableList$from$factory([])/*const []*/;
 var const$2 = new EmptyQueueException()/*const EmptyQueueException()*/;
 var const$3 = new _DeletedKeySentinel()/*const _DeletedKeySentinel()*/;
 var const$8 = new NoMoreElementsException()/*const NoMoreElementsException()*/;
 var $globals = {};
 $static_init();
 main();