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 415 matching lines @@
     InterfaceType type = new InterfaceType(classElement, typeArgument);
     handler.registerInstantiatedType(type, elements);
     Constant constant = new MapConstant(type, keysList, values, protoValue);
     handler.registerCompileTimeConstant(constant, elements);
     return constant;
   }
 
   Constant visitLiteralNull(LiteralNull node) {
     return constantSystem.createNull();
   }
-
+  
   Constant visitLiteralString(LiteralString node) {
     handler.registerStringInstance(elements);
     return constantSystem.createString(node.dartString, node);
   }
 
   Constant visitStringJuxtaposition(StringJuxtaposition node) {
     StringConstant left = evaluate(node.first);
     StringConstant right = evaluate(node.second);
     if (left == null || right == null) return null;
     handler.registerStringInstance(elements);
@@ skipping 20 matching lines @@
         return signalNotCompileTimeConstant(part.expression);
       }
       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 visitSymbolLiteral(SymbolLiteral node) {
+    InterfaceType type = compiler.symbolClass.computeType(compiler);
+    List<Constant> createArguments(_) {
+      return [constantSystem.createString(
+        new DartString.literal(node.nameString), 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.
@@ skipping 193 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;
   }
-
+  
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     compiler.reportFatalError(
         node, MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
   }
@@ skipping 203 matching lines @@
           if (fieldValue == null) {
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeSuperAndInjectedMembers: true);
     return jsNewArguments;
   }
 }