Materialize ConstructorElementImpl as we analyze constants.

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';
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/ast/utilities.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:analyzer/src/dart/element/member.dart';
+import 'package:analyzer/src/generated/element_handle.dart'
+    show ConstructorElementHandle;
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/engine.dart'
     show AnalysisEngine, RecordingErrorListener;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/java_core.dart';
 import 'package:analyzer/src/generated/resolver.dart' show TypeProvider;
 import 'package:analyzer/src/generated/scanner.dart' show Token, TokenType;
 import 'package:analyzer/src/generated/source.dart' show Source;
 import 'package:analyzer/src/generated/type_system.dart'
     show TypeSystem, TypeSystemImpl;
 import 'package:analyzer/src/generated/utilities_collection.dart';
 import 'package:analyzer/src/generated/utilities_dart.dart' show ParameterKind;
 import 'package:analyzer/src/generated/utilities_general.dart';
 import 'package:analyzer/src/task/dart.dart';
 
+ConstructorElementImpl _getConstructorImpl(ConstructorElement constructor) {
+  if (constructor is ConstructorElementHandle) {
+    constructor = (constructor as ConstructorElementHandle).actualElement;
+  }
+  while (constructor is ConstructorMember) {
+    constructor = (constructor as ConstructorMember).baseElement;
+  }
+  return constructor;
+}
+
 /**
  * Callback used by [ReferenceFinder] to report that a dependency was found.
  */
 typedef void ReferenceFinderCallback(ConstantEvaluationTarget dependency);
 
 /**
  * The state of an object representing a boolean value.
  */
 class BoolState extends InstanceState {
   /**
@@ skipping 291 matching lines @@
     String name = argumentValues[0].toStringValue();
     return isValidPublicSymbol(name);
   }
 
   /**
    * Compute the constant value associated with the given [constant].
    */
   void computeConstantValue(ConstantEvaluationTarget constant) {
     validator.beforeComputeValue(constant);
     if (constant is ParameterElementImpl) {
-      if (constant.initializer != null) {
-        Expression defaultValue = constant.constantInitializer;
-        if (defaultValue != null) {
-          RecordingErrorListener errorListener = new RecordingErrorListener();
-          ErrorReporter errorReporter =
-              new ErrorReporter(errorListener, constant.source);
-          DartObjectImpl dartObject =
-              defaultValue.accept(new ConstantVisitor(this, errorReporter));
-          constant.evaluationResult =
-              new EvaluationResultImpl(dartObject, errorListener.errors);
-        }
+      Expression defaultValue = constant.constantInitializer;
+      if (defaultValue != null) {
+        RecordingErrorListener errorListener = new RecordingErrorListener();
+        ErrorReporter errorReporter =
+            new ErrorReporter(errorListener, constant.source);
+        DartObjectImpl dartObject =
+            defaultValue.accept(new ConstantVisitor(this, errorReporter));
+        constant.evaluationResult =
+            new EvaluationResultImpl(dartObject, errorListener.errors);
       }
     } else if (constant is VariableElementImpl) {
       Expression constantInitializer = constant.constantInitializer;
       if (constantInitializer != null) {
         RecordingErrorListener errorListener = new RecordingErrorListener();
         ErrorReporter errorReporter =
             new ErrorReporter(errorListener, constant.source);
         DartObjectImpl dartObject = constantInitializer
             .accept(new ConstantVisitor(this, errorReporter));
         // Only check the type for truly const declarations (don't check final
@@ skipping 76 matching lines @@
   }
 
   /**
    * 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 ConstructorElement) {
+      constant = _getConstructorImpl(constant);
+    }
     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 =
-              _getConstructorBase(redirectedConstructor);
+              _getConstructorImpl(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 =
-                _getConstructorBase(superclass.element.unnamedConstructor);
+                _getConstructorImpl(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 74 matching lines @@
     }
     return value;
   }
 
   DartObjectImpl evaluateConstructorCall(
       AstNode node,
       NodeList<Expression> arguments,
       ConstructorElement constructor,
       ConstantVisitor constantVisitor,
       ErrorReporter errorReporter) {
-    if (!_getConstructorBase(constructor).isCycleFree) {
+    if (!_getConstructorImpl(constructor).isCycleFree) {
       // It's not safe to evaluate this constructor, so bail out.
       // TODO(paulberry): ensure that a reasonable error message is produced
       // in this case, as well as other cases involving constant expression
       // circularities (e.g. "compile-time constant expression depends on
       // itself")
       return new DartObjectImpl.validWithUnknownValue(constructor.returnType);
     }
     int argumentCount = arguments.length;
     List<DartObjectImpl> argumentValues =
         new List<DartObjectImpl>(argumentCount);
@@ skipping 69 matching lines @@
             definingClass, new SymbolState(argumentValue));
       }
       // Either it's an external const factory constructor that we can't
       // emulate, or an error occurred (a cycle, or a const constructor trying
       // to delegate to a non-const constructor).
       // In the former case, the best we can do is consider it an unknown value.
       // In the latter case, the error has already been reported, so considering
       // it an unknown value will suppress further errors.
       return new DartObjectImpl.validWithUnknownValue(definingClass);
     }
-    ConstructorElementImpl constructorBase = _getConstructorBase(constructor);
+    ConstructorElementImpl constructorBase = _getConstructorImpl(constructor);
     validator.beforeGetConstantInitializers(constructorBase);
     List<ConstructorInitializer> initializers =
         constructorBase.constantInitializers;
     if (initializers == null) {
       // This can happen in some cases where there are compile errors in the
       // code being analyzed (for example if the code is trying to create a
       // const instance using a non-const constructor, or the node we're
       // visiting is involved in a cycle).  The error has already been reported,
       // so consider it an unknown value to suppress further errors.
       return new DartObjectImpl.validWithUnknownValue(definingClass);
@@ skipping 197 matching lines @@
   ConstructorElement followConstantRedirectionChain(
       ConstructorElement constructor) {
     HashSet<ConstructorElement> constructorsVisited =
         new HashSet<ConstructorElement>();
     while (true) {
       ConstructorElement redirectedConstructor =
           getConstRedirectedConstructor(constructor);
       if (redirectedConstructor == null) {
         break;
       } else {
-        ConstructorElement constructorBase = _getConstructorBase(constructor);
+        ConstructorElement constructorBase = _getConstructorImpl(constructor);
         constructorsVisited.add(constructorBase);
         ConstructorElement redirectedConstructorBase =
-            _getConstructorBase(redirectedConstructor);
+            _getConstructorImpl(redirectedConstructor);
         if (constructorsVisited.contains(redirectedConstructorBase)) {
           // Cycle in redirecting factory constructors--this is not allowed
           // and is checked elsewhere--see
           // [ErrorVerifier.checkForRecursiveFactoryRedirect()]).
           break;
         }
       }
       constructor = redirectedConstructor;
     }
     return constructor;
@@ skipping 77 matching lines @@
   }
 
   /**
    * Determine whether the given string is a valid name for a public symbol
    * (i.e. whether it is allowed for a call to the Symbol constructor).
    */
   static bool isValidPublicSymbol(String name) =>
       name.isEmpty ||
       name == "void" ||
       new JavaPatternMatcher(_PUBLIC_SYMBOL_PATTERN, name).matches();
-
-  static ConstructorElementImpl _getConstructorBase(
-      ConstructorElement constructor) {
-    while (constructor is ConstructorMember) {
-      constructor = (constructor as ConstructorMember).baseElement;
-    }
-    return constructor;
-  }
 }
 
 /**
  * Interface used by unit tests to verify correct dependency analysis during
  * constant evaluation.
  */
 abstract class ConstantEvaluationValidator {
   /**
    * This method is called just before computing the constant value associated
    * with [constant]. Unit tests will override this method to introduce
@@ skipping 4136 matching lines @@
   /**
    * Initialize a newly created reference finder to find references from a given
    * variable to other variables and to add those references to the given graph.
    * The [_callback] will be invoked for every dependency found.
    */
   ReferenceFinder(this._callback);
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (node.isConst) {
-      ConstructorElement constructor =
-          ConstantEvaluationEngine._getConstructorBase(node.staticElement);
+      ConstructorElement constructor = _getConstructorImpl(node.staticElement);
       if (constructor != null) {
         _callback(constructor);
       }
     }
     return super.visitInstanceCreationExpression(node);
   }
 
   @override
   Object visitLabel(Label node) {
     // We are visiting the "label" part of a named expression in a function
     // call (presumably a constructor call), e.g. "const C(label: ...)".  We
     // don't want to visit the SimpleIdentifier for the label because that's a
     // reference to a function parameter that needs to be filled in; it's not a
     // constant whose value we depend on.
     return null;
   }
 
   @override
   Object visitRedirectingConstructorInvocation(
       RedirectingConstructorInvocation node) {
     super.visitRedirectingConstructorInvocation(node);
-    ConstructorElement target =
-        ConstantEvaluationEngine._getConstructorBase(node.staticElement);
+    ConstructorElement target = _getConstructorImpl(node.staticElement);
     if (target != null) {
       _callback(target);
     }
     return null;
   }
 
   @override
   Object visitSimpleIdentifier(SimpleIdentifier node) {
     Element element = node.staticElement;
     if (element is PropertyAccessorElement) {
       element = (element as PropertyAccessorElement).variable;
     }
     if (element is VariableElement && element.isConst) {
       _callback(element);
     }
     return null;
   }
 
   @override
   Object visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     super.visitSuperConstructorInvocation(node);
-    ConstructorElement constructor =
-        ConstantEvaluationEngine._getConstructorBase(node.staticElement);
+    ConstructorElement constructor = _getConstructorImpl(node.staticElement);
     if (constructor != null) {
       _callback(constructor);
     }
     return null;
   }
 }
 
 /**
  * The state of an object representing a string.
  */
@@ skipping 194 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;
 }