fix issue 1110 (handle void better)

frog/minfrog

 #!/usr/bin/env node
 //  ********** Library dart:core **************
 //  ********** Natives dart:core **************
 function $throw(e) {
   // If e is not a value, we can use V8's captureStackTrace utility method.
   // TODO(jmesserly): capture the stack trace on other JS engines.
   if (e && (typeof e == 'object') && Error.captureStackTrace) {
     // TODO(jmesserly): this will clobber the e.stack property
     Error.captureStackTrace(e, $throw);
   }
@@ skipping 278 matching lines @@
 }, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "removeLast$0", { value: function() {
   return this.noSuchMethod("removeLast", []);
 }, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "replaceFirst$2", { value: function($0, $1) {
   return this.noSuchMethod("replaceFirst", [$0, $1]);
 }, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "resolve$0", { value: function() {
   return this.noSuchMethod("resolve", []);
 }, enumerable: false, configurable: true });
+Object.defineProperty(Object.prototype, "resolveType$2", { value: function($0, $1) {
+  return this.noSuchMethod("resolveType", [$0, $1]);
+}, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "resolveTypeParams$1", { value: function($0) {
   return this.noSuchMethod("resolveTypeParams", [$0]);
 }, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "setDefinition$1", { value: function($0) {
   return this.noSuchMethod("setDefinition", [$0]);
 }, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "set_$4", { value: function($0, $1, $2, $3) {
   return this.noSuchMethod("set_", [$0, $1, $2, $3]);
 }, enumerable: false, configurable: true });
 Object.defineProperty(Object.prototype, "some$1", { value: function($0) {
@@ skipping 1996 matching lines @@
       for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
         var tp = $$list.$index($$i);
         if ($eq(tp.get$name(), name)) {
           typeRef.type = tp;
         }
       }
     }
     if (typeRef.type != null) {
       return typeRef.type;
     }
-    return this.get$enclosingElement().resolveType(node, typeErrors);
+    return this.get$enclosingElement().resolveType$2(node, typeErrors);
   }
   else if ((node instanceof GenericTypeReference)) {
     var typeRef = node;
-    var baseType = this.resolveType(typeRef.baseType, typeErrors);
+    var baseType = this.resolveType$2(typeRef.baseType, typeErrors);
     if (!baseType.get$isGeneric()) {
       $globals.world.error(("" + baseType.get$name() + " is not generic"), typeRef.span);
       return null;
     }
     if (typeRef.typeArguments.get$length() != baseType.get$typeParameters().get$length()) {
       $globals.world.error("wrong number of type arguments", typeRef.span);
       return null;
     }
     var typeArgs = [];
     for (var i = (0);
      i < typeRef.typeArguments.get$length(); i++) {
-      typeArgs.add$1(this.resolveType(typeRef.typeArguments.$index(i), typeErrors));
+      typeArgs.add$1(this.resolveType$2(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);
   }
   else {
     $globals.world.internalError("unknown type reference", node.span);
   }
   return node.type;
 }
 Element.prototype.hashCode$0 = Element.prototype.hashCode;
 Element.prototype.resolve$0 = Element.prototype.resolve;
+Element.prototype.resolveType$2 = Element.prototype.resolveType;
 // ********** Code for WorldGenerator **************
 function WorldGenerator(main, writer) {
   this.main = main;
   this.hasStatics = false;
   this.corejs = new CoreJs();
   this.globals = new HashMapImplementation();
   this.writer = writer;
 }
 WorldGenerator.prototype.run = function() {
   var metaGen = new MethodGenerator(this.main, null);
@@ skipping 626 matching lines @@
   var ret = new Value(type, jsName, span, false);
   ret.set$isFinal(isFinal);
   this._vars.$setindex(name, ret);
   if (name != jsName) this._jsNames.add(jsName);
   return ret;
 }
 BlockScope.prototype.declareParameter = function(p) {
   return this.create(p.name, p.type, p.definition.span, false, true);
 }
 BlockScope.prototype.declare = function(id) {
-  var type = this.enclosingMethod.method.resolveType(id.type, false);
+  var type = this.enclosingMethod.method.resolveType$2(id.type, false);
   return this.create(id.name.name, type, id.span, false, false);
 }
 BlockScope.prototype.getRethrow = function() {
   var scope = this;
   while (scope.get$rethrow() == null && scope.get$parent() != null) {
     scope = scope.get$parent();
   }
   return scope.get$rethrow();
 }
 // ********** Code for MethodGenerator **************
@@ skipping 460 matching lines @@
   var parser = new Parser(node.span.file, false, false, false, node.span.start);
   this.visitStatementsInBlock(parser.block$0());
   return false;
 }
 MethodGenerator.prototype.visitVariableDefinition = function(node) {
   var isFinal = false;
   if (node.modifiers != null && $eq(node.modifiers.$index((0)).get$kind(), (99))) {
     isFinal = true;
   }
   this.writer.write("var ");
-  var type = this.method.resolveType(node.type, false);
+  var type = this.method.resolveType$2(node.type, false);
   for (var i = (0);
    i < node.names.get$length(); i++) {
     var thisType = type;
     if (i > (0)) {
       this.writer.write(", ");
     }
     var name = node.names.$index(i).get$name();
     var value = this.visitValue(node.values.$index(i));
     if (isFinal) {
       if (value == null) {
@@ skipping 147 matching lines @@
   this._popBlock();
   return false;
 }
 MethodGenerator.prototype._isFinal = function(typeRef) {
   if ((typeRef instanceof GenericTypeReference)) {
     typeRef = typeRef.get$baseType();
   }
   return typeRef != null && typeRef.get$isFinal();
 }
 MethodGenerator.prototype.visitForInStatement = function(node) {
-  var itemType = this.method.resolveType(node.item.type, false);
+  var itemType = this.method.resolveType$2(node.item.type, false);
   var itemName = node.item.name.name;
   var list = node.list.visit(this);
   this._pushBlock(true);
   var isFinal = this._isFinal(node.item.type);
   var item = this._scope.create(itemName, itemType, node.item.name.span, isFinal, false);
   if (list.get$needsTemp()) {
     var listVar = this._scope.create("$list", list.get$type(), null, false, false);
     this.writer.writeln(("var " + listVar.get$code() + " = " + list.get$code() + ";"));
     list = listVar;
   }
@@ skipping 26 matching lines @@
   this.writer.writeln(("var " + trace.get$code() + " = " + result.get$code() + ";"));
 }
 MethodGenerator.prototype.visitTryStatement = function(node) {
   this.writer.enterBlock("try {");
   this._pushBlock(false);
   this.visitStatementsInBlock(node.body);
   this._popBlock();
   if (node.catches.get$length() == (1)) {
     var catch_ = node.catches.$index((0));
     this._pushBlock(false);
-    var exType = this.method.resolveType(catch_.get$exception().get$type(), false);
+    var exType = this.method.resolveType$2(catch_.get$exception().get$type(), false);
     var ex = this._scope.declare(catch_.get$exception());
     this._scope.rethrow = ex;
     this.writer.nextBlock(("} catch (" + ex.get$code() + ") {"));
     if (catch_.get$trace() != null) {
       var trace = this._scope.declare(catch_.get$trace());
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     if (!exType.get$isVarOrObject()) {
       var test = ex.instanceOf$3$isTrue$forceCheck(this, exType, catch_.get$exception().get$span(), false, true);
@@ skipping 14 matching lines @@
     )) {
       trace = this._scope.create("$trace", $globals.world.varType, null, false, false);
       this._genStackTraceOf(trace, ex);
     }
     this._genToDartException(ex);
     var needsRethrow = true;
     for (var i = (0);
      i < node.catches.get$length(); i++) {
       var catch_ = node.catches.$index(i);
       this._pushBlock(false);
-      var tmpType = this.method.resolveType(catch_.get$exception().get$type(), false);
+      var tmpType = this.method.resolveType$2(catch_.get$exception().get$type(), false);
       var tmp = this._scope.declare(catch_.get$exception());
       if (!tmpType.get$isVarOrObject()) {
         var test = ex.instanceOf$3$isTrue$forceCheck(this, tmpType, catch_.get$exception().get$span(), true, true);
         if (i == (0)) {
           this.writer.enterBlock(("if (" + test.get$code() + ") {"));
         }
         else {
           this.writer.nextBlock(("} else if (" + test.get$code() + ") {"));
         }
       }
@@ skipping 405 matching lines @@
   var constructorName = "";
   if (node.name != null) {
     constructorName = node.name.name;
   }
   if ($eq(constructorName, "") && !(typeRef instanceof GenericTypeReference) && typeRef.get$names() != null) {
     var names = ListFactory.ListFactory$from$factory(typeRef.get$names());
     constructorName = names.removeLast$0().get$name();
     if ($eq(names.get$length(), (0))) names = null;
     typeRef = new NameTypeReference(typeRef.get$isFinal(), typeRef.get$name(), names, typeRef.get$span());
   }
-  var type = this.method.resolveType(typeRef, true);
+  var type = this.method.resolveType$2(typeRef, true);
   if (type.get$isTop()) {
     type = type.get$library().findTypeByName$1(constructorName);
     constructorName = "";
   }
   if ((type instanceof ParameterType)) {
     $globals.world.error("cannot instantiate a type parameter", node.span);
     return this._makeMissingValue(constructorName);
   }
   var m = type.getConstructor$1(constructorName);
   if (m == null) {
@@ skipping 17 matching lines @@
     }
   }
   var target = new Value.type$ctor(type, typeRef.get$span());
   return m.invoke$4(this, node, target, this._makeArgs(node.arguments));
 }
 MethodGenerator.prototype.visitListExpression = function(node) {
   var argValues = [];
   var listType = $globals.world.listType;
   var type = $globals.world.varType;
   if (node.itemType != null) {
-    type = this.method.resolveType(node.itemType, true);
+    type = this.method.resolveType$2(node.itemType, true);
     if (node.isConst && ((type instanceof ParameterType) || type.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const list literals");
     }
     listType = listType.getOrMakeConcreteType$1([type]);
   }
   var $$list = node.values;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var item = $$list.$index($$i);
     var arg = this.visitTypedValue(item, type);
     argValues.add$1(arg);
     if (node.isConst && !arg.get$isConst()) {
       $globals.world.error("const list can only contain const values", arg.get$span());
     }
   }
   $globals.world.listFactoryType.markUsed();
   var ret = new ListValue(argValues, node.isConst, listType, node.span);
   if (ret.get$isConst()) return ret.getGlobalValue$0();
   return ret;
 }
 MethodGenerator.prototype.visitMapExpression = function(node) {
   if (node.items.get$length() == (0) && !node.isConst) {
     return $globals.world.mapType.getConstructor("").invoke$4(this, node, new Value.type$ctor($globals.world.mapType, node.span), Arguments.get$EMPTY());
   }
   var values = [];
   var valueType = $globals.world.varType, keyType = $globals.world.stringType;
   var mapType = $globals.world.mapType;
   if (node.valueType != null) {
     if (node.keyType != null) {
-      keyType = this.method.resolveType(node.keyType, true);
+      keyType = this.method.resolveType$2(node.keyType, true);
       if (!keyType.get$isString()) {
         $globals.world.error("the key type of a map literal must be \"String\"", keyType.get$span());
       }
       if (node.isConst && ((keyType instanceof ParameterType) || keyType.get$hasTypeParams())) {
         $globals.world.error("type parameter cannot be used in const map literals");
       }
     }
-    valueType = this.method.resolveType(node.valueType, true);
+    valueType = this.method.resolveType$2(node.valueType, true);
     if (node.isConst && ((valueType instanceof ParameterType) || valueType.get$hasTypeParams())) {
       $globals.world.error("type parameter cannot be used in const map literals");
     }
     mapType = mapType.getOrMakeConcreteType$1([keyType, valueType]);
   }
   for (var i = (0);
    i < node.items.get$length(); i += (2)) {
     var key = this.visitTypedValue(node.items.$index(i), keyType);
     if (node.isConst && !key.get$isConst()) {
       $globals.world.error("const map can only contain const keys", key.get$span());
@@ skipping 11 matching lines @@
 }
 MethodGenerator.prototype.visitConditionalExpression = function(node) {
   var test = this.visitBool(node.test);
   var trueBranch = this.visitValue(node.trueBranch);
   var falseBranch = this.visitValue(node.falseBranch);
   var code = ("" + test.get$code() + " ? " + trueBranch.get$code() + " : " + falseBranch.get$code());
   return new Value(Type.union(trueBranch.get$type(), falseBranch.get$type()), code, node.span, true);
 }
 MethodGenerator.prototype.visitIsExpression = function(node) {
   var value = this.visitValue(node.x);
-  var type = this.method.resolveType(node.type, false);
+  var type = this.method.resolveType$2(node.type, false);
   return value.instanceOf$4(this, type, node.span, node.isTrue);
 }
 MethodGenerator.prototype.visitParenExpression = function(node) {
   var body = this.visitValue(node.body);
   if (body.get$isConst()) return body;
   return new Value(body.get$type(), ("(" + body.get$code() + ")"), node.span, true);
 }
 MethodGenerator.prototype.visitDotExpression = function(node) {
   var target = node.self.visit(this);
   return target.get_$3(this, node.name.name, node.name);
@@ skipping 573 matching lines @@
 Library.prototype.hashCode = function() {
   return this.baseSource.filename.hashCode();
 }
 Library.prototype.$eq = function(other) {
   return (other instanceof Library) && $eq(other.get$baseSource().get$filename(), this.baseSource.filename);
 }
 Library.prototype.findTypeByName$1 = Library.prototype.findTypeByName;
 Library.prototype.hashCode$0 = Library.prototype.hashCode;
 Library.prototype.postResolveChecks$0 = Library.prototype.postResolveChecks;
 Library.prototype.resolve$0 = Library.prototype.resolve;
+Library.prototype.resolveType$2 = Library.prototype.resolveType;
 Library.prototype.toString$0 = Library.prototype.toString;
 Library.prototype.visitSources$0 = Library.prototype.visitSources;
 // ********** Code for _LibraryVisitor **************
 function _LibraryVisitor(library) {
   this.library = library;
   this.isTop = true;
   this.seenSource = false;
   this.seenResource = false;
   this.seenImport = false;
   this.currentType = this.library.topType;
@@ skipping 197 matching lines @@
 Parameter.prototype.get$isInitializer = function() { return this.isInitializer; };
 Parameter.prototype.set$isInitializer = function(value) { return this.isInitializer = value; };
 Parameter.prototype.get$value = function() { return this.value; };
 Parameter.prototype.set$value = function(value) { return this.value = value; };
 Parameter.prototype.resolve = function() {
   this.name = this.definition.name.name;
   if (this.name.startsWith("this.")) {
     this.name = this.name.substring((5));
     this.isInitializer = true;
   }
-  this.type = this.method.resolveType(this.definition.type, false);
+  this.type = this.method.resolveType$2(this.definition.type, false);
   if (this.definition.value != null) {
     if (!this.get$hasDefaultValue()) return;
     if (this.method.name == ":call") {
       if (this.method.get$definition().get$body() == null && !this.method.get$isNative()) {
         $globals.world.error("default value not allowed on function type", this.definition.span);
       }
     }
     else if (this.method.get$isAbstract()) {
       $globals.world.error("default value not allowed on abstract methods", this.definition.span);
     }
@@ skipping 453 matching lines @@
 ConcreteMember.prototype.get$definition = function() {
   return this.baseMember.get$definition();
 }
 ConcreteMember.prototype.get$initDelegate = function() {
   return this.baseMember.get$initDelegate();
 }
 ConcreteMember.prototype.set$initDelegate = function(ctor) {
   this.baseMember.set$initDelegate(ctor);
 }
 ConcreteMember.prototype.resolveType = function(node, isRequired) {
-  var type = this.baseMember.resolveType(node, isRequired);
+  var type = this.baseMember.resolveType$2(node, isRequired);
   return type.resolveTypeParams$1(this.declaringType);
 }
 ConcreteMember.prototype.computeValue = function() {
   return this.baseMember.computeValue();
 }
 ConcreteMember.prototype.override = function(other) {
   return this.baseMember.override(other);
 }
 ConcreteMember.prototype._get = function(context, node, target, isDynamic) {
   var ret = this.baseMember._get(context, node, target, isDynamic);
@@ skipping 30 matching lines @@
 ConcreteMember.prototype._set$5 = ConcreteMember.prototype._set;
 ConcreteMember.prototype.canInvoke$2 = ConcreteMember.prototype.canInvoke;
 ConcreteMember.prototype.computeValue$0 = ConcreteMember.prototype.computeValue;
 ConcreteMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 ConcreteMember.prototype.invoke$4$isDynamic = ConcreteMember.prototype.invoke;
 ConcreteMember.prototype.invoke$5 = ConcreteMember.prototype.invoke;
 ConcreteMember.prototype.provideFieldSyntax$0 = ConcreteMember.prototype.provideFieldSyntax;
 ConcreteMember.prototype.providePropertySyntax$0 = ConcreteMember.prototype.providePropertySyntax;
+ConcreteMember.prototype.resolveType$2 = ConcreteMember.prototype.resolveType;
 // ********** Code for MethodMember **************
 $inherits(MethodMember, Member);
 function MethodMember(name, declaringType, definition) {
   this.isLambda = false;
   this._provideOptionalParamInfo = false;
   this.isFactory = false;
   this.definition = definition;
   this.isConst = false;
   this.isAbstract = false;
   this.isStatic = false;
@@ skipping 450 matching lines @@
   }
   else {
     if (this.definition.body == null && !this.get$isConstructor() && !this.get$isNative()) {
       $globals.world.error("method needs a body", this.get$span());
     }
   }
   if (this.get$isConstructor() && !this.isFactory) {
     this.returnType = this.declaringType;
   }
   else {
-    this.returnType = this.resolveType(this.definition.returnType, false);
+    this.returnType = this.resolveType(this.definition.returnType, false, true);
   }
   this.parameters = [];
   var $$list = this.definition.formals;
   for (var $$i = 0;$$i < $$list.get$length(); $$i++) {
     var formal = $$list.$index($$i);
     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) {
+MethodMember.prototype.resolveType = function(node, typeErrors, allowVoid) {
   var t = Element.prototype.resolveType.call(this, node, typeErrors);
   if (this.isStatic && !this.isFactory && (t instanceof ParameterType)) {
     $globals.world.error("using type parameter in static context.", node.span);
   }
+  if (!allowVoid && t.get$isVoid()) {
+    $globals.world.error("\"void\" only allowed as return type", node.span);
+  }
   return t;
 }
 MethodMember.prototype._evalConstConstructor$2 = MethodMember.prototype._evalConstConstructor;
 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) {
   return this._set($0, $1, $2, $3, false);
 };
 MethodMember.prototype._set$4$isDynamic = MethodMember.prototype._set;
 MethodMember.prototype._set$5 = MethodMember.prototype._set;
 MethodMember.prototype.canInvoke$2 = MethodMember.prototype.canInvoke;
 MethodMember.prototype.invoke$4 = function($0, $1, $2, $3) {
   return this.invoke($0, $1, $2, $3, false);
 };
 MethodMember.prototype.invoke$4$isDynamic = MethodMember.prototype.invoke;
 MethodMember.prototype.invoke$5 = MethodMember.prototype.invoke;
 MethodMember.prototype.namesInOrder$1 = MethodMember.prototype.namesInOrder;
 MethodMember.prototype.provideFieldSyntax$0 = MethodMember.prototype.provideFieldSyntax;
 MethodMember.prototype.providePropertySyntax$0 = MethodMember.prototype.providePropertySyntax;
 MethodMember.prototype.resolve$0 = MethodMember.prototype.resolve;
+MethodMember.prototype.resolveType$2 = function($0, $1) {
+  return this.resolveType($0, $1, false);
+};
 // ********** Code for MemberSet **************
 function MemberSet(member, isVar) {
   this.jsname = member.get$jsname();
   this.name = member.name;
   this.isVar = isVar;
   this.members = [member];
 }
 MemberSet.prototype.get$name = function() { return this.name; };
 MemberSet.prototype.get$members = function() { return this.members; };
 MemberSet.prototype.get$jsname = function() { return this.jsname; };
@@ skipping 3378 matching lines @@
     if (kind == (3) || kind == (1)) {
       this._afterParens.$setindex(saved, this._peekToken);
       return;
     }
     else if (kind == (2)) {
       this._lookaheadAfterParens(tokens);
     }
   }
 }
 Parser.prototype._typeAsIdentifier = function(type) {
+  if ($eq(type.get$name().get$name(), "void")) {
+    this._errorExpected(("identifer, but found \"" + type.get$name().get$name() + "\""));
+  }
   return type.get$name();
 }
 Parser.prototype._specialIdentifier = function(includeOperators) {
   var start = this._peekToken.start;
   var name;
   switch (this._peek()) {
     case (15):
 
       this._eat((15));
       this._lang_error("rest no longer supported", this._previousToken.get$span());
@@ skipping 368 matching lines @@
 }
 Parser.prototype._makeFunction = function(expr, formals, body) {
   var name, type;
   if ((expr instanceof VarExpression)) {
     name = expr.get$name();
     type = null;
   }
   else if ((expr instanceof DeclaredIdentifier)) {
     name = expr.get$name();
     type = expr.get$type();
+    if (name == null) {
+      this._lang_error("expected name and type", expr.get$span());
+    }
   }
   else {
     this._lang_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, body, span);
   return new LambdaExpression(func, func.get$span());
 }
 Parser.prototype._makeDeclaredIdentifier = function(e) {
   if ((e instanceof VarExpression)) {
@@ skipping 1208 matching lines @@
   $globals.world.internalError("no concrete types of type parameters yet", this.get$span());
 }
 ParameterType.prototype.resolveTypeParams = function(inType) {
   return inType.typeArguments.$index(this.name);
 }
 ParameterType.prototype.addDirectSubtype = function(type) {
   $globals.world.internalError("no subtypes of type parameters yet", this.get$span());
 }
 ParameterType.prototype.resolve = function() {
   if (this.typeParameter.extendsType != null) {
-    this.extendsType = this.get$enclosingElement().resolveType(this.typeParameter.extendsType, true);
+    this.extendsType = this.get$enclosingElement().resolveType$2(this.typeParameter.extendsType, true);
   }
   else {
     this.extendsType = $globals.world.objectType;
   }
 }
 ParameterType.prototype.addDirectSubtype$1 = ParameterType.prototype.addDirectSubtype;
 ParameterType.prototype.getConstructor$1 = ParameterType.prototype.getConstructor;
 ParameterType.prototype.getOrMakeConcreteType$1 = ParameterType.prototype.getOrMakeConcreteType;
 ParameterType.prototype.isSubtypeOf$1 = ParameterType.prototype.isSubtypeOf;
 ParameterType.prototype.resolve$0 = ParameterType.prototype.resolve;
@@ skipping 101 matching lines @@
 NonNullableType.prototype.get$isNative = function() {
   return this.type.get$isNative();
 }
 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.resolveType$2 = NonNullableType.prototype.resolveType;
 NonNullableType.prototype.resolveTypeParams$1 = NonNullableType.prototype.resolveTypeParams;
 // ********** Code for ConcreteType **************
 $inherits(ConcreteType, Type);
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.isUsed = false;
   this.constructors = new HashMapImplementation();
   this.genericType = genericType;
   this.factories = new FactoryMap();
   this.members = new HashMapImplementation();
   this.typeArguments = typeArguments;
@@ skipping 148 matching lines @@
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 ConcreteType.prototype.addDirectSubtype$1 = ConcreteType.prototype.addDirectSubtype;
 ConcreteType.prototype.getConstructor$1 = ConcreteType.prototype.getConstructor;
 ConcreteType.prototype.getFactory$2 = ConcreteType.prototype.getFactory;
 ConcreteType.prototype.getMember$1 = ConcreteType.prototype.getMember;
 ConcreteType.prototype.getOrMakeConcreteType$1 = ConcreteType.prototype.getOrMakeConcreteType;
 ConcreteType.prototype.markUsed$0 = ConcreteType.prototype.markUsed;
+ConcreteType.prototype.resolveType$2 = ConcreteType.prototype.resolveType;
 ConcreteType.prototype.resolveTypeParams$1 = ConcreteType.prototype.resolveTypeParams;
 // ********** Code for DefinedType **************
 $inherits(DefinedType, Type);
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false;
   this.directSubtypes = new HashSetImplementation();
   this.isNative = false;
   this.library = library;
   this.isClass = isClass;
   this.constructors = new HashMapImplementation();
@@ skipping 2611 matching lines @@
   $globals._RED_COLOR = "\x1b[31m";
 }
 var const$0000 = Object.create(EmptyQueueException.prototype, {});
 var const$0001 = Object.create(_DeletedKeySentinel.prototype, {});
 var const$0005 = Object.create(NoMoreElementsException.prototype, {});
 var const$0007 = Object.create(IllegalAccessException.prototype, {});
 var const$0008 = ImmutableList.ImmutableList$from$factory([]);
 var $globals = {};
 $static_init();
 main();