Implement hackish version of const list literals.

frog/leg/compile_time_constants.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.
 
 // TODO(floitsch): finish implementation.
 class Constant implements Hashable {
   // TODO(floitsch): remove the direct access to the string.
   final String jsCode;
   Constant(this.jsCode);
 
@@ skipping 17 matching lines @@
 
   // Map from compile-time constants to their JS name.
   final Map<Constant, String> compiledConstants;
 
   CompileTimeConstantHandler(Compiler compiler)
       : initialVariableValues = new Map<VariableElement, Dynamic>(),
         compiledConstants = new Map<Constant, String>(),
         super(compiler);
   String get name() => 'CompileTimeConstantHandler';
 
+  void registerCompileTimeConstant(Constant constant) {
+    Function ifAbsentThunk = (() => compiler.namer.getFreshGlobalName("CTC"));
+    compiledConstants.putIfAbsent(constant, ifAbsentThunk);
+  }
+
   /**
    * Compiles the initial value of the given field and stores it in an internal
    * map.
    *
    * [WorkItem] must contain a [VariableElement] refering to a global or
    * static field.
    */
   void compileWorkItem(WorkItem work) {
     assert(work.element.kind == ElementKind.FIELD
            || work.element.kind == ElementKind.PARAMETER);
@@ skipping 47 matching lines @@
       }
     }
     if (classElement.superclass != compiler.coreLibrary.find(Types.OBJECT)) {
       compiler.unimplemented("CompileTimeConstantHandler with super",
                              node: node);
     }
     compiler.registerInstantiatedClass(classElement);
     Namer namer = compiler.namer;
     String instantiation = "new ${namer.isolatePropertyAccess(classElement)}()";
     Constant constant = new Constant(instantiation);
-    compiledConstants.putIfAbsent(constant,
-                                  () => namer.getFreshGlobalName("CTC"));
+    registerCompileTimeConstant(constant);
     return constant;
   }
 
+  compileListLiteral(Node node, List arguments) {
+    StringBuffer buffer = new StringBuffer();
+    for (int i = 0; i < arguments.length; i++) {
+      if (i != 0) buffer.add(", ");
+      if (arguments[i] is Constant) {
+        // TODO(floitsch): canonicalize if the constant is in the
+        // [compiledConstant] set.
+        Constant constant = arguments[i];
+        buffer.add(constant.jsCode);
+      } else {
+        writeJsCode(buffer, arguments[i]);
+      }
+    }
+    // TODO(floitsch): do we have to register 'List' as instantiated class?
+    String array = "[$buffer]";
+    Constant constant = new Constant(array);
+    registerCompileTimeConstant(constant);
+    return constant;
+  }
+
   /**
    * Returns a [List] of static non final fields that need to be initialized.
    * The list must be evaluated in order since the fields might depend on each
    * other.
    */
   List<VariableElement> getStaticNonFinalFieldsForEmission() {
     return initialVariableValues.getKeys().filter((element) {
       return element.kind == ElementKind.FIELD
           && !element.isInstanceMember()
           && !element.modifiers.isFinal();
@@ skipping 14 matching lines @@
   }
 
   List<Constant> getConstantsForEmission() {
     return compiledConstants.getKeys();
   }
 
   String getNameForConstant(Constant constant) {
     return compiledConstants[constant];
   }
 
-  StringBuffer writeJsCodeForVariable(StringBuffer buffer,
-                                      VariableElement element) {
-    var value = initialVariableValues[element];
+  StringBuffer writeJsCode(StringBuffer buffer, var value) {
     if (value === null) {
       buffer.add("(void 0)");
     } else if (value is num) {
       if (value.isNaN()) {
         buffer.add("(0/0)");
       } else if (value == double.INFINITY) {
         buffer.add("(1/0)");
       } else if (value == -double.INFINITY) {
         buffer.add("(-1/0)");
       } else {
@@ skipping 11 matching lines @@
       buffer.add("'");
     } else if (value is Constant) {
       String name = compiledConstants[value];
       buffer.add("${compiler.namer.ISOLATE}.prototype.$name");
     } else {
       // TODO(floitsch): support more values.
       compiler.unimplemented("CompileTimeConstantHandler" +
                              "writeJsCodeForVariable",
                              element: element);
     }
-    return buffer;
+    return buffer;    
+  }
+
+  StringBuffer writeJsCodeForVariable(StringBuffer buffer,
+                                      VariableElement element) {
+    return writeJsCode(buffer, initialVariableValues[element]);
   }
 
   /**
    * Write the contents of the quoted string to a [StringBuffer] in
    * a form that is valid as JavaScript string literal content.
    * The string is assumed quoted by single quote characters.
    */
   static void writeEscapedString(DartString string,
                                  StringBuffer buffer,
                                  void cancel(String reason)) {
@@ skipping 164 matching lines @@
       for (Link<Node> link = send.arguments;
            !link.isEmpty();
            link = link.tail) {
         arguments.add(evaluate(link.head));
       }
     }
     return constantHandler.compileObjectCreation(node, definitions[node.send],
                                                  arguments);
   }
 
+  visitLiteralList(LiteralList node) {
+    if (!node.isConst()) error(node);
+    List arguments = [];
+    for (Link<Node> link = node.elements.nodes;
+         !link.isEmpty();
+         link = link.tail) {
+      arguments.add(evaluate(link.head));
+    }
+    return constantHandler.compileListLiteral(node, arguments);
+  }
+
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
     compiler.reportError(node, new CompileTimeConstantError(kind, const []));
   }
 }