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

frog/type.dart

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 class Type implements Named, Hashable {
   final String name;
   bool isTested;
 
   /**
    * For core types (int, String, etc) this is the generated type assertion
    * function (uses JS "typeof"). This field is null for all other types.
    */
   String typeCheckCode;
 
   String _jsname;
 
   Member _typeMember;
 
   /** Stubs used to call into this method dynamically. Lazy initialized. */
   Map<String, VarMember> varStubs;
 
-  Type(this.name): isTested = false;
+  /** Cache of [MemberSet]s that have been resolved. */
+  Map<String, MemberSet> _resolvedMembers;
+
+  Type(this.name): isTested = false, _resolvedMembers = {};
 
   void markUsed() {}
   abstract void genMethod(Member method);
 
   TypeMember get typeMember() {
     if (_typeMember == null) {
       _typeMember = new TypeMember(this);
     }
     return _typeMember;
   }
 
   abstract SourceSpan get span();
 
   abstract Type resolveType(TypeReference node, bool isRequired);
 
   abstract Type resolveTypeParams(ConcreteType inType);
 
-  abstract MemberSet resolveMember(String name);
   Member getMember(String name) => null;
   abstract MethodMember getConstructor(String name);
   abstract MethodMember getFactory(Type type, String name);
   abstract Type getOrMakeConcreteType(List<Type> typeArgs);
   abstract Map<String, MethodMember> get constructors();
   abstract addDirectSubtype(Type type);
   abstract bool get isClass();
   abstract Library get library();
+  Set<Type> get subtypes() => null;
 
   // TODO(jmesserly): rename to isDynamic?
   bool get isVar() => false;
   bool get isTop() => false;
 
   bool get isObject() => false;
   bool get isString() => false;
   bool get isBool() => false;
   bool get isFunction() => false;
   bool get isList() => false;
@@ skipping 101 matching lines @@
             return ret;
           }
         }
         return null;
       } else {
         return world.objectType.getMember(memberName);
       }
     }
   }
 
+  MemberSet resolveMember(String memberName) {
+    MemberSet ret = _resolvedMembers[memberName];
+    if (ret != null) return ret;
+
+    Member member = getMember(memberName);
+    if (member == null) {
+      // TODO(jimhug): Check for members on subtypes given dart's dynamism.
+      return null;
+    }
+
+    // TODO(jimhug): Move this adding subtypes logic to MemberSet?
+    ret = new MemberSet(member);
+    _resolvedMembers[memberName] = ret;
+    if (member.isStatic) {
+      return ret;
+    } else {
+      for (var t in subtypes) {
+        if (!isClass && t.isClass) {
+          // If this is an interface, the actual implementation may
+          // come from a class that does not implement this interface.
+          // TODO(vsm): Use a more efficient lookup strategy.
+          // TODO(jimhug): This is made uglier by need to avoid dups.
+          final m = t.getMember(memberName);
+          if (m != null && ret.members.indexOf(m) == -1) {
+            ret.add(m);
+          }
+        } else {
+          final m = t.members[memberName];
+          if (m != null) ret.add(m);
+        }
+      }
+      return ret;
+    }
+  }
+
   void ensureSubtypeOf(Type other, SourceSpan span, [bool typeErrors=false]) {
     if (!isSubtypeOf(other)) {
       var msg = 'type $name is not a subtype of ${other.name}';
       if (typeErrors) {
         world.error(msg, span);
       } else {
         world.warning(msg, span);
       }
     }
   }
@@ skipping 295 matching lines @@
   FactoryMap get factories() => type.factories;
   Collection<Type> get typeArgsInOrder() => type.typeArgsInOrder;
   DefinedType get genericType() => type.genericType;
   List<Type> get interfaces() => type.interfaces;
   Type get parent() => type.parent;
   Map<String, Member> getAllMembers() => type.getAllMembers();
   bool get isNativeType() => type.isNativeType;
 }
 
 /** A concrete version of a generic type. */