Add ConstantConstructor to ConstantExpression system.

pkg/compiler/lib/src/elements/modelx.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.
 
 library elements.modelx;
 
 import 'elements.dart';
 import '../constants/expressions.dart';
+import '../constants/constructors.dart';
 import '../helpers/helpers.dart';  // Included for debug helpers.
 import '../tree/tree.dart';
 import '../util/util.dart';
 import '../resolution/resolution.dart';
 import '../resolution/class_members.dart' show ClassMemberMixin;
 
 import '../dart2jslib.dart' show
     Backend,
     Compiler,
     Constant,
@@ skipping 280 matching lines @@
   get cachedNode => unsupported();
   get functionSignature => unsupported();
   get parameters => unsupported();
   get patch => null;
   get origin => this;
   get immediateRedirectionTarget => unsupported();
   get nestedClosures => unsupported();
   get memberContext => unsupported();
   get executableContext => unsupported();
   get isExternal => unsupported();
+  get constantConstructor => null;
 
   bool get isRedirectingGenerative => unsupported();
   bool get isRedirectingFactory => unsupported();
 
   computeSignature(compiler) => unsupported();
 
   bool get hasFunctionSignature => false;
 
   get effectiveTarget => this;
 
   computeEffectiveTargetType(InterfaceType newType) => unsupported();
 
   get definingConstructor => null;
 
   FunctionElement asFunctionElement() => this;
 
   String get message => '${messageKind.message(messageArguments)}';
 
   String toString() => '<$name: $message>';
 
   accept(ElementVisitor visitor, arg) {
     return visitor.visitErroneousElement(this, arg);
   }
+
+  @override
+  bool get isFromEnvironmentConstructor => false;
 }
 
 /// A constructor that was synthesized to recover from a compile-time error.
 class ErroneousConstructorElementX extends ErroneousElementX
-    with PatchMixin<FunctionElement>, AnalyzableElementX
+    with PatchMixin<FunctionElement>,
+         AnalyzableElementX,
+         ConstantConstructorMixin
     implements ConstructorElementX {
   // TODO(ahe): Instead of subclassing [ErroneousElementX], this class should
   // be more like [ErroneousFieldElementX]. In particular, its kind should be
   // [ElementKind.GENERATIVE_CONSTRUCTOR], and it shouldn't throw as much.
 
   ErroneousConstructorElementX(
       MessageKind messageKind,
       Map messageArguments,
       String name,
       Element enclosing)
@@ skipping 901 matching lines @@
     assert(modifiers != null);
   }
 
   VariableDefinitions parseNode(Element element, DiagnosticListener listener) {
     return definitions;
   }
 
   DartType computeType(Element element, Compiler compiler) => type;
 }
 
-abstract class VariableElementX extends ElementX with AstElementMixin
+abstract class ConstantVariableMixin implements VariableElement {
+  ConstantExpression _constant;
+
+  ConstantExpression get constant {
+    assert(invariant(this, _constant != null,
+        message: "Constant has not been computed for $this."));
+    return _constant;
+  }
+
+  void set constant(ConstantExpression value) {
+    assert(invariant(this, _constant == null || _constant == value,
+        message: "Constant has already been computed for $this."));
+    _constant = value;
+  }
+}
+
+abstract class VariableElementX extends ElementX
+    with AstElementMixin, ConstantVariableMixin
     implements VariableElement {
   final Token token;
   final VariableList variables;
   VariableDefinitions definitionsCache;
   Expression initializerCache;
 
   Modifiers get modifiers => variables.modifiers;
 
   VariableElementX(String name,
                    ElementKind kind,
@@ skipping 138 matching lines @@
     nestedClosures.clear();
   }
 
   FieldElementX copyWithEnclosing(Element enclosingElement) {
     return new FieldElementX(
         new Identifier(token), enclosingElement, variables);
   }
 }
 
 /// A field that was synthesized to recover from a compile-time error.
-class ErroneousFieldElementX extends ElementX implements FieldElementX {
+class ErroneousFieldElementX extends ElementX
+    with ConstantVariableMixin implements FieldElementX {
   final VariableList variables;
 
   ErroneousFieldElementX(Identifier name, Element enclosingElement)
       : variables = new VariableList(Modifiers.EMPTY)
             ..definitions = new VariableDefinitions(
                 null, Modifiers.EMPTY, new NodeList.singleton(name))
             ..type = const DynamicType(),
         super(name.source, ElementKind.FIELD, enclosingElement);
 
   VariableDefinitions get definitionsCache => variables.definitions;
@@ skipping 124 matching lines @@
   AstElement get definingElement => declaration;
 }
 
 /// [Element] for a formal parameter.
 ///
 /// A [ParameterElementX] can be patched. A parameter of an external method is
 /// patched with the corresponding parameter of the patch method. This is done
 /// to ensure that default values on parameters are computed once (on the
 /// origin parameter) but can be found through both the origin and the patch.
 abstract class ParameterElementX extends FormalElementX
-  with PatchMixin<ParameterElement> implements ParameterElement {
+    with PatchMixin<ParameterElement>, ConstantVariableMixin
+    implements ParameterElement {
   final Expression initializer;
   final bool isOptional;
   final bool isNamed;
 
   ParameterElementX(ElementKind elementKind,
                     FunctionElement functionDeclaration,
                     VariableDefinitions definitions,
                     Identifier identifier,
                     this.initializer,
                     {this.isOptional: false,
@@ skipping 369 matching lines @@
     if (node.name != null) {
       return node.name.getBeginToken();
     } else {
       return node.getBeginToken();
     }
   }
 
   bool get isLocal => true;
 }
 
+abstract class ConstantConstructorMixin implements ConstructorElement {
+  ConstantConstructor _constantConstructor;
+
+  ConstantConstructor get constantConstructor {
+    if (isPatch) {
+      ConstructorElement originConstructor = origin;
+      return originConstructor.constantConstructor;
+    }
+    if (!isConst || isFromEnvironmentConstructor) return null;
+    if (_constantConstructor == null) {
+      _constantConstructor = computeConstantConstructor(resolvedAst);
+    }
+    return _constantConstructor;
+  }
+
+  bool get isFromEnvironmentConstructor {
+    return name == 'fromEnvironment' &&
+           library.isDartCore &&
+           (enclosingClass.name == 'bool' ||
+            enclosingClass.name == 'int' ||
+            enclosingClass.name == 'String');
+  }
+}
+
 abstract class ConstructorElementX extends FunctionElementX
-    implements ConstructorElement {
+    with ConstantConstructorMixin implements ConstructorElement {
   bool isRedirectingGenerative = false;
 
   ConstructorElementX(String name,
                       ElementKind kind,
                       Modifiers modifiers,
                       Element enclosing)
         : super(name, kind, modifiers, enclosing, false);
 
   FunctionElement immediateRedirectionTarget;
 
@@ skipping 1161 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }