Rework handling of potentially-constant variables.

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.
 
 library engine.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/src/generated/utilities_general.dart';
@@ skipping 2119 matching lines @@
  * Mixin used 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 is not intended to be part of the public API for analyzer.
  */
-abstract class ConstVariableElement implements PotentiallyConstVariableElement {
+abstract class ConstVariableElement {
   /**
    * 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 constantInitializer;
@@ skipping 2025 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   AstNode computeNode();
 }
 
 /**
  * A concrete implementation of a [FieldElement].
  */
 class FieldElementImpl extends PropertyInducingElementImpl
-    with PotentiallyConstVariableElement
     implements FieldElement {
   /**
    * An empty list of field elements.
    */
   @deprecated // Use FieldElement.EMPTY_LIST
   static const List<FieldElement> EMPTY_ARRAY = const <FieldElement>[];
 
   /**
    * Initialize a newly created synthetic field element to have the given [name]
    * at the given [offset].
@@ skipping 3735 matching lines @@
    * so parsing and resolving will be performed.
    */
   @override
   VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [LocalVariableElement].
  */
 class LocalVariableElementImpl extends VariableElementImpl
-    with PotentiallyConstVariableElement
     implements LocalVariableElement {
   /**
    * An empty list of field elements.
    */
   @deprecated // Use LocalVariableElement.EMPTY_LIST
   static const List<LocalVariableElement> EMPTY_ARRAY =
       const <LocalVariableElement>[];
 
   /**
    * The offset to the beginning of the visible range for this element.
@@ skipping 916 matching lines @@
   void appendToWithoutDelimiters(StringBuffer buffer);
 
   @override
   FormalParameter computeNode();
 }
 
 /**
  * A concrete implementation of a [ParameterElement].
  */
 class ParameterElementImpl extends VariableElementImpl
-    with ParameterElementMixin, PotentiallyConstVariableElement
+    with ParameterElementMixin
     implements ParameterElement {
   /**
    * An empty list of parameter elements.
    */
   @deprecated // Use ParameterElement.EMPTY_LIST
   static const List<ParameterElement> EMPTY_ARRAY = const <ParameterElement>[];
 
   /**
    * A list containing all of the parameters defined by this parameter element.
    * There will only be parameters if this parameter is a function typed
@@ skipping 338 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);
   }
 }
 
 /**
- * Interface used by elements that might represent constant variables.
- *
- * This class may be used as a mixin in the case where [constInitializer] is
- * known to return null.
- *
- * This class is not intended to be part of the public API for analyzer.
- */
-abstract class PotentiallyConstVariableElement
-    implements VariableElementImpl, ConstantEvaluationTarget {
-  /**
-   * 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 => null;
-}
-
-/**
  * A prefix used to import one or more libraries into another library.
  */
 abstract class PrefixElement implements Element {
   /**
    * An empty list of prefix elements.
    */
   static const List<PrefixElement> EMPTY_LIST = const <PrefixElement>[];
 
   /**
    * Return the library into which other libraries are imported using this
@@ skipping 788 matching lines @@
       const <TopLevelVariableElement>[];
 
   @override
   VariableDeclaration computeNode();
 }
 
 /**
  * A concrete implementation of a [TopLevelVariableElement].
  */
 class TopLevelVariableElementImpl extends PropertyInducingElementImpl
-    with PotentiallyConstVariableElement
     implements TopLevelVariableElement {
   /**
    * An empty list of top-level variable elements.
    */
   @deprecated // Use TopLevelVariableElement.EMPTY_LIST
   static const List<TopLevelVariableElement> EMPTY_ARRAY =
       const <TopLevelVariableElement>[];
 
   /**
    * Initialize a newly created synthetic top-level variable element to have the
@@ skipping 684 matching lines @@
    */
   VariableElementImpl.forNode(Identifier name) : super.forNode(name);
 
   /**
    * Set whether this variable is const.
    */
   void set const3(bool isConst) {
     setModifier(Modifier.CONST, isConst);
   }
 
+  /**
+   * 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 => null;
+
   @override
   DartObject get constantValue => null;
 
   /**
    * Return the result of evaluating this variable's initializer as a
    * compile-time constant expression, or `null` if this variable is not a
    * 'const' variable, if it does not have an initializer, or if the compilation
    * unit containing the variable has not been resolved.
    */
   EvaluationResultImpl get evaluationResult => null;
@@ skipping 198 matching lines @@
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }