Allow interpolated strings and adjacent strings to be compile-time constants.

frog/gen.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.
 
 /**
  * Top level generator object for writing code and keeping track of
  * dependencies.
  *
  * Should have two compilation models, but only one implemented so far.
  *
@@ skipping 2278 matching lines @@
 
   _isUnaryIncrement(Expression item) {
     if (item is UnaryExpression) {
       UnaryExpression u = item;
       return u.op.kind == TokenKind.INCR || u.op.kind == TokenKind.DECR;
     } else {
       return false;
     }
   }
 
+  String foldStrings(List<StringValue> strings) {
+    StringBuffer buffer = new StringBuffer();
+    for (var part in strings) buffer.add(part.constValue.actualValue);
+    return buffer.toString();
+  }
+
   visitStringConcatExpression(StringConcatExpression node) {
     var items = [];
+    var itemsConst = [];
     for (var item in node.strings) {
       Value val = visitValue(item);
       assert(val.type.isString);
+      if (val.isConst) itemsConst.add(val);
       items.add(val.code);
     }
-    return new Value(world.stringType, '(${Strings.join(items, " + ")})',
-                     node.span);
+    if (items.length == itemsConst.length) {

[ngeoffray, 2012/03/14 12:13:11]

instead of having two lists, could you just have a boolean and a list? This will
change line 2311 to:
if (!val.isConst) isConst = false;

+      return new StringValue(foldStrings(itemsConst), true, node.span);
+    } else {
+      String code = '(${Strings.join(items, " + ")})';
+      return new Value(world.stringType, code, node.span);
+    }
   }
 
   visitStringInterpExpression(StringInterpExpression node) {
     var items = [];
+    var itemsConst = [];
     for (var item in node.pieces) {
       var val = visitValue(item);
-      val.invoke(this, 'toString', item, Arguments.EMPTY);
+      bool isConst = val.isConst && val.type.isString;
+      if (!isConst) {
+        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);
+        if (isConst) itemsConst.add(val);
       }
     }
-    return new Value(world.stringType, '(${Strings.join(items, " + ")})',
-      node.span);
+    if (items.length == itemsConst.length) {
+      return new StringValue(foldStrings(itemsConst), true, node.span);
+    } else {
+      String code = '(${Strings.join(items, " + ")})';
+      return new Value(world.stringType, code, 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 121 matching lines @@
     return true;
   }
 
 }
 
 class ReturnKind {
   static final int IGNORE = 1;
   static final int POST = 2;
   static final int PRE = 3;
 }