Remove duplicate resolveMember, fix type substitution for subtype of generic class

frog/frogsh

 #!/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) { 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 20859 matching lines @@
 DeclaredIdentifier.prototype.visit = function(visitor) {
   return visitor.visitDeclaredIdentifier(this);
 }
 DeclaredIdentifier.prototype.visit$1 = function($0) {
   return this.visit(($0 && $0.is$TreeVisitor()));
 };
 // ********** Code for lang_Type **************
 function lang_Type(name) {
   this.name = name;
   this.isTested = false;
+  this._resolvedMembers = $map([]);
   // Initializers done
 }
 lang_Type.prototype.is$lang_Type = function(){return this;};
 lang_Type.prototype.is$Named = function(){return this;};
 lang_Type.prototype.get$name = function() { return this.name; };
 lang_Type.prototype.get$isTested = function() { return this.isTested; };
 lang_Type.prototype.set$isTested = function(value) { return this.isTested = value; };
 lang_Type.prototype.get$typeCheckCode = function() { return this.typeCheckCode; };
 lang_Type.prototype.set$typeCheckCode = function(value) { return this.typeCheckCode = value; };
 lang_Type.prototype.get$varStubs = function() { return this.varStubs; };
 lang_Type.prototype.set$varStubs = function(value) { return this.varStubs = value; };
 lang_Type.prototype.markUsed = function() {
 
 }
 lang_Type.prototype.get$typeMember = function() {
   var $0;
   if (this._typeMember == null) {
     this._typeMember = new TypeMember((this && this.is$DefinedType()));
   }
   return (($0 = this._typeMember) && $0.is$TypeMember());
 }
 lang_Type.prototype.getMember = function(name) {
   return null;
 }
+lang_Type.prototype.get$subtypes = function() {
+  return null;
+}
 lang_Type.prototype.get$isVar = function() {
   return false;
 }
 lang_Type.prototype.get$isTop = function() {
   return false;
 }
 lang_Type.prototype.get$isObject = function() {
   return false;
 }
 lang_Type.prototype.get$isString = function() {
@@ skipping 129 matching lines @@
           return (ret && ret.is$Member());
         }
       }
       return null;
     }
     else {
       return $globals.world.objectType.getMember(memberName);
     }
   }
 }
+lang_Type.prototype.resolveMember = function(memberName) {
+  var $0;
+  var ret = (($0 = this._resolvedMembers.$index(memberName)) && $0.is$MemberSet());
+  if (ret != null) return ret;
+  var member = this.getMember(memberName);
+  if (member == null) {
+    return null;
+  }
+  ret = new MemberSet(member, false);
+  this._resolvedMembers.$setindex(memberName, ret);
+  if ($notnull_bool(member.get$isStatic())) {
+    return ret;
+  }
+  else {
+    var $list = this.get$subtypes();
+    for (var $i = this.get$subtypes().iterator(); $i.hasNext$0(); ) {
+      var t = $i.next$0();
+      if (!$notnull_bool(this.get$isClass()) && $notnull_bool(t.get$isClass())) {
+        var m = t.getMember$1(memberName);
+        if ($notnull_bool($ne(m, null)) && ret.members.indexOf(m) == -1) {
+          ret.add((m && m.is$Member()));
+        }
+      }
+      else {
+        var m = t.get$members().$index(memberName);
+        if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
+      }
+    }
+    return ret;
+  }
+}
 lang_Type.prototype.ensureSubtypeOf = function(other, span, typeErrors) {
   if (!$notnull_bool(this.isSubtypeOf(other))) {
     var msg = ('type ' + this.name + ' is not a subtype of ' + other.name);
     if ($notnull_bool(typeErrors)) {
       $globals.world.error($assert_String(msg), span);
     }
     else {
       $globals.world.warning($assert_String(msg), span);
     }
   }
@@ skipping 333 matching lines @@
 NonNullableType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for ConcreteType **************
 function ConcreteType(name, genericType, typeArguments, typeArgsInOrder) {
   this.genericType = genericType;
   this.typeArguments = typeArguments;
   this.typeArgsInOrder = typeArgsInOrder;
   this.constructors = $map([]);
   this.members = $map([]);
-  this._resolvedMembers = $map([]);
   this.factories = new FactoryMap();
   // Initializers done
   lang_Type.call(this, name);
 }
 $inherits(ConcreteType, lang_Type);
 ConcreteType.prototype.is$ConcreteType = function(){return this;};
 ConcreteType.prototype.get$genericType = function() { return this.genericType; };
 ConcreteType.prototype.get$typeArgsInOrder = function() { return this.typeArgsInOrder; };
 ConcreteType.prototype.set$typeArgsInOrder = function(value) { return this.typeArgsInOrder = value; };
 ConcreteType.prototype.get$isList = function() {
@@ skipping 46 matching lines @@
   if (this._interfaces == null && this.genericType.interfaces != null) {
     this._interfaces = [];
     var $list = this.genericType.interfaces;
     for (var $i = 0;$i < $list.length; $i++) {
       var i = $list.$index($i);
       this._interfaces.add(i.resolveTypeParams$1(this));
     }
   }
   return this._interfaces;
 }
+ConcreteType.prototype.get$subtypes = function() {
+  if (this._subtypes == null) {
+    this._subtypes = new HashSetImplementation();
+    var $list = this.genericType.get$subtypes();
+    for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext$0(); ) {
+      var s = $i.next$0();
+      this._subtypes.add(s.resolveTypeParams$1(this));
+    }
+  }
+  return this._subtypes;
+}
 ConcreteType.prototype.getCallMethod = function() {
   return this.genericType.getCallMethod();
 }
 ConcreteType.prototype.getAllMembers = function() {
   var result = this.genericType.getAllMembers();
   var $list = result.getKeys$0();
   for (var $i = result.getKeys$0().iterator$0(); $i.hasNext$0(); ) {
     var memberName = $i.next$0();
     var myMember = this.members.$index(memberName);
     if ($notnull_bool($ne(myMember, null))) {
@@ skipping 43 matching lines @@
     return member;
   }
   var genericMember = this.genericType.members.$index(memberName);
   if ($notnull_bool($ne(genericMember, null))) {
     member = new ConcreteMember($assert_String(genericMember.get$name()), this, genericMember);
     this.members.$setindex(memberName, member);
     return member;
   }
   return this._getMemberInParents(memberName);
 }
-ConcreteType.prototype.resolveMember = function(memberName) {
-  var $0;
-  var ret = (($0 = this._resolvedMembers.$index(memberName)) && $0.is$MemberSet());
-  if (ret != null) return ret;
-  var member = this.getMember(memberName);
-  if (member == null) {
-    return null;
-  }
-  ret = new MemberSet(member, false);
-  this._resolvedMembers.$setindex(memberName, ret);
-  if ($notnull_bool(member.get$isStatic())) {
-    return ret;
-  }
-  else {
-    var $list = this.genericType.get$subtypes();
-    for (var $i = this.genericType.get$subtypes().iterator(); $i.hasNext$0(); ) {
-      var t = $i.next$0();
-      if (!$notnull_bool(this.get$isClass()) && $notnull_bool(t.get$isClass())) {
-        var m = t.getMember$1(memberName);
-        if ($notnull_bool($ne(m, null)) && ret.members.indexOf(m) == -1) {
-          ret.add((m && m.is$Member()));
-        }
-      }
-      else {
-        var m = t.get$members().$index(memberName);
-        if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
-      }
-    }
-    return ret;
-  }
-}
 ConcreteType.prototype.resolveType = function(node, isRequired) {
   var ret = this.genericType.resolveType(node, isRequired);
   return (ret && ret.is$lang_Type());
 }
 ConcreteType.prototype.addDirectSubtype = function(type) {
   this.genericType.addDirectSubtype(type);
 }
 ConcreteType.prototype.addDirectSubtype$1 = function($0) {
   return this.addDirectSubtype(($0 && $0.is$lang_Type()));
 };
 ConcreteType.prototype.getConstructor$1 = function($0) {
   return this.getConstructor($assert_String($0));
 };
 ConcreteType.prototype.getFactory$2 = function($0, $1) {
   return this.getFactory(($0 && $0.is$lang_Type()), $assert_String($1));
 };
 ConcreteType.prototype.getMember$1 = function($0) {
   return this.getMember($assert_String($0));
 };
 ConcreteType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 ConcreteType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
-ConcreteType.prototype.resolveMember$1 = function($0) {
-  return this.resolveMember($assert_String($0));
-};
 ConcreteType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 // ********** Code for DefinedType **************
 function DefinedType(name, library, definition, isClass) {
   this.isUsed = false
   this.isNativeType = false
   this.library = library;
   this.isClass = isClass;
   this.directSubtypes = new HashSetImplementation();
   this.constructors = $map([]);
   this.members = $map([]);
   this.factories = new FactoryMap();
-  this._resolvedMembers = $map([]);
   // Initializers done
   lang_Type.call(this, name);
   this.setDefinition(definition);
 }
 $inherits(DefinedType, lang_Type);
 DefinedType.prototype.is$DefinedType = function(){return this;};
 DefinedType.prototype.get$definition = function() { return this.definition; };
 DefinedType.prototype.set$definition = function(value) { return this.definition = value; };
 DefinedType.prototype.get$library = function() { return this.library; };
 DefinedType.prototype.get$isClass = function() { return this.isClass; };
@@ skipping 11 matching lines @@
 DefinedType.prototype.set$constructors = function(value) { return this.constructors = value; };
 DefinedType.prototype.get$members = function() { return this.members; };
 DefinedType.prototype.set$members = function(value) { return this.members = value; };
 DefinedType.prototype.get$factories = function() { return this.factories; };
 DefinedType.prototype.set$factories = function(value) { return this.factories = value; };
 DefinedType.prototype.get$isUsed = function() { return this.isUsed; };
 DefinedType.prototype.set$isUsed = function(value) { return this.isUsed = value; };
 DefinedType.prototype.get$isNativeType = function() { return this.isNativeType; };
 DefinedType.prototype.set$isNativeType = function(value) { return this.isNativeType = value; };
 DefinedType.prototype.setDefinition = function(def) {
-  $assert(this.definition == null, "definition == null", "type.dart", 728, 12);
+  $assert(this.definition == null, "definition == null", "type.dart", 735, 12);
   this.definition = def;
   if ((this.definition instanceof TypeDefinition) && $notnull_bool($ne(this.definition.get$nativeType(), null))) {
     this.isNativeType = true;
   }
   if (this.definition != null && this.definition.get$typeParameters() != null) {
     this._concreteTypes = $map([]);
     this.typeParameters = [];
     var $list = this.definition.get$typeParameters();
     for (var $i = 0;$i < $list.length; $i++) {
       var tp = $list.$index($i);
@@ skipping 92 matching lines @@
     var resolvedInterface = this.resolveType((type && type.is$TypeReference()), true);
     if ($notnull_bool(resolvedInterface.get$isClosed()) && !($notnull_bool(this.library.get$isCore()) || $notnull_bool(this.library.get$isCoreImpl()))) {
       $globals.world.error(('can not implement "' + resolvedInterface.get$name() + '": ') + 'only native implementation allowed', (($0 = type.get$span()) && $0.is$SourceSpan()));
     }
     resolvedInterface.addDirectSubtype$1(this);
     interfaces.add$1(resolvedInterface);
   }
   return (interfaces && interfaces.is$List$Type());
 }
 DefinedType.prototype.addDirectSubtype = function(type) {
-  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 849, 12);
+  $assert(this._subtypes == null, "_subtypes == null", "type.dart", 856, 12);
   this.directSubtypes.add(type);
 }
 DefinedType.prototype.get$subtypes = function() {
   var $0;
   if (this._subtypes == null) {
     this._subtypes = new HashSetImplementation();
     var $list = this.directSubtypes;
     for (var $i = this.directSubtypes.iterator(); $i.hasNext$0(); ) {
       var st = $i.next$0();
       this._subtypes.add(st);
@@ skipping 241 matching lines @@
     return member;
   }
   if ($notnull_bool(this.get$isTop())) {
     var libType = this.library.findTypeByName(memberName);
     if ($notnull_bool($ne(libType, null))) {
       return (($0 = libType.get$typeMember()) && $0.is$Member());
     }
   }
   return this._getMemberInParents(memberName);
 }
-DefinedType.prototype.resolveMember = function(memberName) {
-  var $0;
-  var ret = (($0 = this._resolvedMembers.$index(memberName)) && $0.is$MemberSet());
-  if (ret != null) return ret;
-  var member = this.getMember(memberName);
-  if (member == null) {
-    return null;
-  }
-  ret = new MemberSet(member, false);
-  this._resolvedMembers.$setindex(memberName, ret);
-  if ($notnull_bool(member.get$isStatic())) {
-    return ret;
-  }
-  else {
-    var $list = this.get$subtypes();
-    for (var $i = this.get$subtypes().iterator(); $i.hasNext$0(); ) {
-      var t = $i.next$0();
-      if (!$notnull_bool(this.isClass) && $notnull_bool(t.get$isClass())) {
-        var m = t.getMember$1(memberName);
-        if ($notnull_bool($ne(m, null)) && ret.members.indexOf(m) == -1) {
-          ret.add((m && m.is$Member()));
-        }
-      }
-      else {
-        var m = t.get$members().$index(memberName);
-        if ($notnull_bool($ne(m, null))) ret.add((m && m.is$Member()));
-      }
-    }
-    return ret;
-  }
-}
 DefinedType._getDottedName = function(type) {
   if (type.names != null) {
     var names = map(type.names, (function (n) {
       return n.get$name();
     })
     );
     return type.name.name + '.' + Strings.join((names && names.is$List$String()), '.');
   }
   else {
     return type.name.name;
@@ skipping 67 matching lines @@
   }
   else {
     $globals.world.internalError('unknown type reference', node.span);
   }
   return node.type;
 }
 DefinedType.prototype.resolveTypeParams = function(inType) {
   return this;
 }
 DefinedType.prototype.getOrMakeConcreteType = function(typeArgs) {
-  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1281, 12);
+  $assert(this.get$isGeneric(), "isGeneric", "type.dart", 1253, 12);
   var names = [this.name];
   var typeMap = $map([]);
   for (var i = 0;
    i < typeArgs.length; i++) {
     var paramName = this.typeParameters.$index(i).get$name();
     typeMap.$setindex(paramName, typeArgs.$index(i));
     names.add$1(typeArgs.$index(i).get$name());
   }
   var concreteName = Strings.join((names && names.is$List$String()), '\$');
   var ret = this._concreteTypes.$index(concreteName);
   if ($notnull_bool(ret == null)) {
     ret = new ConcreteType($assert_String(concreteName), this, typeMap, typeArgs);
     this._concreteTypes.$setindex(concreteName, ret);
   }
   return (ret && ret.is$lang_Type());
 }
 DefinedType.prototype.getCallStub = function(args) {
-  $assert(this.get$isFunction(), "isFunction", "type.dart", 1301, 12);
+  $assert(this.get$isFunction(), "isFunction", "type.dart", 1273, 12);
   var name = _getCallStubName('call', args);
   if (this.varStubs == null) this.varStubs = $map([]);
   var stub = this.varStubs.$index(name);
   if ($notnull_bool(stub == null)) {
     stub = new VarFunctionStub($assert_String(name), args);
     this.varStubs.$setindex(name, stub);
   }
   return (stub && stub.is$VarFunctionStub());
 }
 DefinedType.prototype.addDirectSubtype$1 = function($0) {
@@ skipping 13 matching lines @@
 };
 DefinedType.prototype.getOrMakeConcreteType$1 = function($0) {
   return this.getOrMakeConcreteType(($0 && $0.is$List$Type()));
 };
 DefinedType.prototype.markUsed$0 = function() {
   return this.markUsed();
 };
 DefinedType.prototype.resolve$0 = function() {
   return this.resolve();
 };
-DefinedType.prototype.resolveMember$1 = function($0) {
-  return this.resolveMember($assert_String($0));
-};
 DefinedType.prototype.resolveTypeParams$1 = function($0) {
   return this.resolveTypeParams(($0 && $0.is$ConcreteType()));
 };
 DefinedType.prototype.setDefinition$1 = function($0) {
   return this.setDefinition(($0 && $0.is$Definition()));
 };
 // ********** Code for NativeType **************
 function NativeType(spec) {
   // Initializers done
   if (spec.startsWith('*')) {
@@ skipping 1810 matching lines @@
       NATIVE,
       NEGATE,
       OPERATOR,
       SET,
       SOURCE,
       STATIC,
       TYPEDEF ]*/;
 var $globals = {};
 $static_init();
 main();