TBR (red build bot).

frog/value.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.
 
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The [Type] of the [Value]. */
   Type type;
@@ skipping 10 matching lines @@
   /** If we reference this value multiple times, do we need a temp? */
   bool needsTemp;
 
   Value(this.type, this.code,
         // TODO(sigmund): reorder, so that needsTemp comes first.
         [this.isSuper = false, this.needsTemp = true, this.isType = false]) {
     if (type == null) type = world.varType;
   }
 
   /** Is this value a constant expression? */
-  bool get isConst() => false;
+  bool get isConst () => false;
 
   // TODO(jimhug): These three methods are still a little too similar for me.
   get_(MethodGenerator context, String name, Node node) {
     var member = _resolveMember(context, name, node);
     if (member != null) {
       member = member.get_(context, node, this);
     }
     // member.get_ returns null if no signatures match the given node.
     if (member != null) {
       return member;
     } else {
       return invokeNoSuchMethod(context, 'get:$name', node);
     }
   }
 
   set_(MethodGenerator context, String name, Node node, Value value,
       [bool isDynamic=false]) {
-    var member = _resolveMember(context, name, node, isDynamic);
+    var member = _resolveMember(context, name, node);
     if (member != null) {
       member = member.set_(context, node, this, value, isDynamic);
     }
     // member.set_ returns null if no signatures match the given node.
     if (member != null) {
       return member;
     } else {
       return invokeNoSuchMethod(context, 'set:$name', node,
           new Arguments(null, [value]));
     }
@@ skipping 21 matching lines @@
     if (name == '\$call') {
       if (isType) {
         world.error('must use "new" or "const" to construct a new instance',
             node.span);
       }
       if (type.needsVarCall(args)) {
         return _varCall(context, args);
       }
     }
 
-    var member = _resolveMember(context, name, node, isDynamic);
+    var member = _resolveMember(context, name, node);
     if (member == null) {
       return invokeNoSuchMethod(context, name, node, args);
     } else {
       return member.invoke(context, node, this, args, isDynamic);
     }
   }
 
   bool canInvoke(MethodGenerator context, String name, Arguments args) {
     // TODO(jimhug): The != method is weird - understand it better.
     if (type.isVar && name == '\$ne') {
       return true;
     }
 
     if (type.isVarOrFunction && name == '\$call') {
       return true;
     }
 
-    var member = _resolveMember(context, name, null, isDynamic:true);
+    var member = _tryResolveMember(context, name);
     return member != null && member.canInvoke(context, args);
   }
 
-  /**
-   * True if this class (or some related class that is not Object) overrides
-   * noSuchMethod. If it does we suppress warnings about unknown members.
-   */
-  // TODO(jmesserly): should we be doing this?
-  bool _hasOverriddenNoSuchMethod() {
-    if (isSuper) {
-      var m = type.getMember('noSuchMethod');
-      return m != null && !m.declaringType.isObject;
+  // TODO(jimhug): Better type here - currently is union(Member, MemberSet)
+  _tryResolveMember(MethodGenerator context, String name) {
+    var member = null;
+    if (!type.isVar) {
+      if (isSuper) {
+        return type.getMember(name);
+      } else {
+        member = type.resolveMember(name);
+      }
+    }
+
+    if (member == null) {
+      // TODO(jmesserly): shouldn't look in world except for "var"
+      member = context.findMembers(name);
+    }
+    return member;
+  }
+
+  _resolveMember(MethodGenerator context, String name, Node node) {
+    var member = _tryResolveMember(context, name);
+    if (member != null) {
+      if (isType && !member.isStatic) {
+        world.error('can not refer to instance member as static', node.span);
+      }
+      return member;
     } else {
-      return type.resolveMember('noSuchMethod').members.length > 1;
+      // TODO(jmesserly): we suppress warnings if someone has overridden
+      // noSuchMethod, and we know it will call their version. Is that right?
+      if (_tryResolveMember(context, 'noSuchMethod').members.length > 1) {
+        return null;
+      }
+
+      var typeName = type.name == null ? type.library.name : type.name;
+      var message = 'can not resolve "$name" on "${typeName}"';
+      if (isType) {
+        world.error(message, node.span);
+      } else {
+        world.warning(message, node.span);
+      }
+      // TODO(jmesserly): isn't this condition always true if we got here?
+      if (context.findMembers(name) == null) {
+        world.warning('$name is not defined anywhere in the world.', node.span);
+      }
+      return null;
     }
   }
 
-  // TODO(jimhug): Better type here - currently is union(Member, MemberSet)
-  _resolveMember(MethodGenerator context, String name, Node node,
-        [bool isDynamic=false]) {
-
-    // TODO(jmesserly): until reified generic lists are fixed, treat
-    // ParameterType as "var".
-    var member;
-    if (!type.isVar && type is! ParameterType) {
-      if (isSuper) {
-        member = type.getMember(name);
-      } else {
-        member = type.resolveMember(name);
-      }
-
-      if (member != null && isType && !member.isStatic) {
-        if (!isDynamic) {
-          world.error('can not refer to instance member as static', node.span);
-        }
-        return null;
-      }
-
-      if (member == null && !isDynamic && !_hasOverriddenNoSuchMethod()) {
-        var typeName = type.name == null ? type.library.name : type.name;
-        var message = 'can not resolve "$name" on "${typeName}"';
-        if (isType) {
-          world.error(message, node.span);
-        } else {
-          world.warning(message, node.span);
-        }
-      }
-    }
-
-    // Fall back to a dynamic operation for instance members
-    if (member == null && !isSuper && !isType) {
-      member = context.findMembers(name);
-      if (member == null && !isDynamic) {
-        world.warning('$name is not defined anywhere in the world.',
-           node.span);
-      }
-    }
-
-    return member;
-  }
-
   checkFirstClass(SourceSpan span) {
     if (isType) {
       world.error('Types are not first class', span);
     }
   }
 
   /** Generate a call to an unknown function type. */
   Value _varCall(MethodGenerator context, Arguments args) {
     // TODO(jmesserly): calls to unknown functions will bypass type checks,
     // which normally happen on the caller side, or in the generated stub for
@@ skipping 247 matching lines @@
     /*if (args != null && args.hasNames) {
       var names = [];
       for (int i = args.bareCount; i < args.length; i++) {
         names.add('"${args.getName(i)}", ${args.values[i].code}');
       }
       noSuchArgs.add(new Value(world.gen.useMapFactory(),
           '\$map(${Strings.join(names, ", ")})'));
     }*/
 
     // Finally, invoke noSuchMethod
-    return _resolveMember(context, 'noSuchMethod', node).invoke(
+    return _tryResolveMember(context, 'noSuchMethod').invoke(
         context, node, this, new Arguments(null, noSuchArgs));
   }
 
   Value invokeSpecial(String name, Arguments args, Type returnType) {
     assert(name.startsWith('\$'));
     assert(!args.hasNames);
     // TODO(jimhug): We need to do this a little bit more like get and set on
     // properties.  We should check the set of members for something
     // like "requiresNativeIndexer" and "requiresDartIndexer" to
     // decide on a strategy.
 
     var argsString = args.getCode();
     // Most operator calls need to be emitted as function calls, so we don't
     // box numbers accidentally. Indexing is the exception.
     if (name == '\$index' || name == '\$setindex') {
       return new Value(returnType, '$code.$name($argsString)');
     } else {
       if (argsString.length > 0) argsString = ', $argsString';
       world.gen.corejs.useOperator(name);
       return new Value(returnType, '$name($code$argsString)');
     }
   }
 }
 
-// TODO(jmesserly): the subtypes of Value require a lot of type checks and
-// downcasts to use; can we make that cleaner? (search for ".dynamic")
-
 /** A value that can has been evaluated statically. */
 class EvaluatedValue extends Value {
 
   var actualValue;
 
   bool get isConst() => true;
 
   /**
    * A canonicalized form of the code. Two const expressions that result in the
    * same instance should have the same [canonicalCode].
@@ skipping 152 matching lines @@
       return 1;
     } else if (name != null && other.name == null) {
       return -1;
     } else if (name != null) {
       return name.compareTo(other.name);
     } else {
       return field.name.compareTo(other.field.name);
     }
   }
 }