Lots of frog cleanup

frog/value.dart

 // Copyright (c) 2012, 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.
 
 
+interface CallingContext {
+  MemberSet findMembers(String name);
+  CounterLog get counters();
+  Library get library();
+  bool get isStatic();
+  MethodMember get method();
+
+  bool get needsCode();
+  bool get showWarnings();
+
+  // Hopefully remove the 5 members below that are only used for code gen.
+  String _makeThisCode();
+
+  Value getTemp(Value value);
+  VariableValue forceTemp(Value value);
+  Value assignTemp(Value tmp, Value v);
+  void freeTemp(VariableValue value);
+}
+
+// TODO(jimhug): Value needs better separation into three parts:
+//  1. Static analysis
+//  2. Type inferred abstract interpretation analysis
+//  3. Actual code generation
+/**
+ * This subtype of value is the one and only version used for static
+ * analysis.  It has no code and its type is always the static type.
+ */
+class PureStaticValue extends Value {
+  bool isConst;
+  bool isType;
+
+  // TODO(jimhug): Can we remove span?
+  PureStaticValue(Type type, SourceSpan span,
+    [this.isConst = false, this.isType = false]):
+    super(type, null, span);
+
+  Member getMem(CallingContext context, String name, Node node) {
+    var member = type.getMember(name);
+
+    if (member == null) {
+      world.warning('can not find "$name" on "${type.name}"', node.span);
+    }
+
+    if (isType && !member.isStatic) {
+      world.error('can not refer to instance member as static', node.span);
+    }
+
+    return member;
+  }
+
+  Value get_(CallingContext context, String name, Node node) {
+    if (type.isVar) return new PureStaticValue(world.varType, node.span);
+    var member = getMem(context, name, node);
+    if (member == null) return new PureStaticValue(world.varType, node.span);
+
+    return member._get(context, node, this);
+  }
+
+  Value set_(CallingContext context, String name, Node node, Value value,
+      [int kind=0, int returnKind=ReturnKind.IGNORE]) {
+    if (type.isVar) return new PureStaticValue(world.varType, node.span);
+
+    var member = getMem(context, name, node);
+    if (member != null) {
+      member._set(context, node, this, value);
+    }
+    return new PureStaticValue(value.type, node.span);
+  }
+
+  Value setIndex(CallingContext context, Value index, Node node, Value value,
+      [int kind=0, int returnKind=ReturnKind.IGNORE]) {
+    return invoke(context, ':setindex', node,
+      new Arguments(null, [index, value]));
+  }
+
+  Value unop(int kind, CallingContext context, var node) {
+    switch (kind) {
+      case TokenKind.NOT:
+        // TODO(jimhug): Issue #359 seeks to clarify this behavior.
+        // ?var newVal = convertTo(context, world.nonNullBool);
+        return new PureStaticValue(world.boolType, node.span);
+      case TokenKind.ADD:
+        if (!isConst && !type.isNum) {
+          world.error('no unary add operator in dart', node.span);
+        }
+        return new PureStaticValue(world.numType, node.span);
+      case TokenKind.SUB:
+        return invoke(context, ':negate', node, Arguments.EMPTY);
+      case TokenKind.BIT_NOT:
+        return invoke(context, ':bit_not', node, Arguments.EMPTY);
+    }
+    world.internalError('unimplemented: ${node.op}', node.span);
+  }
+
+  Value binop(int kind, Value other, CallingContext context, var node) {
+    var isConst = isConst && other.isConst;
+
+
+    switch (kind) {
+      case TokenKind.AND:
+      case TokenKind.OR:
+        return new PureStaticValue(world.boolType, node.span, isConst);
+      case TokenKind.EQ_STRICT:
+        return new PureStaticValue(world.boolType, node.span, isConst);
+      case TokenKind.NE_STRICT:
+        return new PureStaticValue(world.boolType, node.span, isConst);
+    }
+
+    var name = kind == TokenKind.NE ? ':ne': TokenKind.binaryMethodName(kind);
+    var ret = invoke(context, name, node, new Arguments(null, [other]));
+    if (isConst) {
+      ret = new PureStaticValue(ret.type, node.span, isConst);
+    }
+    return ret;
+  }
+
+
+  Value invoke(CallingContext context, String name, Node node,
+      Arguments args) {
+    if (type.isVar) return new PureStaticValue(world.varType, node.span);
+    if (type.isFunction && name == ':call') {
+      return new PureStaticValue(world.varType, node.span);
+    }
+
+    var member = getMem(context, name, node);
+    if (member == null) return new PureStaticValue(world.varType, node.span);
+
+    return member.invoke(context, node, this, args);
+  }
+}
+
+
 /**
  * Represents a meta-value for code generation.
  */
 class Value {
   /** The inferred (i.e. most precise) [Type] of the [Value]. */
   final Type type;
 
   /** The javascript code to generate this value. */
   final String code;
 
@@ skipping 60 matching lines @@
   Value _tryUnion(Value right) => null;
 
   // TODO(jimhug): remove once type system works better.
   setField(Member field, Value value, [bool duringInit = false]) { }
 
   // Nothing to do in general?
   validateInitialized(SourceSpan span) { }
 
   // TODO(jimhug): Fix these names once get/set are truly pseudo-keywords.
   //   See issue #379.
-  Value get_(MethodGenerator context, String name, Node node) {
+  Value get_(CallingContext context, String name, Node node) {
     final member = _resolveMember(context, name, node);
     if (member != null) {
       return member._get(context, node, this);
     } else {
       return invokeNoSuchMethod(context, 'get:$name', node);
     }
   }
 
-  Value set_(MethodGenerator context, String name, Node node, Value value,
-      [bool isDynamic=false, int kind=0, int returnKind=ReturnKind.IGNORE]) {
-    final member = _resolveMember(context, name, node, isDynamic);
+  Value set_(CallingContext context, String name, Node node, Value value,
+      [int kind=0, int returnKind=ReturnKind.IGNORE]) {
+    final member = _resolveMember(context, name, node);
     if (member != null) {
       var thisValue = this;
       var thisTmp = null;
       var retTmp = null;
       if (kind != 0) {
         // TODO(jimhug): Very special number optimizations will go here...
         thisTmp = context.getTemp(thisValue);
         thisValue = context.assignTemp(thisTmp, thisValue);
         var lhs = member._get(context, node, thisTmp);
         if (returnKind == ReturnKind.PRE) {
           retTmp = context.forceTemp(lhs);
           lhs = context.assignTemp(retTmp, lhs);
         }
         value = lhs.binop(kind, value, context, node);
       }
 
       if (returnKind == ReturnKind.POST) {
         // TODO(jimhug): Optimize this away when native JS is detected.
         retTmp = context.forceTemp(value);
         value = context.assignTemp(retTmp, value);
       }
 
-      var ret = member._set(context, node, thisValue, value, isDynamic);
+      var ret = member._set(context, node, thisValue, value);
       if (thisTmp != null && thisTmp != this) context.freeTemp(thisTmp);
       if (retTmp != null) {
         context.freeTemp(retTmp);
         return Value.comma(ret, retTmp);
       } else {
         return ret;
       }
     } else {
       // TODO(jimhug): Need to support += and noSuchMethod better.
       return invokeNoSuchMethod(context, 'set:$name', node,
           new Arguments(null, [value]));
     }
   }
 
   // TODO(jimhug): This method body has too much in common with set_ above.
-  Value setIndex(MethodGenerator context, Value index, Node node, Value value,
-      [bool isDynamic=false, int kind=0, int returnKind=ReturnKind.IGNORE]) {
-    final member = _resolveMember(context, ':setindex', node, isDynamic);
+  Value setIndex(CallingContext context, Value index, Node node, Value value,
+      [int kind=0, int returnKind=ReturnKind.IGNORE]) {
+    final member = _resolveMember(context, ':setindex', node);
     if (member != null) {
       var thisValue = this;
       var indexValue = index;
       var thisTmp = null;
       var indexTmp = null;
       var retTmp = null;
       if (returnKind == ReturnKind.POST) {
         // TODO(jimhug): Optimize this away when native JS works.
         retTmp = context.forceTemp(value);
       }
@@ skipping 13 matching lines @@
         if (returnKind == ReturnKind.PRE) {
           lhs = context.assignTemp(retTmp, lhs);
         }
         value = lhs.binop(kind, value, context, node);
       }
       if (returnKind == ReturnKind.POST) {
         value = context.assignTemp(retTmp, value);
       }
 
       var ret = member.invoke(context, node, thisValue,
-        new Arguments(null, [indexValue, value]), isDynamic);
+        new Arguments(null, [indexValue, value]));
       if (thisTmp != null && thisTmp != this) context.freeTemp(thisTmp);
       if (indexTmp != null && indexTmp != index) context.freeTemp(indexTmp);
       if (retTmp != null) {
         context.freeTemp(retTmp);
         return Value.comma(ret, retTmp);
       } else {
         return ret;
       }
     } else {
       // TODO(jimhug): Need to support += and noSuchMethod better.
       return invokeNoSuchMethod(context, ':index', node,
           new Arguments(null, [index, value]));
     }
   }
 
-  //Value getIndex(MethodGenerator context, Value index, var node) {
+  //Value getIndex(CallingContext context, Value index, var node) {
   //}
 
-  Value unop(int kind, MethodGenerator context, var node) {
+  Value unop(int kind, CallingContext context, var node) {
     switch (kind) {
       case TokenKind.NOT:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         var newVal = convertTo(context, world.nonNullBool);
         return new Value(newVal.type, '!${newVal.code}', node.span);
       case TokenKind.ADD:
         world.error('no unary add operator in dart', node.span);
         break;
       case TokenKind.SUB:
         return invoke(context, ':negate', node, Arguments.EMPTY);
       case TokenKind.BIT_NOT:
         return invoke(context, ':bit_not', node, Arguments.EMPTY);
     }
     world.internalError('unimplemented: ${node.op}', node.span);
   }
 
-  Value binop(int kind, Value other, MethodGenerator context, var node) {
+  bool _mayOverrideEqual() {
+    // TODO(jimhug): Need to check subtypes as well
+    return type.isVar || type.isObject ||
+      !type.getMember(':eq').declaringType.isObject;
+  }
+
+  Value binop(int kind, Value other, CallingContext context, var node) {
     switch (kind) {
       case TokenKind.AND:
       case TokenKind.OR:
         final code = '${code} ${node.op} ${other.code}';
         return new Value(world.nonNullBool, code, node.span);
-      // TODO(jimhug): Lot's to resolve here.
+      // TODO(jimhug): Wrong on primitives, need new fix for null == undefined
       case TokenKind.EQ_STRICT:
         return new Value(world.nonNullBool, '${code} == ${other.code}',
           node.span);
       case TokenKind.NE_STRICT:
         return new Value(world.nonNullBool, '${code} != ${other.code}',
           node.span);
+
+      case TokenKind.EQ:
+        if (other.code == 'null') {
+          if (!_mayOverrideEqual()) {
+            return new Value(world.nonNullBool, '${code} == ${other.code}',
+              node.span);
+          }
+        } else if (code == 'null') {
+          return new Value(world.nonNullBool, '${code} == ${other.code}',
+            node.span);
+        }
+        break;
+      case TokenKind.NE:
+        if (other.code == 'null') {
+          if (!_mayOverrideEqual()) {
+            return new Value(world.nonNullBool, '${code} != ${other.code}',
+              node.span);
+          }
+        } else if (code == 'null') {
+          return new Value(world.nonNullBool, '${code} != ${other.code}',
+            node.span);
+        }
+        break;
+
     }
 
     var name = kind == TokenKind.NE ? ':ne': TokenKind.binaryMethodName(kind);
     return invoke(context, name, node, new Arguments(null, [other]));
   }
 
 
-  Value invoke(MethodGenerator context, String name, Node node, Arguments args,
-      [bool isDynamic=false]) {
-
+  Value invoke(CallingContext context, String name, Node node,
+      Arguments args) {
     // TODO(jmesserly): it'd be nice to remove these special cases
     // We could create a :call in world members, and have that handle the
     // canInvoke/Invoke logic.
 
     // Note: this check is a little different than the one in canInvoke, because
     // sometimes we need to call dynamically even if we found the :call method
     // statically.
 
     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, node, 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);
+      return member.invoke(context, node, this, args);
     }
   }
 
-  bool canInvoke(MethodGenerator context, String name, Arguments args) {
-    if (type.isVarOrFunction && name == ':call') {
-      return true;
-    }
-
-    var member = _resolveMember(context, name, null, isDynamic:true);
-    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() {
     var m = type.getMember('noSuchMethod');
     return m != null && !m.declaringType.isObject;
   }
 
   // TODO(jimhug): Handle more precise types here, i.e. consts or closed...
   bool get isPreciseType() => isSuper || isType;
 
-  void _missingMemberError(MethodGenerator context, String name, bool isDynamic, Node node) {
+  void _missingMemberError(CallingContext context, String name, Node node) {
     bool onStaticType = false;
     if (type != staticType) {
       onStaticType = staticType.getMember(name) !== null;
     }
 
-    if (!onStaticType && !isDynamic &&
+    if (!onStaticType && context.showWarnings &&
       !_isVarOrParameterType(staticType) && !_hasOverriddenNoSuchMethod()) {
       // warn if the member was not found, or error if it is a static lookup.
       var typeName = staticType.name;
       if (typeName == null) typeName = staticType.library.name;
       var message = 'can not resolve "$name" on "${typeName}"';
       if (isType) {
         world.error(message, node.span);
       } else {
         world.warning(message, node.span);
       }
     }
   }
 
 
 
-  MemberSet _tryResolveMember(MethodGenerator context, String name, bool isDynamic, Node node) {
+  MemberSet _tryResolveMember(CallingContext context, String name, Node node) {
     var member = type.getMember(name);
     if (member == null) {
-      _missingMemberError(context, name, isDynamic, node);
+      _missingMemberError(context, name, node);
       return null;
     } else {
-      if (isType && !member.isStatic) {
-        if (!isDynamic) {
-          world.error('can not refer to instance member as static', node.span);
-        }
+      if (isType && !member.isStatic && context.showWarnings) {
+        world.error('can not refer to instance member as static', node.span);
         return null;
       }
     }
 
     if (isPreciseType || member.isStatic) {
       return member.preciseMemberSet;
     } else {
       return member.potentialMemberSet;
     }
   }
 
   // TODO(jmesserly): until reified generics are fixed, treat ParameterType as
   // "var".
   bool _isVarOrParameterType(Type t) => t.isVar || t is ParameterType;
 
   bool _shouldBindDynamically() {
     return _isVarOrParameterType(type) || options.forceDynamic && !isConst;
   }
 
   // TODO(jimhug): Better type here - currently is union(Member, MemberSet)
-  MemberSet _resolveMember(MethodGenerator context, String name, Node node,
-        [bool isDynamic=false]) {
+  MemberSet _resolveMember(CallingContext context, String name, Node node) {
     var member = null;
     if (!_shouldBindDynamically()) {
-      member = _tryResolveMember(context, name, isDynamic, node);
+      member = _tryResolveMember(context, name, node);
     }
 
     // Fall back to a dynamic operation for instance members
     if (member == null && !isSuper && !isType) {
       member = context.findMembers(name);
-      if (member == null && !isDynamic) {
+      if (member == null && context.showWarnings) {
         var where = 'the world';
         if (name.startsWith('_')) {
           where = 'library "${context.library.name}"';
         }
         world.warning('$name is not defined anywhere in $where.',
            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, Node node, Arguments args) {
+  Value _varCall(CallingContext context, Node node, 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
     // dynamic method calls. What should we do?
     var stub = world.functionType.getCallStub(args);
     return stub.invoke(context, node, this, args);
   }
 
   /** True if convertTo would generate a conversion. */
   bool needsConversion(Type toType) {
-    var c = convertTo(null, toType, isDynamic:true);
+    var c = convertTo(null, toType);
     return c == null || code != c.code;
   }
 
   /**
    * Assign or convert this value to another type.
    * This is used for converting between function types, inserting type
    * checks when --enable_type_checks is enabled, and wrapping callback
    * functions passed to the dom so we can restore their isolate context.
    */
-  Value convertTo(MethodGenerator context, Type toType,
-      [bool isDynamic=false]) {
+  Value convertTo(CallingContext context, Type toType) {
 
     // Issue type warnings unless we are processing a dynamic operation.
-    bool checked = !isDynamic;
+    bool checked = context != null && context.showWarnings;
 
     var callMethod = toType.getCallMethod();
     if (callMethod != null) {
       if (checked && !toType.isAssignable(type)) {
         convertWarning(toType);
       }
 
       return _maybeWrapFunction(toType, callMethod);
     }
 
@@ skipping 17 matching lines @@
       return changeStaticType(toType);
     }
 
     if (checked && !toType.isSubtypeOf(type)) {
       // According to the static types, this conversion can't work.
       convertWarning(toType);
     }
 
     // Generate a runtime checks if they're turned on, otherwise skip it.
     if (options.enableTypeChecks) {
-      if (context == null && isDynamic) {
+      if (context == null) {
         // If we're called from needsConversion, we don't need a context.
         // Just return null so it knows a conversion is required.
         return null;
       }
-      return _typeAssert(context, toType, isDynamic);
+      return _typeAssert(context, toType);
     } else {
       return changeStaticType(toType);
     }
   }
 
-  // TODO(jmesserly): I think we can replace our usage of the "isDynamic" flag
-  // by changing the static type of the target to "Dynamic" instead.
   changeStaticType(Type toType) {
     // Ensure that we return something with the right type for inference
     // purposes.
     return (toType == type) ? this : new ConvertedValue(this, toType);
   }
 
   /**
    * Wraps a function with a conversion, so it can be called directly from
    * Dart or JS code with the proper arity. We avoid the wrapping if the target
    * function has the same arity.
@@ skipping 31 matching lines @@
 
     if (result === this) result = changeStaticType(toType);
     return result;
   }
 
   /**
    * Generates a run time type assertion for the given value. This works like
    * [instanceOf], but it allows null since Dart types are nullable.
    * Also it will throw a TypeError if it gets the wrong type.
    */
-  Value _typeAssert(MethodGenerator context, Type toType, bool isDynamic) {
+  Value _typeAssert(CallingContext context, Type toType) {
     if (toType is ParameterType) {
       ParameterType p = toType;
       toType = p.extendsType;
     }
 
     if (toType.isObject || toType.isVar) {
       world.internalError(
           'We thought ${type.name} is not a subtype of ${toType.name}?');
     }
 
     // Prevent a stack overflow when forceDynamic and type checks are both
     // enabled. forceDynamic would cause the TypeError constructor to type check
     // its arguments, which in turn invokes the TypeError constructor, ad
     // infinitum.
     String throwTypeError(String paramName) => world.withoutForceDynamic(() {
       final typeErrorCtor = world.typeErrorType.getConstructor('_internal');
       world.gen.corejs.ensureTypeNameOf();
       final result = typeErrorCtor.invoke(context, null,
           new TypeValue(world.typeErrorType, null),
           new Arguments(null, [
             new Value(world.objectType, paramName, null),
-            new Value(world.stringType, '"${toType.name}"', null)]),
-          isDynamic);
+            new Value(world.stringType, '"${toType.name}"', null)]));
       world.gen.corejs.useThrow = true;
       return '\$throw(${result.code})';
     });
 
     // TODO(jmesserly): better assert for integers?
     if (toType.isNum) toType = world.numType;
 
     // Generate a check like these:
     //   obj && obj.is$TypeName()
     //   $assert_int(obj)
@@ skipping 47 matching lines @@
   }
 
   /**
    * Test to see if value is an instance of this type.
    *
    * - If a primitive type, then uses the JavaScript typeof.
    * - If it's a non-generic class, use instanceof.
    * - Otherwise add a fake member to test for.  This value is generated
    *   as a function so that it can be called for a runtime failure.
    */
-  Value instanceOf(MethodGenerator context, Type toType, SourceSpan span,
+  Value instanceOf(CallingContext context, Type toType, SourceSpan span,
       [bool isTrue=true, bool forceCheck=false]) {
     // TODO(jimhug): Optimize away tests that will always pass unless
     //    forceCheck is true.
 
     if (toType.isVar) {
       world.error('can not resolve type', span);
     }
 
     String testCode = null;
     if (toType.isVar || toType.isObject || toType is ParameterType) {
       // Note: everything is an Object, including null.
       if (needsTemp) {
         return new Value(world.nonNullBool, '($code, true)', span);
       } else {
         // TODO(jimhug): Mark non-const?
         return Value.fromBool(true, span);
       }
     }
 
     if (toType.library.isCore) {
       var typeofName = toType.typeofName;
       if (typeofName != null) {
         testCode = "(typeof($code) ${isTrue ? '==' : '!='} '$typeofName')";
       }
     }
-    if (toType.isClass && toType is !ConcreteType
-        && !toType.isHiddenNativeType) {
+
+    if (toType.isClass
+        && !toType.isHiddenNativeType && !toType.isConcreteGeneric) {
       toType.markUsed();
       testCode = '($code instanceof ${toType.jsname})';
       if (!isTrue) {
         testCode = '!' + testCode;
       }
     }
     if (testCode == null) {
       toType.isTested = true;
 
       // If we track nullability, we could simplify this check.
@@ skipping 21 matching lines @@
     }
     return new Value(world.nonNullBool, testCode, span);
   }
 
   void convertWarning(Type toType) {
     // TODO(jmesserly): better error messages for type conversion failures
     world.warning('type "${type.name}" is not assignable to "${toType.name}"',
         span);
   }
 
-  Value invokeNoSuchMethod(MethodGenerator context, String name, Node node,
+  Value invokeNoSuchMethod(CallingContext context, String name, Node node,
       [Arguments args]) {
     if (isType) {
       world.error('member lookup failed for "$name"', node.span);
     }
 
     var pos = '';
     if (args != null) {
       var argsCode = [];
       for (int i = 0; i < args.length; i++) {
         argsCode.add(args.values[i].code);
@@ skipping 70 matching lines @@
 
 
 class NullValue extends EvaluatedValue {
   NullValue(bool isConst, SourceSpan span):
     super(isConst, world.varType, span);
 
   get actualValue() => null;
 
   String get code() => 'null';
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     if (other is! NullValue) return super.binop(kind, other, context, node);
 
     final c = isConst && other.isConst;
     final s = node.span;
     switch (kind) {
       case TokenKind.EQ_STRICT:
       case TokenKind.EQ:
         return new BoolValue(true, c, s);
       case TokenKind.NE_STRICT:
       case TokenKind.NE:
         return new BoolValue(false, c, s);
     }
 
     return super.binop(kind, other, context, node);
   }
 }
 
 class BoolValue extends EvaluatedValue {
   final bool actualValue;
 
   BoolValue(this.actualValue, bool isConst, SourceSpan span):
     super(isConst, world.nonNullBool, span);
 
   String get code() => actualValue ? 'true' : 'false';
 
-  Value unop(int kind, MethodGenerator context, var node) {
+  Value unop(int kind, CallingContext context, var node) {
     switch (kind) {
       case TokenKind.NOT:
         return new BoolValue(!actualValue, isConst, node.span);
     }
     return super.unop(kind, context, node);
   }
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     if (other is! BoolValue) return super.binop(kind, other, context, node);
 
     final c = isConst && other.isConst;
     final s = node.span;
     bool x = actualValue, y = other.actualValue;
     switch (kind) {
       case TokenKind.EQ_STRICT:
       case TokenKind.EQ:
         return new BoolValue(x == y, c, s);
       case TokenKind.NE_STRICT:
@@ skipping 11 matching lines @@
 
 class IntValue extends EvaluatedValue {
   final int actualValue;
 
   IntValue(this.actualValue, bool isConst, SourceSpan span):
     super(isConst, world.intType, span);
 
   // TODO(jimhug): Only add parens when needed.
   String get code() => '(${actualValue})';
 
-  Value unop(int kind, MethodGenerator context, var node) {
+  Value unop(int kind, CallingContext context, var node) {
     switch (kind) {
       case TokenKind.ADD:
         // This is allowed on numeric constants only
         return new IntValue(actualValue, isConst, span);
       case TokenKind.SUB:
         return new IntValue(-actualValue, isConst, span);
       case TokenKind.BIT_NOT:
         return new IntValue(~actualValue, isConst, span);
     }
     return super.unop(kind, context, node);
   }
 
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     final c = isConst && other.isConst;
     final s = node.span;
     if (other is IntValue) {
       int x = actualValue;
       int y = other.actualValue;
       switch (kind) {
         case TokenKind.EQ_STRICT:
         case TokenKind.EQ:
           return new BoolValue(x == y, c, s);
         case TokenKind.NE_STRICT:
@@ skipping 71 matching lines @@
 }
 
 class DoubleValue extends EvaluatedValue {
   final double actualValue;
 
   DoubleValue(this.actualValue, bool isConst, SourceSpan span):
     super(isConst, world.doubleType, span);
 
   String get code() => '(${actualValue})';
 
-  Value unop(int kind, MethodGenerator context, var node) {
+  Value unop(int kind, CallingContext context, var node) {
     switch (kind) {
       case TokenKind.ADD:
         // This is allowed on numeric constants only
         return new DoubleValue(actualValue, isConst, span);
       case TokenKind.SUB:
         return new DoubleValue(-actualValue, isConst, span);
     }
     return super.unop(kind, context, node);
   }
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     final c = isConst && other.isConst;
     final s = node.span;
     if (other is DoubleValue) {
       double x = actualValue;
       double y = other.actualValue;
       switch (kind) {
         case TokenKind.EQ_STRICT:
         case TokenKind.EQ:
           return new BoolValue(x == y, c, s);
         case TokenKind.NE_STRICT:
@@ skipping 60 matching lines @@
     return super.binop(kind, other, context, node);
   }
 }
 
 class StringValue extends EvaluatedValue {
   final String actualValue;
 
   StringValue(this.actualValue, bool isConst, SourceSpan span):
     super(isConst, world.stringType, span);
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     if (other is! StringValue) return super.binop(kind, other, context, node);
 
     final c = isConst && other.isConst;
     final s = node.span;
     String x = actualValue, y = other.actualValue;
     switch (kind) {
       case TokenKind.EQ_STRICT:
       case TokenKind.EQ:
         return new BoolValue(x == y, c, s);
       case TokenKind.NE_STRICT:
@@ skipping 58 matching lines @@
       if (i > 0) buf.add(', ');
       buf.add(values[i].code);
     }
     buf.add(']');
     var listCode = buf.toString();
 
     if (!isConst) return listCode;
 
     var v = new Value(world.listType, listCode, span);
     final immutableListCtor = world.immutableListType.getConstructor('from');
-    final result = immutableListCtor.invoke(null, null,
+    final result = immutableListCtor.invoke(world.gen.mainContext, null,
         new TypeValue(v.type, span), new Arguments(null, [v]));
     return result.code;
   }
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     // TODO(jimhug): Support int/double better
     if (other is! ListValue) return super.binop(kind, other, context, node);
 
     switch (kind) {
       case TokenKind.EQ_STRICT:
         return new BoolValue(type == other.type && code == other.code,
           isConst && other.isConst, node.span);
       case TokenKind.NE_STRICT:
         return new BoolValue(type != other.type || code != other.code,
           isConst && other.isConst, node.span);
@@ skipping 15 matching lines @@
 
   MapValue(this.values, bool isConst, Type type, SourceSpan span):
     super(isConst, type, span);
 
   String get code() {
     // Cache?
     var items = new ListValue(values, false, world.listType, span);
     var tp = world.coreimpl.topType;
     Member f = isConst ? tp.getMember('_constMap') : tp.getMember('_map');
     // TODO(jimhug): Clean up invoke signature
-    var value = f.invoke(null, null, new TypeValue(tp, null),
+    var value = f.invoke(world.gen.mainContext, null, new TypeValue(tp, null),
       new Arguments(null, [items]));
     return value.code;
   }
 
   GlobalValue getGlobalValue() {
     assert(isConst);
 
     return world.gen.globalForConst(this, values);
   }
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     if (other is! MapValue) return super.binop(kind, other, context, node);
 
     switch (kind) {
       case TokenKind.EQ_STRICT:
         return new BoolValue(type == other.type && code == other.code,
           isConst && other.isConst, node.span);
       case TokenKind.NE_STRICT:
         return new BoolValue(type != other.type || code != other.code,
           isConst && other.isConst, node.span);
     }
@@ skipping 11 matching lines @@
 
   ObjectValue(bool isConst, Type type, SourceSpan span):
     fields = {}, super(isConst, type, span);
 
   String get code() {
     if (_code === null) validateInitialized(null);
     return _code;
   }
 
   initFields() {
-    var allMembers = world.gen._orderValues(type.getAllMembers());
+    var allMembers = world.gen._orderValues(type.genericType.getAllMembers());
     for (var f in allMembers) {
       if (f.isField && !f.isStatic && f.declaringType.isClass) {
         fields[f] = f.computeValue();
       }
     }
   }
 
   setField(Member field, Value value, [bool duringInit = false]) {
     // Unpack constant values
     if (value.isConst && value is VariableValue) {
@@ skipping 37 matching lines @@
         buf.add('null');
       } else {
         buf.add(fields[field].code);
       }
       buf.add(', writeable: false}, ');
     }
     buf.add('})');
     _code = buf.toString();
   }
 
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     if (other is! ObjectValue) return super.binop(kind, other, context, node);
 
     switch (kind) {
       case TokenKind.EQ_STRICT:
       case TokenKind.EQ:
         return new BoolValue(type == other.type && code == other.code,
           isConst && other.isConst, node.span);
       case TokenKind.NE_STRICT:
       case TokenKind.NE:
         return new BoolValue(type != other.type || code != other.code,
@@ skipping 77 matching lines @@
   }
 }
 
 /**
  * Represents the hidden or implicit value in a bare reference like 'a'.
  * This could be this, the current type, or the current library for purposes
  * of resolving members.
  */
 class BareValue extends Value {
   final bool isType;
-  final MethodGenerator home;
+  final CallingContext home;
 
   String _code;
 
-  BareValue(this.home, MethodGenerator outermost, SourceSpan span):
+  BareValue(this.home, CallingContext outermost, SourceSpan span):
     isType = outermost.isStatic,
     super(outermost.method.declaringType, null, span);
 
   bool get needsTemp() => false;
   bool _shouldBindDynamically() => false;
 
   String get code() => _code;
 
   // TODO(jimhug): Lazy initialization here is weird!
   void _ensureCode() {
     if (_code === null) _code = isType ? type.jsname : home._makeThisCode();
   }
 
-  MemberSet _tryResolveMember(MethodGenerator context, String name, bool isDynamic, Node node) {
+  MemberSet _tryResolveMember(CallingContext context, String name, Node node) {
     assert(context == home);
 
     // TODO(jimhug): Confirm this matches final resolution of issue 641.
     var member = type.getMember(name);
     if (member == null || member.declaringType != type) {
       var libMember = home.library.lookup(name, span);
       if (libMember !== null) {
         return libMember.preciseMemberSet;
       }
     }
 
     _ensureCode();
-    return super._tryResolveMember(context, name, isDynamic, node);
+    return super._tryResolveMember(context, name, node);
   }
 }
 
 /** A reference to 'super'. */
 // TODO(jmesserly): override resolveMember to clean up the one on Value
 class SuperValue extends Value {
   SuperValue(Type parentType, SourceSpan span):
     super(parentType, 'this', span);
 
   bool get needsTemp() => false;
@@ skipping 41 matching lines @@
   }
 
   bool get needsTemp() => value.needsTemp;
   bool get isFinal() => value.isFinal;
   bool get isConst() => value.isConst;
 
   // TODO(jmesserly): preserve the staticType?
   Value _tryUnion(Value right) => Value.union(value, right);
 
   // TODO(jmessery): override get/set/invoke/unop/binop?
-  // (The tricky part is we want them to use our staticType for warning
-  // purposes. It's like the whole ConcreteType/ConcreteMember issues...)
 }
 
 /**
  * A value that represents a variable or parameter. The [assigned] value can be
  * mutated when the variable is assigned to a new Value.
  */
 class VariableValue extends Value {
   final bool isFinal;
   final Value value;
 
@@ skipping 28 matching lines @@
   Type get staticType() => super.type;
   bool get isConst() => value !== null ? value.isConst : false;
 
   // TODO(jmesserly): we could use this for checking uninitialized values
   bool get isInitialized() => value != null;
 
   VariableValue replaceValue(Value v) =>
       new VariableValue(staticType, code, span, isFinal, v);
 
   // TODO(jmesserly): anything else to override?
-  Value unop(int kind, MethodGenerator context, var node) {
+  Value unop(int kind, CallingContext context, var node) {
     if (value != null) {
       return replaceValue(value.unop(kind, context, node));
     }
     return super.unop(kind, context, node);
   }
-  Value binop(int kind, var other, MethodGenerator context, var node) {
+  Value binop(int kind, var other, CallingContext context, var node) {
     if (value != null) {
       return replaceValue(value.binop(kind, _unwrap(other), context, node));
     }
     return super.binop(kind, other, context, node);
   }
 }