Compute constant constructors in resolution.

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 'common.dart';
 import 'elements.dart';
 import '../constants/expressions.dart';
 import '../constants/constructors.dart';
+import '../helpers/helpers.dart';
 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,
     DartType,
@@ skipping 1220 matching lines @@
   }
 
   VariableDefinitions parseNode(Element element, DiagnosticListener listener) {
     return definitions;
   }
 
   DartType computeType(Element element, Compiler compiler) => type;
 }
 
 abstract class ConstantVariableMixin implements VariableElement {
-  ConstantExpression _constant;
+  ConstantExpression constantCache;
 
   ConstantExpression get constant {
     if (isPatch) {
       ConstantVariableMixin originVariable = origin;
       return originVariable.constant;
     }
-    assert(invariant(this, _constant != null,
+    assert(invariant(this, constantCache != null,
         message: "Constant has not been computed for $this."));
-    return _constant;
+    return constantCache;
   }
 
   void set constant(ConstantExpression value) {
     if (isPatch) {
       ConstantVariableMixin originVariable = origin;
       originVariable.constant = value;
       return null;
     }
-    assert(invariant(this, _constant == null || _constant == value,
+    assert(invariant(this, constantCache == null || constantCache == value,
         message: "Constant has already been computed for $this."));
-    _constant = value;
+    constantCache = value;
   }
 }
 
 abstract class VariableElementX extends ElementX
     with AstElementMixin, ConstantVariableMixin
     implements VariableElement {
   final Token token;
   final VariableList variables;
   VariableDefinitions definitionsCache;
   Expression initializerCache;
@@ skipping 677 matching lines @@
       ConstructorElement originConstructor = origin;
       return originConstructor.constantConstructor;
     }
     if (!isConst || isFromEnvironmentConstructor) return null;
     if (_constantConstructor == null) {
       _constantConstructor = computeConstantConstructor(resolvedAst);
     }
     return _constantConstructor;
   }
 
+  void set constantConstructor(ConstantConstructor value) {
+    if (isPatch) {
+      ConstantConstructorMixin originConstructor = origin;
+      originConstructor.constantConstructor = value;
+    } else {
+      assert(invariant(this, isConst,
+          message: "Constant constructor set on non-constant "
+                   "constructor $this."));
+      assert(invariant(this, !isFromEnvironmentConstructor,
+          message: "Constant constructor set on fromEnvironment "
+                   "constructor: $this."));
+      assert(invariant(this,
+          _constantConstructor == null || _constantConstructor == value,
+          message: "Constant constructor already computed for $this:"
+                   "Existing: $_constantConstructor, new: $value"));
+      _constantConstructor = value;
+    }
+  }
+
   bool get isFromEnvironmentConstructor {
     return name == 'fromEnvironment' &&
            library.isDartCore &&
            (enclosingClass.name == 'bool' ||
             enclosingClass.name == 'int' ||
             enclosingClass.name == 'String');
   }
 }
 
 abstract class ConstructorElementX extends FunctionElementX
@@ skipping 916 matching lines @@
   AstElement get definingElement;
 
   bool get hasResolvedAst => definingElement.hasTreeElements;
 
   ResolvedAst get resolvedAst {
     return new ResolvedAst(declaration,
         definingElement.node, definingElement.treeElements);
   }
 
 }