dart2dart: Support for all constants in new backend.

sdk/lib/_internal/compiler/implementation/ir/ir_nodes.dart

 // Copyright (c) 2013, 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.
 
 // IrNodes are kept in a separate library to have precise control over their
 // dependencies on other parts of the system.
 library dart2js.ir_nodes;
 
-import '../dart2jslib.dart' as dart2js show Constant;
+import '../dart2jslib.dart' as dart2js show Constant, ConstructedConstant;
 import '../elements/elements.dart'
     show FunctionElement, LibraryElement, ParameterElement, ClassElement,
     Element, VariableElement;
 import '../universe/universe.dart' show Selector, SelectorKind;
 import '../dart_types.dart' show DartType, GenericType;
 import '../helpers/helpers.dart';
 
 abstract class Node {
   static int hashCount = 0;
   final int hashCode = hashCount = (hashCount + 1) & 0x3fffffff;
@@ skipping 34 matching lines @@
 abstract class Primitive extends Definition {
   /// The [VariableElement] or [ParameterElement] from which the primitive
   /// binding originated.
   Element element;
 
   /// Register in which the variable binding this primitive can be allocated.
   /// Separate register spaces are used for primitives with different [element].
   /// Assigned by [RegisterAllocator], is null before that phase.
   int registerIndex;
 
+  /// If non-null, this primitive is a reference to the given constant.
+  dart2js.Constant get constant;
+
   /// Use the given element as a hint for naming this primitive.
   ///
   /// Has no effect if this primitive already has a non-null [element].
   void useElementAsHint(Element hint) {
     if (element == null) {
       element = hint;
     }
   }
 }
 
@@ skipping 133 matching lines @@
 
   accept(Visitor visitor) => visitor.visitInvokeConstructor(this);
 }
 
 class InvokeConstConstructor extends Primitive {
   final GenericType type;
   final FunctionElement constructor;
   final List<Reference> arguments;
   final Selector selector;
 
+  final dart2js.ConstructedConstant constant;
+
   /// The class being instantiated. This is the same as `target.enclosingClass`
   /// and `type.element`.
   ClassElement get targetClass => constructor.enclosingElement;
 
   /// True if this is an invocation of a factory constructor.
   bool get isFactory => constructor.isFactoryConstructor;
 
   InvokeConstConstructor(this.type,
                     this.constructor,
                     this.selector,
-                    List<Definition> args)
+                    List<Definition> args,
+                    this.constant)
       : arguments = _referenceList(args) {
     assert(constructor.isConstructor);
     assert(type.element == constructor.enclosingElement);
+    assert(constant.type == type);
   }
 
   accept(Visitor visitor) => visitor.visitInvokeConstConstructor(this);
 }
 
 /// Invoke [toString] on each argument and concatenate the results.
 class ConcatenateStrings extends Expression {
   final Reference continuation;
   final List<Reference> arguments;
 
@@ skipping 47 matching lines @@
         falseContinuation = new Reference(falseCont);
 
   accept(Visitor visitor) => visitor.visitBranch(this);
 }
 
 class Constant extends Primitive {
   final dart2js.Constant value;
 
   Constant(this.value);
 
+  dart2js.Constant get constant => value;
+
   accept(Visitor visitor) => visitor.visitConstant(this);
 }
 
 class LiteralList extends Primitive {
-  List<Reference> values;
+  /// The List type being created; this is not the type argument.
+  final GenericType type;
+  final List<Reference> values;
 
-  LiteralList(List<Primitive> values)
+  /// Set to null if this is not a const literal list.
+  final dart2js.Constant constant;
+
+  LiteralList(this.type, List<Primitive> values, [this.constant])
       : this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralList(this);
 }
 
 class LiteralMap extends Primitive {
-  List<Reference> keys;
-  List<Reference> values;
+  final GenericType type;
+  final List<Reference> keys;
+  final List<Reference> values;
 
-  LiteralMap(List<Primitive> keys, List<Primitive> values)
+  /// Set to null if this is not a const literal map.
+  final dart2js.Constant constant;
+
+  LiteralMap(this.type, List<Primitive> keys, List<Primitive> values,
+             [this.constant])
       : this.keys = _referenceList(keys),
         this.values = _referenceList(values);
 
   accept(Visitor visitor) => visitor.visitLiteralMap(this);
 }
 
 class Parameter extends Primitive {
   Parameter(Element element) {
     super.element = element;
   }
 
+  dart2js.Constant get constant => null;
+
   accept(Visitor visitor) => visitor.visitParameter(this);
 }
 
 /// Continuations are normally bound by 'let cont'.  A continuation with no
 /// parameter (or body) is used to represent a function's return continuation.
 /// The return continuation is bound by the Function, not by 'let cont'.
 class Continuation extends Definition {
   final List<Parameter> parameters;
   Expression body = null;
 
@@ skipping 317 matching lines @@
     for (int i = node.parameters.length - 1; i >= 0; --i) {
       release(node.parameters[i]);
     }
   }
 
   void visitIsTrue(IsTrue node) {
     visitReference(node.value);
   }
 
 }