Revert "cleanup resolveMember and get/set"

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 extends Element {
   bool isTested = false;
   bool isChecked = false;
   bool isWritten = false;
 
   /**
    * 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;
 
   Member _typeMember;
 
   /** Stubs used to call into this method dynamically. */
   Map<String, VarMember> varStubs;
 
-  /** Cache of [Member]s that have been found. */
-  Map<String, Member> _foundMembers;
+  /** Cache of [MemberSet]s that have been resolved. */
+  Map<String, MemberSet> _resolvedMembers;
 
-  Type(String name): _foundMembers = {}, varStubs = {}, super(name, null);
+  Type(String name): _resolvedMembers = {}, varStubs = {}, super(name, null);
 
   void markUsed() {}
   abstract void genMethod(Member method);
 
   TypeMember get typeMember() {
     if (_typeMember == null) {
       _typeMember = new TypeMember(this);
     }
     return _typeMember;
   }
@@ skipping 161 matching lines @@
           var ret = i.getMember(memberName);
           if (ret != null) {
             return ret;
           }
         }
       }
       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 209 matching lines @@
 
   Map<String, MethodMember> get constructors() {
     world.internalError('no constructors on type parameters yet');
   }
 
   MethodMember getCallMethod() => extendsType.getCallMethod();
 
   void genMethod(Member method) {
     extendsType.genMethod(method);
   }