cleanup to Value - fix for StringEscapesTest

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 28 matching lines @@
     var metaGen = new MethodGenerator(main, null);
     var mainTarget = new Value.type(main.declaringType, main.span);
     var mainCall = main.invoke(metaGen, null, mainTarget, Arguments.EMPTY);
     main.declaringType.markUsed();
 
     if (options.compileAll) {
       markLibrariesUsed(
           [world.coreimpl, world.corelib, main.declaringType.library]);
     }
 
+    // These are essentially always used through literals - just include them
+    world.numImplType.markUsed();
+    world.stringImplType.markUsed();
+
     // Only include isolate-specific code if isolates are used.
     if (world.corelib.types['Isolate'].isUsed
         || world.coreimpl.types['ReceivePortImpl'].isUsed) {
 
       // Generate callbacks from JS to isolate code if needed
       if (corejs.useWrap0 || corejs.useWrap1) {
         genMethod(world.coreimpl.types['IsolateContext'].getMember('eval'));
         genMethod(world.coreimpl.types['EventLoop'].getMember('run'));
       }
 
@@ skipping 987 matching lines @@
   _provideOptionalParamInfo(CodeWriter defWriter) {
     if (method is MethodMember) {
       MethodMember meth = method;
       if (meth._provideOptionalParamInfo) {
         var optNames = [];
         var optValues = [];
         meth.genParameterValues();
         for (var param in meth.parameters) {
           if (param.isOptional) {
             optNames.add(param.name);
+            // TODO(jimhug): Remove this last usage of escapeString.
             optValues.add(_escapeString(param.value.code));
           }
         }
         if (optNames.length > 0) {
           // TODO(jmesserly): the logic for how to refer to
           // static/instance/top-level members is duplicated all over the place.
           // Badly needs cleanup.
           var start = '';
           if (meth.isStatic) {
             if (!meth.declaringType.isTop) {
@@ skipping 426 matching lines @@
       var span = node.test.span;
 
       // TODO(jmesserly): do we need to include path/line/column here?
       // It should be captured in the stack trace.
       var line = span.file.getLine(span.start) + 1;
       var column = span.file.getColumn(line - 1, span.start) + 1;
 
       // TODO(jimhug): Simplify code for creating const values.
       var args = [
         test,
-        new EvaluatedValue(world.stringType,
-          _escapeString(span.text), '"${_escapeString(span.text)}"', null),
-        new EvaluatedValue(world.stringType,
-          _escapeString(span.file.filename),
-          '"${_escapeString(span.file.filename)}"', null),
-        new EvaluatedValue(world.intType, line, line.toString(), null),
-        new EvaluatedValue(world.intType, column, column.toString(), null)
+        Value.fromString(span.text, node.span),
+        Value.fromString(span.file.filename, node.span),
+        Value.fromInt(line, node.span),
+        Value.fromInt(column, node.span)
       ];
 
       var tp = world.corelib.topType;
       Member f = tp.getMember('_assert');
       var value = f.invoke(this, node, new Value.type(tp, null),
         new Arguments(null, args));
       writer.writeln('${value.code};');
     }
     return false;
   }
@@ skipping 407 matching lines @@
     meth.generator.writeDefinition(w, node);
     return new Value(meth.functionType, w.text, node.span);
   }
 
   visitCallExpression(CallExpression node) {
     var target;
     var position = node.target;
     var name = ':call';
     if (node.target is DotExpression) {
       DotExpression dot = node.target;
+      // ????
       if (dot.self is LiteralExpression) {
         target = (new ParenExpression(dot.self, dot.self.span)).visit(this);
       } else {
         target = dot.self.visit(this);
       }
       name = dot.name.name;
       position = dot.name;
     } else if (node.target is VarExpression) {
       VarExpression varExpr = node.target;
       name = varExpr.name.name;
@@ skipping 26 matching lines @@
   visitBinaryExpression(BinaryExpression node, [bool isVoid = false]) {
     final kind = node.op.kind;
     // TODO(jimhug): Ensure these have same semantics as JS!
     if (kind == TokenKind.AND || kind == TokenKind.OR) {
       var x = visitTypedValue(node.x, world.nonNullBool);
       var y = visitTypedValue(node.y, world.nonNullBool);
       final code = '${x.code} ${node.op} ${y.code}';
       if (x.isConst && y.isConst) {
         var value = (kind == TokenKind.AND)
             ? x.actualValue && y.actualValue : x.actualValue || y.actualValue;
-        return new EvaluatedValue(world.nonNullBool, value, '$value',
-            node.span);
+        return Value.fromBool(value, node.span);
       }
       return new Value(world.nonNullBool, code, node.span);
     } else if (kind == TokenKind.EQ_STRICT || kind == TokenKind.NE_STRICT) {
       var x = visitValue(node.x);
       var y = visitValue(node.y);
       if (x.isConst && y.isConst) {
         var xVal = x.actualValue;
         var yVal = y.actualValue;
 
-        // cannonicalize strings if they are using different quote chars:
-        if (x.type.isString && y.type.isString
-            && xVal[0] != yVal[0]) {
-          if (xVal[0] == '"') {
-            xVal = xVal.substring(1, xVal.length - 1);
-            yVal = toDoubleQuote(yVal.substring(1, yVal.length - 1));
-          } else {
-            xVal = toDoubleQuote(xVal.substring(1, xVal.length - 1));
-            yVal = yVal.substring(1, yVal.length - 1);
-          }
-        }
-
         // Note: it is ok to use == and not === here since all of these
         // constant comparisons are applied to doubles, bool, or strings.
         // We need it for the compile-time evaluator because
         // (9).toDouble() === 9.0 is false in dartvm.
         var value = kind == TokenKind.EQ_STRICT ? xVal == yVal : xVal != yVal;
-        return new EvaluatedValue(world.nonNullBool, value, "$value",
-            node.span);
+        return Value.fromBool(value, node.span);
       }
       if (x.code == 'null' || y.code == 'null') {
         // Switching to == ensures that null and undefined are interchangable.
         final op = node.op.toString().substring(0,2);
         return new Value(world.nonNullBool, '${x.code} $op ${y.code}',
             node.span);
       } else {
         // TODO(jimhug): Resolve issue with undefined and null here.
         return new Value(world.nonNullBool, '${x.code} ${node.op} ${y.code}',
           node.span);
@@ skipping 192 matching lines @@
       case TokenKind.INCR:
       case TokenKind.DECR:
         if (value.type.isNum) {
           return new Value(value.type, '${node.op}${value.code}', node.span);
         } else {
           // ++x becomes x += 1
           // --x becomes x -= 1
           // TODO(jimhug): Confirm that --x becomes x -= 1 as it is in VM.
           var kind = (TokenKind.INCR == node.op.kind ?
               TokenKind.ADD : TokenKind.SUB);
-          var operand = new LiteralExpression(1,
-            new TypeReference(node.span, world.numType), '1', node.span);
+          // TODO(jimhug): Shouldn't need a full-expression here.
+          var operand = new LiteralExpression(Value.fromInt(1, node.span),
+            node.span);
 
           var assignValue = _visitAssign(kind, node.self, operand, node, null);
           return new Value(assignValue.type, '(${assignValue.code})',
               node.span);
         }
       case TokenKind.NOT:
         // TODO(jimhug): Issue #359 seeks to clarify this behavior.
         if (value.type.isBool && value.isConst) {
           var newVal = !value.actualValue;
           return new EvaluatedValue(value.type, newVal, '${newVal}', node.span);
@@ skipping 34 matching lines @@
   visitPostfixExpression(PostfixExpression node, [bool isVoid = false]) {
     var value = visitValue(node.body);
     if (value.type.isNum && !value.isFinal) {
       return new Value(value.type, '${value.code}${node.op}', node.span);
     }
 
     // x++ is equivalent to (t = x, x = t + 1, t), where we capture all temps
     // needed to evaluate x so we're not evaluating multiple times. Likewise,
     // x-- is equivalent to (t = x, x = t - 1, t).
     var kind = (TokenKind.INCR == node.op.kind) ? TokenKind.ADD : TokenKind.SUB;
-    var operand = new LiteralExpression(1,
-      new TypeReference(node.span, world.numType), '1', node.span);
+    // TODO(jimhug): Shouldn't need a full-expression here.
+    var operand = new LiteralExpression(Value.fromInt(1, node.span),
+      node.span);
 
     // Use _visitAssign to do most of the work, but save the right side in a
     // temporary variable if needed.
     // TODO(jmesserly): I don't like passing function args like this, but the
     // alternative is duplicating most of the _visitAssign logic. Needs cleanup.
     var tmpleft = null, left = null;
     var ret = _visitAssign(kind, node.body, operand, node, (l) {
       if (isVoid) {
         // No need for a temp if we're throwing away the result.
         return l;
@@ skipping 231 matching lines @@
   }
 
   visitThisExpression(ThisExpression node) {
     return _makeThisValue(node);
   }
 
   visitSuperExpression(SuperExpression node) {
     return _makeSuperValue(node);
   }
 
-  visitNullExpression(NullExpression node) {
-    // TODO(jimhug): should be passing node.span
-    // TODO(jimhug): Can we do better than var for the type?
-    return new EvaluatedValue(world.varType, null, 'null', null);
+  visitLiteralExpression(LiteralExpression node) {
+    return node.value;
   }
 
   _isUnaryIncrement(Expression item) {
     if (item is UnaryExpression) {
       UnaryExpression u = item;
       return u.op.kind == TokenKind.INCR || u.op.kind == TokenKind.DECR;
     } else {
       return false;
     }
   }
 
-  visitLiteralExpression(LiteralExpression node) {
-    // All Literal types are filled in at parse time, so no need to resolve.
-    var type = node.type.type;
-    assert(type != null);
-
-    if (node.value is List) {
-      var items = [];
-      for (var item in node.value) {
-        var val = visitValue(item);
-        val.invoke(this, 'toString', item, Arguments.EMPTY);
-
-        // TODO(jimhug): Ensure this solves all precedence problems.
-        // TODO(jmesserly): We could be smarter about prefix/postfix, but we'd
-        // need to know if it will compile to a ++ or to some sort of += form.
-        var code = val.code;
-        if (_expressionNeedsParens(item)) {
-          code = '(${code})';
-        }
-        // No need to concat empty strings except the first.
-        if (items.length == 0 || (code != "''" && code != '""')) {
-          items.add(code);
-        }
+  visitStringInterpExpression(StringInterpExpression node) {
+    var items = [];
+    for (var item in node.pieces) {
+      var val = visitValue(item);
+      val.invoke(this, 'toString', item, Arguments.EMPTY);
+      // TODO(jimhug): Ensure this solves all precedence problems.
+      // TODO(jmesserly): We could be smarter about prefix/postfix, but we'd
+      // need to know if it will compile to a ++ or to some sort of += form.
+      var code = val.code;
+      if (_expressionNeedsParens(item)) {
+        code = '(${code})';
       }
-      return new Value(type, '(${Strings.join(items, " + ")})', node.span);
-    }
-
-    if (node.value is num) {
-      world.numImplType.markUsed();
-    }
-
-    var text = node.text;
-    // TODO(jimhug): Confirm that only strings need possible translation
-    if (type.isString) {
-      world.stringImplType.markUsed();
-
-      if (text.startsWith('@')) {
-        text = _escapeString(parseStringLiteral(text));
-        text = '"$text"';
-      } else if (isMultilineString(text)) {
-        // convert multi-line strings into single-line
-        text = parseStringLiteral(text);
-        // TODO(jimhug): What about \r?
-        text = text.replaceAll('\n', '\\n');
-        text = toDoubleQuote(text);
-        text = '"$text"';
-      }
-      if (text !== node.text) {
-        node.value = text;
-        node.text = text;
+      // No need to concat empty strings except the first.
+      if (items.length == 0 || (code != "''" && code != '""')) {
+        items.add(code);
       }
     }
-
-    // TODO(jimhug): Should pass node.span - but that breaks something...
-    return new EvaluatedValue(type, node.value, node.text, null);
+    return new Value(world.stringType, '(${Strings.join(items, " + ")})',
+      node.span);
   }
 }
 
 
 // TODO(jmesserly): move this into its own file?
 class Arguments {
   static Arguments _empty;
   static Arguments get EMPTY() {
     if (_empty == null) {
       _empty = new Arguments(null, []);
@@ skipping 103 matching lines @@
       result.add(new Value(world.varType, '\$$i', null, /*needsTemp:*/false));
     }
     for (int i = bareCount; i < length; i++) {
       var name = getName(i);
       if (name == null) name = '\$$i';
       result.add(new Value(world.varType, name, null, /*needsTemp:*/false));
     }
     return new Arguments(nodes, result);
   }
 }