incremental progress on Value

frog/member.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.
 
 /** A formal parameter to a [Method]. */
 class Parameter {
   FormalNode definition;
 
   String name;
   Type type;
@@ skipping 133 matching lines @@
   List<Parameter> get parameters() => [];
 
   // TODO(jmesserly): isDynamic isn't a great name for this, something better?
   abstract Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic]);
 
   abstract Value _set(MethodGenerator context, Node node, Value target,
       Value value, [bool isDynamic]);
 
   bool canInvoke(MethodGenerator context, Arguments args) {
-    // TODO(jimhug): Needs better source location?
+    // No source location needed because canInvoke may not produce errors.
     return canGet &&
       new Value(returnType, null, null).canInvoke(context, '\$call', args);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     var newTarget = _get(context, node, target, isDynamic);
     return newTarget.invoke(context, '\$call', node, args, isDynamic);
   }
 
@@ skipping 52 matching lines @@
 
   bool canInvoke(MethodGenerator context, Arguments args) => false;
   bool get canGet() => true;
   bool get canSet() => false;
 
   void resolve(Type inType) {}
 
   Value _get(MethodGenerator context, Node node, Value target,
       [bool isDynamic=false]) {
     // TODO(jmesserly): named args
-    return new Value(type, type.jsname, node.span, false, false, true);
+    var ret = new Value(type, type.jsname, node.span, false);
+    // TODO(jimhug): Replace with TypeValue.
+    ret.isType = true;
+    return ret;
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     world.error('can not set type', type.definition.span);
   }
 
   Value invoke(MethodGenerator context, Node node, Value target, Arguments args,
       [bool isDynamic=false]) {
     world.error('can not invoke type', type.definition.span);
@@ skipping 918 matching lines @@
 
         // Ensure we generate toString on the right side
         args.values[0].invoke(context, 'toString', node, Arguments.EMPTY);
         return new Value(declaringType, '${target.code} + ${argsCode[0]}',
           node.span);
       }
     } else if (declaringType.isNativeType) {
       if (name == '\$index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
-        // TODO(jmesserly): why are we using a return type of "var"?
-        return new Value(null, '${target.code}[${argsCode[0]}]', node.span);
+        return new Value(returnType, '${target.code}[${argsCode[0]}]', node.span);
       } else if (name == '\$setindex') {
-        return new Value(null,
+        return new Value(returnType,
           '${target.code}[${argsCode[0]}] = ${argsCode[1]}', node.span);
       }
     }
 
     // TODO(jimhug): Optimize null on lhs as well.
     if (name == '\$eq' || name == '\$ne') {
       final op = name == '\$eq' ? '==' : '!=';
       if (allConst) {
         var val0 = target.dynamic.actualValue;
         var val1 = args.values[0].dynamic.actualValue;
@@ skipping 143 matching lines @@
   // TODO(jimhug): Always false, or is this needed?
   bool get isStatic() => members.length == 1 && members[0].isStatic;
 
   bool canInvoke(MethodGenerator context, Arguments args) =>
     members.some((m) => m.canInvoke(context, args));
 
   Value _makeError(Node node, Value target, String action) {
     if (!target.type.isVar) {
       world.warning('could not find applicable $action for "$name"', node.span);
     }
-    return new Value(null, '${target.code}.$jsname() /*no applicable $action*/',
-      node.span);
+    return new Value(world.varType,
+      '${target.code}.$jsname() /*no applicable $action*/', node.span);
   }
 
   bool _treatAsField;
   bool get treatAsField() {
     if (_treatAsField == null) {
       _treatAsField = true;
       for (var member in members) {
         if (member.requiresFieldSyntax) {
           _treatAsField = true;
           break;
@@ skipping 121 matching lines @@
 
   Value _tryUnion(Value x, Value y, Node node) {
     if (x == null) return y;
     var type = Type.union(x.type, y.type);
     if (x.code == y.code) {
       if (type == x.type) {
         return x;
       } else if (x.isConst || y.isConst) {
         world.internalError("unexpected: union of const values ");
       } else {
-        return new Value(type, x.code, node.span,
-            x.isSuper && y.isSuper,
-            x.needsTemp || y.needsTemp,
-            x.isType && y.isType);
+        // TODO(jimhug): This is icky - but this whole class needs cleanup.
+        var ret = new Value(type, x.code, node.span);
+        ret.isSuper = x.isSuper && y.isSuper;
+        ret.needsTemp = x.needsTemp || y.needsTemp;
+        ret.isType = x.isType && y.isType;
+        return ret;
       }
     } else {
       return new Value(type, null, node.span);
     }
   }
 
   dumpAllMembers() {
     for (var member in members) {
       world.warning('hard-multi $name on ${member.declaringType.name}',
         member.span);
@@ skipping 84 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }