Add ConstantConstructor to ConstantExpression system.

pkg/compiler/lib/src/dart_backend/backend_ast_emitter.dart

 // Copyright (c) 2014, 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.
 
 library backend_ast_emitter;
 
 import '../tree_ir/tree_ir_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../constants/expressions.dart';
 import '../constants/values.dart';
@@ skipping 1096 matching lines @@
           ..dartType = type;
     } else {
       throw "Unsupported type annotation: $type";
     }
   }
 
 }
 
 
 class ConstantEmitter
-    extends ConstantExpressionVisitor<BuilderContext<Statement>, Expression> {
+    extends ConstantExpressionVisitor<Expression, BuilderContext<Statement>> {
   const ConstantEmitter();
 
   /// Creates the [Expression] for the constant [exp].
   static Expression createExpression(ConstantExpression exp,
                                      BuilderContext<Statement> context) {
     return const ConstantEmitter().visit(exp, context);
   }
 
   Expression handlePrimitiveConstant(PrimitiveConstantValue value) {
     // Num constants may be negative, while literals must be non-negative:
@@ skipping 12 matching lines @@
     return new Literal(value);
   }
 
   List<Expression> visitExpressions(List<ConstantExpression> expressions,
                                     BuilderContext<Statement> context) {
     return expressions.map((expression) => visit(expression, context))
         .toList(growable: false);
   }
 
   @override
-  Expression visitPrimitive(PrimitiveConstantExpression exp,
-                            BuilderContext<Statement> context) {
+  Expression visitBool(BoolConstantExpression exp,
+                       BuilderContext<Statement> context) {
     return handlePrimitiveConstant(exp.value);
   }
 
+  @override
+  Expression visitInt(IntConstantExpression exp,
+                      BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
+  @override
+  Expression visitDouble(DoubleConstantExpression exp,
+                         BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
+  @override
+  Expression visitString(StringConstantExpression exp,
+                         BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
+  @override
+  Expression visitNull(NullConstantExpression exp,
+                       BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
   /// Given a negative num constant, returns the corresponding positive
   /// literal wrapped by a unary minus operator.
   Expression negatedLiteral(NumConstantValue constant) {
     assert(constant.primitiveValue.isNegative);
     NumConstantValue positiveConstant;
     if (constant.isInt) {
       positiveConstant = new IntConstantValue(-constant.primitiveValue);
     } else if (constant.isDouble) {
       positiveConstant = new DoubleConstantValue(-constant.primitiveValue);
     } else {
@@ skipping 44 matching lines @@
                        constructorName: name,
                        isConst: true)
                ..constructor = constructor
                ..dartType = exp.type;
   }
 
   @override
   Expression visitConcatenate(ConcatenateConstantExpression exp,
                               BuilderContext<Statement> context) {
 
-    return new StringConcat(visitExpressions(exp.arguments, context));
+    return new StringConcat(visitExpressions(exp.expressions, context));
   }
 
   @override
   Expression visitSymbol(SymbolConstantExpression exp,
                          BuilderContext<Statement> context) {
     return new LiteralSymbol(exp.name);
   }
 
   @override
   Expression visitType(TypeConstantExpression exp,
@@ skipping 42 matching lines @@
     } else {
       return exp.falseExp.accept(this);
     }
   }
 
   @override
   Expression visitUnary(UnaryConstantExpression exp,
                         BuilderContext<Statement> context) {
     return handlePrimitiveConstant(exp.value);
   }
+
+  @override
+  Expression visitNamed(NamedArgumentReference exp,
+                        BuilderContext<Statement> context) {
+    throw new UnsupportedError("ConstantEmitter.visitNamed");
+  }
+
+  @override
+  Expression visitPositional(PositionalArgumentReference exp,
+                             BuilderContext<Statement> context) {
+    throw new UnsupportedError("ConstantEmitter.visitPositional");
+  }
+
+  @override
+  Expression visitBoolFromEnvironment(
+      BoolFromEnvironmentConstantExpression exp,
+      BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
+  @override
+  Expression visitIntFromEnvironment(
+      IntFromEnvironmentConstantExpression exp,
+      BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
+  @override
+  Expression visitStringFromEnvironment(
+      StringFromEnvironmentConstantExpression exp,
+      BuilderContext<Statement> context) {
+    return handlePrimitiveConstant(exp.value);
+  }
 }
 
 /// Moves function parameters into a separate variable if one of its uses is
 /// shadowed by an inner function parameter.
 /// This artifact is necessary because function parameters cannot be renamed.
 class UnshadowParameters extends tree.RecursiveVisitor {
 
   /// Maps parameter names to their bindings.
   Map<String, tree.Variable> environment = <String, tree.Variable>{};
 
@@ skipping 67 matching lines @@
       : super(name, ElementKind.VARIABLE, enclosingElement, variables, null);
 
   ExecutableElement get executableContext => enclosingElement;
 
   ExecutableElement get memberContext => executableContext.memberContext;
 
   bool get isLocal => true;
 
   LibraryElement get implementationLibrary => enclosingElement.library;
 }