Begin making copies of AST nodes for constants during resolution.

pkg/analyzer/lib/src/generated/element.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.
 
 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
 
 library engine.element;
 
 import 'dart:collection';
@@ skipping 1475 matching lines @@
     safelyVisitChildren(_functions, visitor);
     safelyVisitChildren(_typeAliases, visitor);
     safelyVisitChildren(_types, visitor);
     safelyVisitChildren(_variables, visitor);
   }
 }
 
 /**
  * A [FieldElement] for a 'const' field that has an initializer.
  */
-class ConstFieldElementImpl extends FieldElementImpl {
+class ConstFieldElementImpl extends FieldElementImpl
+    implements ConstVariableElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
+   * A copy of the AST for the variable's initializer.
+   */
+  Expression _constantInitializer;
+
+  /**
    * Initialize a newly created field element to have the given [name].
    */
   ConstFieldElementImpl.con1(Identifier name) : super.forNode(name);
 
   /**
    * Initialize a newly created synthetic field element to have the given
    * [name] and [offset].
    */
   ConstFieldElementImpl.con2(String name, int offset) : super(name, offset);
 
   @override
+  Expression get constantInitializer => _constantInitializer;

[scheglov, 2015/04/01 23:34:16]

It looks that we don't process this field.
So, why not just convert _constantInitializer into a public field
"constantInitializer"?

[Paul Berry, 2015/04/02 15:18:49]

Done.

+
+  @override
+  void set constantInitializer(Expression value) {
+    _constantInitializer = value;
+  }
+
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
   @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
  * A [LocalVariableElement] for a local 'const' variable that has an
  * initializer.
  */
-class ConstLocalVariableElementImpl extends LocalVariableElementImpl {
+class ConstLocalVariableElementImpl extends LocalVariableElementImpl
+    implements ConstVariableElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
+   * A copy of the AST for the variable's initializer.
+   */
+  Expression _constantInitializer;
+
+  /**
+   * Initialize a newly created local variable element to have the given [name]
+   * and [offset].
+   */
+  ConstLocalVariableElementImpl(String name, int offset) : super(name, offset);
+
+  /**
    * Initialize a newly created local variable element to have the given [name].
    */
-  ConstLocalVariableElementImpl(Identifier name) : super.forNode(name);
+  ConstLocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
+
+  @override
+  Expression get constantInitializer => _constantInitializer;
+
+  @override
+  void set constantInitializer(Expression value) {
+    _constantInitializer = value;
+  }
 
   @override
   EvaluationResultImpl get evaluationResult => _result;
 
   @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
@@ skipping 76 matching lines @@
    */
   int periodOffset;
 
   /**
    * Return the offset of the character immediately following the last character
    * of this constructor's name, or `null` if not named.
    */
   int nameEnd;
 
   /**
+   * True if this constructor has been found by constant evaluation to be free
+   * of redirect cycles, and is thus safe to evaluate.
+   */
+  bool isCycleFree = false;
+
+  /**
    * Initialize a newly created constructor element to have the given [name] and
    * [offset].
    */
   ConstructorElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created constructor element to have the given [name].
    */
   ConstructorElementImpl.forNode(Identifier name) : super.forNode(name);
 
@@ skipping 177 matching lines @@
     // instance. It would use more memory but speed up some operations.
     // We need to see how often the type is being re-computed.
     return new ConstructorMember(constructor, definingType);
   }
 }
 
 /**
  * A [TopLevelVariableElement] for a top-level 'const' variable that has an
  * initializer.
  */
-class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl {
+class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl
+    implements ConstVariableElementImpl {
   /**
    * The result of evaluating this variable's initializer.
    */
   EvaluationResultImpl _result;
 
   /**
+   * A copy of the AST for the variable's initializer.
+   */
+  Expression _constantInitializer;
+
+  /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   ConstTopLevelVariableElementImpl(Identifier name) : super.forNode(name);
 
   @override
+  Expression get constantInitializer => _constantInitializer;
+
+  @override
+  void set constantInitializer(Expression value) {
+    _constantInitializer = value;
+  }
+
+  @override
   EvaluationResultImpl get evaluationResult => _result;
 
   @override
   void set evaluationResult(EvaluationResultImpl result) {
     this._result = result;
   }
 }
 
 /**
+ * Common interface shared by elements that represent constant variables and
+ * have initializers.
+ *
+ * Note that in correct Dart code, all constant variables must have
+ * initializers.  However, analyzer also needs to handle incorrect Dart code,
+ * in which case there might be some constant variables that lack initializers.
+ * This interface is only used for constant variables that have initializers.
+ *
+ * This class has "Impl" in the name to emphasize the fact that it is not
+ * intended to be part of the public API for analyzer.

[Brian Wilkerson, 2015/04/01 20:31:54]

That's a little odd. When I first saw it I assumed it was a concrete class and
commented that it seemed weird to 'implement' a concrete class that way.

Also, everywhere that implements this interface has the same implementation.
This might be a good place for a mixin.

[Paul Berry, 2015/04/02 15:18:49]

Fair enough.  I've removed "Impl" from the name of this class and
PotentiallyConstVariableElement.
Good idea!  PTAL and let me know if the change looks good to you.  Unfortunately
due to the limitations on mixins I had to remove the "implements" clauses, which
led to some warnings when trying to convert a VariableElement to a
ConstVariableElement or a PotentiallyConstVariableElement.  Fortunately these
warnings were easy to get rid of using "as".

+ */
+abstract class ConstVariableElementImpl
+    extends PotentiallyConstVariableElementImpl {
+  /**
+   * Store a copy of the initializer for this variable (which will later be
+   * usd for evaluating constants).

[Brian Wilkerson, 2015/04/01 20:31:54]

"usd" --> "used"

[Paul Berry, 2015/04/02 15:18:49]

Done.

+   */
+  void set constantInitializer(Expression value);
+}
+
+/**
  * The type associated with elements in the element model.
  */
 abstract class DartType {
   /**
    * Return the name of this type as it should appear when presented to users in
    * contexts such as error messages.
    */
   String get displayName;
 
   /**
@@ skipping 1864 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   AstNode get node;
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
-    implements FieldElement {
+    implements FieldElement, PotentiallyConstVariableElementImpl {
   /**
    * An empty list of field elements.
    */
   static const List<FieldElement> EMPTY_ARRAY = const <FieldElement>[];
 
   /**
    * Initialize a newly created synthetic field element to have the given [name]
    * at the given [offset].
    */
   FieldElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created field element to have the given [name].
    */
   FieldElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
+  Expression get constantInitializer => null;
+
+  @override
   ClassElement get enclosingElement => super.enclosingElement as ClassElement;
 
   @override
   bool get isEnumConstant =>
       enclosingElement != null ? enclosingElement.isEnum : false;
 
   @override
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
@@ skipping 3565 matching lines @@
 
 /**
  * A local variable.
  */
 abstract class LocalVariableElement implements LocalElement, VariableElement {}
 
 /**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends VariableElementImpl
-    implements LocalVariableElement {
+    implements LocalVariableElement, PotentiallyConstVariableElementImpl {
   /**
    * An empty list of field elements.
    */
   static const List<LocalVariableElement> EMPTY_ARRAY =
       const <LocalVariableElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
    */
   int _visibleRangeOffset = 0;
 
   /**
    * The length of the visible range for this element, or `-1` if this element
    * does not have a visible range.
    */
   int _visibleRangeLength = -1;
 
   /**
    * Initialize a newly created method element to have the given [name] and
    * [offset].
    */
   LocalVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created local variable element to have the given [name].
    */
   LocalVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
+  Expression get constantInitializer => null;
+
+  @override
   String get identifier {
     int enclosingOffset =
         enclosingElement != null ? enclosingElement.nameOffset : 0;
     int delta = nameOffset - enclosingOffset;
     return '${super.identifier}@$delta';
   }
 
   @override
   bool get isPotentiallyMutatedInClosure =>
       hasModifier(Modifier.POTENTIALLY_MUTATED_IN_CONTEXT);
@@ skipping 1142 matching lines @@
     // We need to see how often the type is being re-computed.
     if (isFieldFormal) {
       return new FieldFormalParameterMember(
           parameter as FieldFormalParameterElement, definingType);
     }
     return new ParameterMember(parameter, definingType);
   }
 }
 
 /**
+ * Common interface shared by elements that might represent constant variables.
+ *
+ * This class has "Impl" in the name to emphasize the fact that it is not
+ * intended to be part of the public API for analyzer.
+ */
+abstract class PotentiallyConstVariableElementImpl extends VariableElement {
+  /**
+   * If this element represents a constant variable, and it has an initializer,
+   * a copy of the initializer for the constant.  Otherwise `null`.
+   *
+   * Note that in correct Dart code, all constant variables must have
+   * initializers.  However, analyzer also needs to handle incorrect Dart code,
+   * in which case there might be some constant variables that lack
+   * initializers.
+   */
+  Expression get constantInitializer;
+}
+
+/**
  * A prefix used to import one or more libraries into another library.
  */
 abstract class PrefixElement implements Element {
   /**
    * Return the library into which other libraries are imported using this
    * prefix.
    */
   @override
   LibraryElement get enclosingElement;
 
@@ skipping 760 matching lines @@
 
 /**
  * A top-level variable.
  */
 abstract class TopLevelVariableElement implements PropertyInducingElement {}
 
 /**
  * A concrete implementation of a [TopLevelVariableElement].
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl
-    implements TopLevelVariableElement {
+    implements TopLevelVariableElement, PotentiallyConstVariableElementImpl {
   /**
    * An empty list of top-level variable elements.
    */
   static const List<TopLevelVariableElement> EMPTY_ARRAY =
       const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
    */
   TopLevelVariableElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   TopLevelVariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
+  Expression get constantInitializer => null;
+
+  @override
   bool get isStatic => true;
 
   @override
   ElementKind get kind => ElementKind.TOP_LEVEL_VARIABLE;
 
   @override
   accept(ElementVisitor visitor) => visitor.visitTopLevelVariableElement(this);
 }
 
 /**
@@ skipping 1113 matching lines @@
     // void <: void (by reflexivity)
     // bottom <: void (as bottom is a subtype of all types).
     // void <: dynamic (as dynamic is a supertype of all types)
     return identical(type, this) || type.isDynamic;
   }
 
   @override
   VoidTypeImpl substitute2(
       List<DartType> argumentTypes, List<DartType> parameterTypes) => this;
 }