Support symbol literals.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 457 matching lines @@
       }
       accumulator = new DartString.concat(accumulator, expressionString);
       StringConstant partString = evaluate(part.string);
       if (partString == null) return null;
       accumulator = new DartString.concat(accumulator, partString.value);
     };
     handler.registerStringInstance(elements);
     return constantSystem.createString(accumulator, node);
   }
 
+  Constant visitLiteralSymbol(LiteralSymbol node) {
+    InterfaceType type = compiler.symbolClass.computeType(compiler);
+    List<Constant> createArguments(_) {
+      return [constantSystem.createString(

[ngeoffray, 2013/09/04 07:14:17]

add <Constant> (since you went into the trouble of typing the return type with
it.

[Johnni Winther, 2013/09/10 09:09:07]

Done.

+        new DartString.literal(node.slowNameString), node)];
+    }
+    return makeConstructedConstant(
+        node, type, compiler.symbolConstructor, createArguments);
+  }
+
   Constant makeTypeConstant(Element element) {
     DartType elementType = element.computeType(compiler).asRaw();
     compiler.backend.registerTypeLiteral(element, elements);
     DartType constantType =
         compiler.backend.typeImplementation.computeType(compiler);
     Constant constant = new TypeConstant(elementType, constantType);
     // If we use a type literal in a constant, the compile time
     // constant emitter will generate a call to the createRuntimeType
     // helper so we register a use of that.
     handler.registerCreateRuntimeTypeFunction();
@@ skipping 192 matching lines @@
     }
 
     Send send = node.send;
     FunctionElement constructor = elements[send];
     // TODO(ahe): This is nasty: we must eagerly analyze the
     // constructor to ensure the redirectionTarget has been computed
     // correctly.  Find a way to avoid this.
     compiler.analyzeElement(constructor.declaration);
 
     InterfaceType type = elements.getType(node);
+    List<Constant> evaluateArguments(FunctionElement constructor) {
+      Selector selector = elements.getSelector(send);
+      return evaluateArgumentsToConstructor(
+          node, selector, send.arguments, constructor);
+    }
+    return makeConstructedConstant(node, type, constructor, evaluateArguments);
+  }
+
+  Constant makeConstructedConstant(
+      Node node, InterfaceType type, FunctionElement constructor,
+      List<Constant> getArguments(FunctionElement constructor)) {
     if (constructor.isRedirectingFactory) {
       type = constructor.computeTargetType(compiler, type);
     }
 
     constructor = constructor.redirectionTarget;
     ClassElement classElement = constructor.getEnclosingClass();
     // The constructor must be an implementation to ensure that field
     // initializers are handled correctly.
     constructor = constructor.implementation;
     assert(invariant(node, constructor.isImplementation));
 
-    Selector selector = elements.getSelector(send);
-    List<Constant> arguments = evaluateArgumentsToConstructor(
-        node, selector, send.arguments, constructor);
+    List<Constant> arguments = getArguments(constructor);
     ConstructorEvaluator evaluator =
         new ConstructorEvaluator(constructor, handler, compiler);
     evaluator.evaluateConstructorFieldValues(arguments);
     List<Constant> jsNewArguments = evaluator.buildJsNewArguments(classElement);
 
     handler.registerInstantiatedType(type, elements);
     Constant constant = new ConstructedConstant(type, jsNewArguments);
     handler.registerCompileTimeConstant(constant, elements);
     return constant;
   }
@@ skipping 216 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }