Separate CONSTANT_EXPRESSION_RESOLVED flag from RESOLVED_UNITx.

pkg/analyzer/lib/src/generated/constant.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.generated.constant;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:analyzer/dart/ast/visitor.dart';
@@ skipping 219 matching lines @@
    */
   static RegExp _PUBLIC_SYMBOL_PATTERN = new RegExp(
       "^(?:${ConstantValueComputer._OPERATOR_RE}\$|$_PUBLIC_IDENTIFIER_RE(?:=?\$|[.](?!\$)))+?\$");
 
   /**
    * The type provider used to access the known types.
    */
   final TypeProvider typeProvider;
 
   /**
-   * The type system.  This is used to gues the types of constants when their
+   * The type system.  This is used to guess the types of constants when their
    * exact value is unknown.
    */
   final TypeSystem typeSystem;
 
   /**
    * The set of variables declared on the command line using '-D'.
    */
   final DeclaredVariables _declaredVariables;
 
   /**
@@ skipping 168 matching lines @@
             new EvaluationResultImpl(result, errorListener.errors);
       } else {
         // This may happen for invalid code (e.g. failing to pass arguments
         // to an annotation which references a const constructor).  The error
         // is detected elsewhere, so just silently ignore it here.
         constant.evaluationResult = new EvaluationResultImpl(null);
       }
     } else if (constant is VariableElement) {
       // constant is a VariableElement but not a VariableElementImpl.  This can
       // happen sometimes in the case of invalid user code (for example, a
-      // constant expression that refers to a nonstatic field inside a generic
+      // constant expression that refers to a non-static field inside a generic
       // class will wind up referring to a FieldMember).  The error is detected
       // elsewhere, so just silently ignore it here.
     } else {
       // Should not happen.
       assert(false);
       AnalysisEngine.instance.logger.logError(
           "Constant value computer trying to compute the value of a node of type ${constant.runtimeType}");
       return;
     }
   }
 
   /**
    * Determine which constant elements need to have their values computed
    * prior to computing the value of [constant], and report them using
    * [callback].
    */
   void computeDependencies(
       ConstantEvaluationTarget constant, ReferenceFinderCallback callback) {
     ReferenceFinder referenceFinder = new ReferenceFinder(callback);
-    if (constant is ParameterElementImpl) {
-      if (constant.initializer != null) {
-        Expression defaultValue = constant.constantInitializer;
-        if (defaultValue != null) {
-          defaultValue.accept(referenceFinder);
-        }
-      }
-    } else if (constant is VariableElementImpl) {
+    if (constant is VariableElementImpl) {
       Expression initializer = constant.constantInitializer;
       if (initializer != null) {
         initializer.accept(referenceFinder);
       }
     } else if (constant is ConstructorElementImpl) {
       if (constant.isConst) {
         constant.isCycleFree = false;
         ConstructorElement redirectedConstructor =
             getConstRedirectedConstructor(constant);
         if (redirectedConstructor != null) {
           ConstructorElement redirectedConstructorBase =
-              ConstantEvaluationEngine
-                  ._getConstructorBase(redirectedConstructor);
+              _getConstructorBase(redirectedConstructor);
           callback(redirectedConstructorBase);
           return;
         } else if (constant.isFactory) {
           // Factory constructor, but getConstRedirectedConstructor returned
           // null.  This can happen if we're visiting one of the special external
           // const factory constructors in the SDK, or if the code contains
           // errors (such as delegating to a non-const constructor, or delegating
           // to a constructor that can't be resolved).  In any of these cases,
           // we'll evaluate calls to this constructor without having to refer to
           // any other constants.  So we don't need to report any dependencies.
           return;
         }
         bool superInvocationFound = false;
         List<ConstructorInitializer> initializers =
             constant.constantInitializers;
         for (ConstructorInitializer initializer in initializers) {
           if (initializer is SuperConstructorInvocation) {
             superInvocationFound = true;
           }
           initializer.accept(referenceFinder);
         }
         if (!superInvocationFound) {
           // No explicit superconstructor invocation found, so we need to
           // manually insert a reference to the implicit superconstructor.
           InterfaceType superclass =
               (constant.returnType as InterfaceType).superclass;
           if (superclass != null && !superclass.isObject) {
-            ConstructorElement unnamedConstructor = ConstantEvaluationEngine
-                ._getConstructorBase(superclass.element.unnamedConstructor);
+            ConstructorElement unnamedConstructor =
+                _getConstructorBase(superclass.element.unnamedConstructor);
             if (unnamedConstructor != null) {
               callback(unnamedConstructor);
             }
           }
         }
         for (FieldElement field in constant.enclosingElement.fields) {
           // Note: non-static const isn't allowed but we handle it anyway so
           // that we won't be confused by incorrect code.
           if ((field.isFinal || field.isConst) &&
               !field.isStatic &&
@@ skipping 20 matching lines @@
       } else {
         // This could happen in the event of invalid code.  The error will be
         // reported at constant evaluation time.
       }
       if (constNode.arguments != null) {
         constNode.arguments.accept(referenceFinder);
       }
     } else if (constant is VariableElement) {
       // constant is a VariableElement but not a VariableElementImpl.  This can
       // happen sometimes in the case of invalid user code (for example, a
-      // constant expression that refers to a nonstatic field inside a generic
+      // constant expression that refers to a non-static field inside a generic
       // class will wind up referring to a FieldMember).  So just don't bother
       // computing any dependencies.
     } else {
       // Should not happen.
       assert(false);
       AnalysisEngine.instance.logger.logError(
           "Constant value computer trying to compute the value of a node of type ${constant.runtimeType}");
     }
   }
 
@@ skipping 4876 matching lines @@
       return BoolState.from(_element == rightElement);
     } else if (rightOperand is DynamicState) {
       return BoolState.UNKNOWN_VALUE;
     }
     return BoolState.FALSE_STATE;
   }
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }