Add API to force the computation of constant values

pkg/analyzer/lib/src/dart/element/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 analyzer.src.dart.element.element;
 
 import 'dart:collection';
 import 'dart:math' show min;
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/token.dart';
 import 'package:analyzer/dart/constant/value.dart';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/dart/element/visitor.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/handle.dart';
 import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/generated/constant.dart' show EvaluationResultImpl;
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisContext, AnalysisEngine;
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/java_engine.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart';
 import 'package:analyzer/src/generated/utilities_general.dart';
+import 'package:analyzer/src/task/dart.dart';
 
 /**
  * For AST nodes that could be in both the getter and setter contexts
  * ([IndexExpression]s and [SimpleIdentifier]s), the additional resolved
  * elements are stored in the AST node, in an [AuxiliaryElements]. Because
  * resolved elements are either statically resolved or resolved using propagated
  * type information, this class is a wrapper for a pair of [ExecutableElement]s,
  * not just a single [ExecutableElement].
  */
 class AuxiliaryElements {
@@ skipping 1217 matching lines @@
  *
  * TODO(paulberry): we should rename this class to reflect the fact that it's
  * used for both const and final fields.  However, we shouldn't do so until
  * we've created an API for reading the values of constants; until that API is
  * available, clients are likely to read constant values by casting to
  * ConstFieldElementImpl, so it would be a breaking change to rename this
  * class.
  */
 class ConstFieldElementImpl extends FieldElementImpl with ConstVariableElement {
   /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
    * Initialize a newly created synthetic field element to have the given
    * [name] and [offset].
    */
   ConstFieldElementImpl(String name, int offset) : super(name, offset);
 
   /**
    * Initialize a newly created field element to have the given [name].
    */
   ConstFieldElementImpl.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result?.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
     with ConstVariableElement {
   /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
    * 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.forNode(Identifier name) : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result?.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
 }
 
 /**
  * A concrete implementation of a [ConstructorElement].
  */
 class ConstructorElementImpl extends ExecutableElementImpl
     implements ConstructorElement {
   /**
    * The constructor to which this constructor is redirecting.
    */
@@ skipping 111 matching lines @@
       getNodeMatching((node) => node is ConstructorDeclaration);
 }
 
 /**
  * A [TopLevelVariableElement] for a top-level 'const' variable that has an
  * initializer.
  */
 class ConstTopLevelVariableElementImpl extends TopLevelVariableElementImpl
     with ConstVariableElement {
   /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
    * Initialize a newly created synthetic top-level variable element to have the
    * given [name] and [offset].
    */
   ConstTopLevelVariableElementImpl(String name, int offset)
       : super(name, offset);
 
   /**
    * Initialize a newly created top-level variable element to have the given
    * [name].
    */
   ConstTopLevelVariableElementImpl.forNode(Identifier name)
       : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result?.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
 }
 
 /**
  * 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 {
+abstract class ConstVariableElement implements 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 constantInitializer;
+
+  @override
+  EvaluationResultImpl evaluationResult;
+
+  /**
+   * Return a representation of the value of this variable, forcing the value
+   * to be computed if it had not previously been computed, or `null` if either
+   * this variable was not declared with the 'const' modifier or if the value of
+   * this variable could not be computed because of errors.
+   */
+  DartObject computeConstantValue() {
+    if (evaluationResult == null) {
+      context?.computeResult(this, CONSTANT_VALUE);
+    }
+    return evaluationResult?.value;
+  }
 }
 
 /**
  * A [FieldFormalParameterElementImpl] for parameters that have an initializer.
  */
 class DefaultFieldFormalParameterElementImpl
     extends FieldFormalParameterElementImpl with ConstVariableElement {
   /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
    * Initialize a newly created parameter element to have the given [name] and
    * [nameOffset].
    */
   DefaultFieldFormalParameterElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
 
   /**
    * Initialize a newly created parameter element to have the given [name].
    */
   DefaultFieldFormalParameterElementImpl.forNode(Identifier name)
       : super.forNode(name);
-
-  @override
-  DartObject get constantValue => _result?.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
 }
 
 /**
  * A [ParameterElement] for parameters that have an initializer.
  */
 class DefaultParameterElementImpl extends ParameterElementImpl
     with ConstVariableElement {
   /**
-   * The result of evaluating this variable's initializer.
-   */
-  EvaluationResultImpl _result;
-
-  /**
    * Initialize a newly created parameter element to have the given [name] and
    * [nameOffset].
    */
   DefaultParameterElementImpl(String name, int nameOffset)
       : super(name, nameOffset);
 
   /**
    * Initialize a newly created parameter element to have the given [name].
    */
   DefaultParameterElementImpl.forNode(Identifier name) : super.forNode(name);
 
   @override
-  DartObject get constantValue => _result?.value;
-
-  @override
-  EvaluationResultImpl get evaluationResult => _result;
-
-  @override
-  void set evaluationResult(EvaluationResultImpl result) {
-    this._result = result;
-  }
-
-  @override
   DefaultFormalParameter computeNode() =>
       getNodeMatching((node) => node is DefaultFormalParameter);
 }
 
 /**
  * The synthetic element representing the declaration of the type `dynamic`.
  */
 class DynamicElementImpl extends ElementImpl implements TypeDefiningElement {
   /**
    * Return the unique instance of this class.
@@ skipping 175 matching lines @@
 
   /**
    * Get the library containing this annotation.
    */
   Source get librarySource => compilationUnit.librarySource;
 
   @override
   Source get source => compilationUnit.source;
 
   @override
+  DartObject computeConstantValue() {
+    if (evaluationResult == null) {
+      context?.computeResult(this, CONSTANT_VALUE);
+    }
+    return constantValue;
+  }
+
+  @override
   String toString() => '@$element';
 }
 
 /**
  * A base class for concrete implementations of an [Element].
  */
 abstract class ElementImpl implements Element {
   /**
    * An Unicode right arrow.
    */
@@ skipping 3156 matching lines @@
    * 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;
+  DartObject get constantValue => evaluationResult?.value;
 
   /**
    * 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 52 matching lines @@
   bool get isStatic => hasModifier(Modifier.STATIC);
 
   @override
   void appendTo(StringBuffer buffer) {
     buffer.write(type);
     buffer.write(" ");
     buffer.write(displayName);
   }
 
   @override
+  DartObject computeConstantValue() => null;
+
+  @override
   void visitChildren(ElementVisitor visitor) {
     super.visitChildren(visitor);
     _initializer?.accept(visitor);
   }
 }
 
 /**
  * A visitor that visit all the elements recursively and fill the given [map].
  */
 class _BuildOffsetToElementMap extends GeneralizingElementVisitor {
   final Map<int, Element> map;
 
   _BuildOffsetToElementMap(this.map);
 
   @override
   void visitElement(Element element) {
     int offset = element.nameOffset;
     if (offset != -1) {
       map[offset] = element;
     }
     super.visitElement(element);
   }
 }