Use ConstExp for storing constants.

sdk/lib/_internal/compiler/implementation/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_nodes.dart' as tree;
 import 'backend_ast_nodes.dart';
 import '../dart2jslib.dart' as dart2js;
 import '../elements/elements.dart';
@@ skipping 652 matching lines @@
   }
 
   Expression emitConstant(ConstExp exp) => new ConstantEmitter(this).visit(exp);
 
 }
 
 class ConstantEmitter extends ConstExpVisitor<Expression> {
   ASTEmitter parent;
   ConstantEmitter(this.parent);
 
-  Expression visitPrimitive(PrimitiveConstExp exp) {
+  Expression handlePrimitiveConstant(dart2js.PrimitiveConstant value) {
     // Num constants may be negative, while literals must be non-negative:
     // Literals are non-negative in the specification, and a negated literal
     // parses as a call to unary `-`. The AST unparser assumes literals are
     // non-negative and relies on this to avoid incorrectly generating `--`,
     // the predecrement operator.
     // Translate such constants into their positive value wrapped by
     // the unary minus operator.
-    if (exp.constant is dart2js.NumConstant) {
-      dart2js.NumConstant numConstant = exp.constant;
+    if (value is dart2js.NumConstant) {
+      dart2js.NumConstant numConstant = value;
       if (numConstant.value.isNegative) {
         return negatedLiteral(numConstant);
       }
     }
-    return new Literal(exp.constant);
+    return new Literal(value);
+  }
+
+  Expression visitPrimitive(PrimitiveConstExp exp) {
+    return handlePrimitiveConstant(exp.value);
   }
 
   /// Given a negative num constant, returns the corresponding positive
   /// literal wrapped by a unary minus operator.
   Expression negatedLiteral(dart2js.NumConstant constant) {
     assert(constant.value.isNegative);
     dart2js.NumConstant positiveConstant;
     if (constant.isInt) {
       positiveConstant = new dart2js.IntConstant(-constant.value);
     } else if (constant.isDouble) {
@@ skipping 64 matching lines @@
     String name = parent.getConstantName(element);
     return new Identifier(name)
                ..element = element;
   }
 
   Expression visitFunction(FunctionConstExp exp) {
     return new Identifier(exp.element.name)
                ..element = exp.element;
   }
 
+  @override

[sigurdm, 2014/09/17 10:29:41]

Maybe add override to all the overriding methods

[Johnni Winther, 2014/09/17 12:20:40]

Done.

+  Expression visitBinary(BinaryConstExp exp) {
+    return handlePrimitiveConstant(exp.value);
+  }
+
+  @override
+  Expression visitConditional(ConditionalConstExp exp) {
+    if (exp.condition.value.isTrue) {
+      return exp.trueExp.accept(this);
+    } else {
+      return exp.falseExp.accept(this);
+    }
+  }
+
+  @override
+  Expression visitUnary(UnaryConstExp exp) {
+    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 36 matching lines @@
     }
   }
 
   visitVariable(tree.Variable variable) {
     if (shadowedParameters.contains(variable)) {
       hasShadowedUse.add(variable);
     }
   }
 
 }