Fixes 2 tests and a crash

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;
   Member method;
 
   String name;
@@ skipping 403 matching lines @@
         if (declaringType.isHiddenNativeType) {
           // TODO: Could warn at parse time.
           world.error('static field of hidden native type is inaccessible',
               node.span);
         }
         return new Value(type, '${declaringType.jsname}.$jsname', node.span);
       } else {
         return new Value(type,
             '\$globals.${declaringType.jsname}_$jsname', node.span);
       }
-    } else if (target.isConst && isFinal) {
+    }
+    /*else if (target.isConst && isFinal) {

[Jennifer Messerly, 2012/01/09 19:06:54]

remove? or is this a todo

[jimhug, 2012/01/09 21:34:30]

Was a todo - but then I decided on something different and forgot to remove... 
Done.
On 2012/01/09 19:06:54, John Messerly wrote:

       // take advantage of consts and retrieve the value directly if possible
       var constTarget = target is GlobalValue ? target.dynamic.exp : target;
       if (constTarget is ConstObjectValue) {
         return constTarget.fields[name];
       } else if (constTarget.type == world.stringType && name == 'length') {
         return new Value(type, '${constTarget.actualValue.length}', node.span);
       }
-    }
+    }*/
     return new Value(type, '${target.code}.$jsname', node.span);
   }
 
   Value _set(MethodGenerator context, Node node, Value target, Value value,
       [bool isDynamic=false]) {
     var lhs = _get(context, node, target, isDynamic);
     value = value.convertTo(context, type, isDynamic);
     return new Value(type, '${lhs.code} = ${value.code}', node.span);
   }
 }
@@ skipping 488 matching lines @@
     }
 
     int bareCount = args.bareCount;
     for (int i = 0; i < bareCount; i++) {
       var arg = args.values[i];
       if (i >= parameters.length) {
         var msg = _argCountMsg(args.length, parameters.length);
         return _argError(context, node, target, args, msg, i);
       }
       arg = arg.convertTo(context, parameters[i].type, isDynamic);
-      if (isConst && arg.isConst) {
-        argsCode.add(arg.canonicalCode);
-      } else {
-        argsCode.add(arg.code);
-      }
+      argsCode.add(arg.code);

[Jennifer Messerly, 2012/01/09 19:06:54]

yay

     }
 
     int namedArgsUsed = 0;
     if (bareCount < parameters.length) {
       genParameterValues();
 
       for (int i = bareCount; i < parameters.length; i++) {
         var arg = args.getValue(parameters[i].name);
         if (arg == null) {
           arg = parameters[i].value;
         } else {
           arg = arg.convertTo(context, parameters[i].type, isDynamic);
           namedArgsUsed++;
         }
 
         if (arg == null || !parameters[i].isOptional) {
           var msg = _argCountMsg(Math.min(i, args.length), i + 1, atLeast:true);
           return _argError(context, node, target, args, msg, i);
         } else {
-          argsCode.add(isConst && arg.isConst
-              ? arg.canonicalCode : arg.code);
+          argsCode.add(arg.code);
         }
       }
       Arguments.removeTrailingNulls(argsCode);
     }
 
     if (namedArgsUsed < args.nameCount) {
       // Find the unused argument name
       var seen = new Set<String>();
       for (int i = bareCount; i < args.length; i++) {
         var name = args.getName(i);
@@ skipping 29 matching lines @@
           node.span);
     }
 
     if (isOperator) {
       return _invokeBuiltin(context, node, target, args, argsCode, isDynamic);
     }
 
     if (isFactory) {
       assert(target.isType);
       return new Value(target.type, '$generatedFactoryName($argsString)',
-          node.span);
+          node !== null ? node.span : null);
     }
 
     if (isStatic) {
       if (declaringType.isTop) {
         // TODO(jimhug): Explore moving libraries into their own namespaces
         return new Value(inferredResult,
-            '$jsname($argsString)', node != null ? node.span : node);
+            '$jsname($argsString)', node !== null ? node.span : null);
       }
       return new Value(inferredResult,
           '${declaringType.jsname}.$jsname($argsString)', node.span);
     }
 
     var code = '${target.code}.$jsname($argsString)';
     // optimize expressions which we know statically their value.
+    // ????

[Jennifer Messerly, 2012/01/09 19:06:54]

is this a TODO?

[jimhug, 2012/01/09 21:34:30]

Done.

+    /*
     if (target.isConst) {
       if (target is GlobalValue) {
         target = target.dynamic.exp; // TODO: an inline "cast" would be nice.
       }
       if (name == 'get:length') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.length}';
         }
       } else if (name == 'isEmpty') {
         if (target is ConstListValue || target is ConstMapValue) {
           code = '${target.dynamic.values.isEmpty()}';
         }
       }
     }
+    */
 
     // TODO(jmesserly): factor this better

[Jennifer Messerly, 2012/01/09 19:06:54]

Not your change, but I noticed that this block of code here is obsolete (logic
is now in corejs.dart). =)

[jimhug, 2012/01/09 21:34:30]

I'm not sure I understand the ramifications of removing this - please remove it
in a future checkin when convenient.
On 2012/01/09 19:06:54, John Messerly wrote:

     if (name == 'get:typeName' && declaringType.library.isDom) {
       world.gen.corejs.ensureTypeNameOf();
     }
 
     return new Value(inferredResult, code, node.span);
   }
 
   Value _invokeConstructor(MethodGenerator context, Node node,
       Value target, Arguments args, argsString) {
     declaringType.markUsed();
 
     String ctor = constructorName;
     if (ctor != '') ctor = '.${ctor}\$ctor';
 
     if (!target.isType) {
       // initializer call to another constructor
       var code = '${declaringType.nativeName}${ctor}.call($argsString)';
       return new Value(target.type, code, node.span);
     } else {
-
       var code = 'new ${declaringType.nativeName}${ctor}($argsString)';
 
       // TODO(jmesserly): using the "node" here feels really hacky
       if (isConst && node is NewExpression && node.dynamic.isConst) {
         return _invokeConstConstructor(node, code, target, args);
       } else {
         final span = node != null ? node.span : target.span;
         return new Value(target.type, code, span);
       }
     }
@@ skipping 11 matching lines @@
    *   class B {
    *     final int y;
    *     const B() : y = 0, super(1);
    *     const B.a(this.y, x) : super(x);
    *     const B.b(v) : this.a(v, 1);
    *   }
    * :]
    */
   Value _invokeConstConstructor(
       Node node, String code, Value target, Arguments args) {
+    // TODO(jimhug): This should be low-hanging fruit for abstract eval!
+
     // Statically compute the actual value for every field in the const object.
-    final fields = new Map<String, EvaluatedValue>();
+    final fields = new Map<String, Value>();
 
     // First deduce the value for fields initialized with the 'this.x' syntax.
     for (int i = 0; i < parameters.length; i++) {
       var param = parameters[i];
       if (param.isInitializer) {
         var value = null;
         if (i < args.length) {
           value = args.values[i];
         } else { // named arguments
           value = args.getValue(param.name);
@@ skipping 66 matching lines @@
           world.error('const class "${declaringType.name}" has non-final '
               + 'field "${f.name}"', f.span);
         }
         if (f.value != null) {
           fields[f.name] = f.computeValue();
         }
       }
     }
 
     return world.gen.globalForConst(
-        new ConstObjectValue(target.type, fields, code, node.span),
+      new ObjectValue(fields, true, target.type, code, node.span),
         args.values);
   }
 
 
   Value _invokeBuiltin(MethodGenerator context, Node node, Value target,
       Arguments args, argsCode, bool isDynamic) {
     var allConst = target.isConst && args.values.every((arg) => arg.isConst);
 
     // Handle some fast paths for Number, String, List and DOM.
     if (declaringType.isNum) {
@@ skipping 40 matching lines @@
 
           // Note: unfortunatelly bit operations fail on doubles in dartvm
           case ':bit_not': value = (~ival0).toDouble(); break;
           case ':bit_or': value = (ival0 | ival1).toDouble(); break;
           case ':bit_xor': value = (ival0 ^ ival1).toDouble(); break;
           case ':bit_and': value = (ival0 & ival1).toDouble(); break;
           case ':shl': value = (ival0 << ival1).toDouble(); break;
           case ':sar': value = (ival0 >> ival1).toDouble(); break;
           case ':shr': value = (ival0 >>> ival1).toDouble(); break;
         }
-        return new EvaluatedValue(inferredResult, value, "$value", node.span);
+        if (inferredResult.isInt) {
+          return Value.fromInt(value.toInt(), node.span);
+        } else if (inferredResult.isDouble) {
+          return Value.fromDouble(value.toDouble(), node.span);
+        } else if (inferredResult.isNum) {
+          // TODO(jimhug): Number type system is flawed here...
+          return Value.fromDouble(value.toDouble(), node.span);
+        } else if (inferredResult.isBool) {
+          return Value.fromBool(value, node.span);
+        } else {
+          world.internalError(
+            'unsupported const result type "${inferredResult.name}"',
+            node.span);
+        }
       }
     } else if (declaringType.isString) {
       if (name == ':index') {
         // Note: this could technically propagate constness, but that's not
         // specified explicitly and the VM doesn't do that.
         return new Value(declaringType, '${target.code}[${argsCode[0]}]',
           node.span);
       } else if (name == ':add') {
         if (allConst) {
           final value = target.dynamic.actualValue +
@@ skipping 22 matching lines @@
 
       if (name == ':ne') {
         // Ensure == is generated.
         target.invoke(context, ':eq', node, args, isDynamic);
       }
 
       if (allConst) {
         var val0 = target.dynamic.actualValue;
         var val1 = args.values[0].dynamic.actualValue;
         var newVal = name == ':eq' ? val0 == val1 : val0 != val1;
-        return new EvaluatedValue(world.nonNullBool,
-            newVal, "$newVal", node.span);
+        return Value.fromBool(newVal, node.span);
       }
       // Optimize test when null is on the rhs.
       if (argsCode[0] == 'null') {
         return new Value(inferredResult, '${target.code} $op null', node.span);
       } else if (target.type.isNum || target.type.isString) {
         // TODO(jimhug): Maybe check rhs.
         return new Value(inferredResult, '${target.code} $op ${argsCode[0]}',
             node.span);
       }
       world.gen.corejs.useOperator(name);
@@ skipping 438 matching lines @@
   }
 
   void forEach(void f(Member member)) {
     factories.forEach((_, Map constructors) {
       constructors.forEach((_, Member member) {
         f(member);
       });
     });
   }
 }