cleanup to Value - fix for StringEscapesTest

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 {
   Type _type;
 
@@ skipping 488 matching lines @@
         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(
         context, node, this, new Arguments(null, noSuchArgs));
   }
+
+
+  static Value fromBool(bool value, SourceSpan span) {
+    return new EvaluatedValue(world.nonNullBool, value, value.toString(),
+      span);
+  }
+
+  static Value fromInt(int value, SourceSpan span) {
+    final strValue = value.toString();
+    assert(strValue.indexOf('.') == -1);
+    return new EvaluatedValue(world.numType, value, strValue, span);
+  }
+
+  static Value fromDouble(double value, SourceSpan span) {
+    var strValue = value.toString();
+    // Ensure that string version looks different from int
+    if (strValue.indexOf('.') == -1 && strValue.indexOf('e') == -1) {
+      strValue = strValue + '.0';
+    }
+    return new EvaluatedValue(world.numType, value, strValue, span);
+  }
+
+  static Value fromString(String value, SourceSpan span) {
+    // TODO(jimhug): This could be much more efficient

[Jennifer Messerly, 2012/01/09 20:16:26]

one thing that might help: we could change StringBuffer's impl to just be a
String. I don't think we need it to build the list, because concat is so well
optimized in JS. I've been meaning to do a microbenchmark on at some point :)

[jimhug, 2012/01/09 21:19:05]

Good thought.  Let me know what you learn!
On 2012/01/09 20:16:26, John Messerly wrote:

+    StringBuffer buf = new StringBuffer();
+    buf.add('"');
+    for (int i=0; i < value.length; i++) {
+      var ch = value.charCodeAt(i);
+      switch (ch) {
+        case 9/*'\t'*/: buf.add(@'\t'); break;
+        case 10/*'\n'*/: buf.add(@'\n'); break;
+        case 13/*'\r'*/: buf.add(@'\r'); break;
+        case 34/*"*/: buf.add(@'\"'); break;
+        case 92/*\*/: buf.add(@'\\'); break;
+        default:
+          if (ch >= 32 && ch <= 126) {
+            buf.add(value[i]);
+          } else {
+            final hex = ch.toRadixString(16);
+            switch (hex.length) {
+              case 1: buf.add(@'\x0'); buf.add(hex); break;
+              case 2: buf.add(@'\x'); buf.add(hex); break;
+              case 3: buf.add(@'\u0'); buf.add(hex); break;
+              case 4: buf.add(@'\u'); buf.add(hex); break;
+              default:
+                world.internalError(
+                  'unicode values greater than 2 bytes not implemented');
+                break;
+            }
+          }
+          break;
+      }
+    }
+    buf.add('"');
+
+    return new EvaluatedValue(world.stringType, value, buf.toString(), span);
+  }
+
+  static Value fromNull(SourceSpan span) {
+    return new EvaluatedValue(world.varType, null, 'null', span);
+  }
 }
 
+
 // 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;
 
   EvaluatedValue get constValue() => this;
 
   /**
    * A canonicalized form of the code. Two const expressions that result in the
    * same instance should have the same [canonicalCode].
    */
   String canonicalCode;
 
   factory EvaluatedValue(Type type, actualValue, String canonicalCode,
       SourceSpan span) {
     return new EvaluatedValue._internal(type, actualValue,
         canonicalCode, span, codeWithComments(canonicalCode, span));
   }
 
   EvaluatedValue._internal(Type type, this.actualValue, this.canonicalCode,
       SourceSpan span, String code)
     : super(type, code, span, false);
 
   static String codeWithComments(String canonicalCode, SourceSpan span) {
-    return (span != null && span.text != canonicalCode)
-        ? '$canonicalCode/*${_escapeForComment(span.text)}*/' : canonicalCode;
+    return canonicalCode;

[Jennifer Messerly, 2012/01/09 20:16:26]

nice simplification

   }
 }
 
 /** An evaluated constant list expression. */
 class ConstListValue extends EvaluatedValue {
   List<EvaluatedValue> values;
 
   factory ConstListValue(Type type, List<EvaluatedValue> values,
       String actualValue, String canonicalCode, SourceSpan span) {
     return new ConstListValue._internal(type, values, actualValue,
@@ skipping 186 matching lines @@
     }
 
     _ensureCode();
     return null;
   }
 }
 
 String _escapeForComment(String text) {
   return text.replaceAll('/*', '/ *').replaceAll('*/', '* /');
 }