Rework handling of factory redirects in constant evaluation.

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.
 
 // 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.constant;
 
 import 'dart:collection';
@@ skipping 424 matching lines @@
     _constructorInvocations = _constantFinder.constructorInvocations;
     _annotations = _constantFinder.annotations;
     _variableDeclarationMap.values.forEach((VariableDeclaration declaration) {
       ReferenceFinder referenceFinder = new ReferenceFinder(declaration,
           referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
       referenceGraph.addNode(declaration);
       declaration.initializer.accept(referenceFinder);
     });
     constructorDeclarationMap.forEach((ConstructorElement element,
         ConstructorDeclaration declaration) {
+      ConstructorElement redirectedConstructor =
+          _getConstRedirectedConstructor(element);
+      if (redirectedConstructor != null) {
+        ConstructorElement redirectedConstructorBase =
+            _getConstructorBase(redirectedConstructor);
+        ConstructorDeclaration redirectedConstructorDeclaration =
+            findConstructorDeclaration(redirectedConstructorBase);
+        referenceGraph.addEdge(declaration, redirectedConstructorDeclaration);
+        return;
+      }
       ReferenceFinder referenceFinder = new ReferenceFinder(declaration,
           referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
       referenceGraph.addNode(declaration);
       bool superInvocationFound = false;
       NodeList<ConstructorInitializer> initializers = declaration.initializers;
       for (ConstructorInitializer initializer in initializers) {
         if (initializer is SuperConstructorInvocation) {
           superInvocationFound = true;
         }
         initializer.accept(referenceFinder);
@@ skipping 26 matching lines @@
           }
         }
       }
     });
     for (InstanceCreationExpression expression in _constructorInvocations) {
       referenceGraph.addNode(expression);
       ConstructorElement constructor = expression.staticElement;
       if (constructor == null) {
         continue;
       }
-      constructor = _followConstantRedirectionChain(constructor);
       ConstructorDeclaration declaration =
           findConstructorDeclaration(constructor);
       // An instance creation expression depends both on the constructor and
       // the arguments passed to it.
       ReferenceFinder referenceFinder = new ReferenceFinder(expression,
           referenceGraph, _variableDeclarationMap, constructorDeclarationMap);
       if (declaration != null) {
         referenceGraph.addEdge(expression, declaration);
       }
       expression.argumentList.accept(referenceFinder);
@@ skipping 476 matching lines @@
    * reached which is not a const factory constructor. Return the constant
    * constructor which terminates the chain of factory redirections, if the
    * chain terminates. If there is a problem (e.g. a redirection can't be found,
    * or a cycle is encountered), the chain will be followed as far as possible
    * and then a const factory constructor will be returned.
    */
   ConstructorElement _followConstantRedirectionChain(
       ConstructorElement constructor) {
     HashSet<ConstructorElement> constructorsVisited =
         new HashSet<ConstructorElement>();
-    while (constructor.isFactory) {
-      if (identical(
-          constructor.enclosingElement.type, typeProvider.symbolType)) {
-        // The dart:core.Symbol has a const factory constructor that redirects
-        // to dart:_internal.Symbol.  That in turn redirects to an external
-        // const constructor, which we won't be able to evaluate.
-        // So stop following the chain of redirections at dart:core.Symbol, and
-        // let [evaluateInstanceCreationExpression] handle it specially.
+    while (true) {
+      ConstructorElement redirectedConstructor =
+          _getConstRedirectedConstructor(constructor);
+      if (redirectedConstructor == null) {
         break;
-      }
-      ConstructorElement constructorBase = _getConstructorBase(constructor);
-      constructorsVisited.add(constructorBase);
-      ConstructorElement redirectedConstructor =
-          constructor.redirectedConstructor;
-      if (redirectedConstructor == null) {
-        // This can happen if constructor is an external factory constructor.
-        break;
-      }
-      if (!redirectedConstructor.isConst) {
-        // Delegating to a non-const constructor--this is not allowed (and
-        // is checked elsewhere--see
-        // [ErrorVerifier.checkForRedirectToNonConstConstructor()]).
-        break;
-      }
-      ConstructorElement redirectedConstructorBase =
-          _getConstructorBase(redirectedConstructor);
-      if (constructorsVisited.contains(redirectedConstructorBase)) {
-        // Cycle in redirecting factory constructors--this is not allowed
-        // and is checked elsewhere--see
-        // [ErrorVerifier.checkForRecursiveFactoryRedirect()]).
-        break;
+      } else {
+        ConstructorElement constructorBase = _getConstructorBase(constructor);
+        constructorsVisited.add(constructorBase);
+        ConstructorElement redirectedConstructorBase =
+            _getConstructorBase(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;
   }
 
   /**
    * Generate an error indicating that the given [constant] is not a valid
    * compile-time constant because it references at least one of the constants
    * in the given [cycle], each of which directly or indirectly references the
    * constant.
    */
   void _generateCycleError(List<AstNode> cycle, AstNode constant) {
     // TODO(brianwilkerson) Implement this.
   }
 
+  /**
+   * If [constructor] redirects to another const constructor, return the
+   * const constructor it redirects to.  Otherwise return `null`.
+   */
+  ConstructorElement _getConstRedirectedConstructor(
+      ConstructorElement constructor) {
+    if (!constructor.isFactory) {
+      return null;
+    }
+    if (identical(constructor.enclosingElement.type, typeProvider.symbolType)) {
+      // The dart:core.Symbol has a const factory constructor that redirects
+      // to dart:_internal.Symbol.  That in turn redirects to an external
+      // const constructor, which we won't be able to evaluate.
+      // So stop following the chain of redirections at dart:core.Symbol, and
+      // let [evaluateInstanceCreationExpression] handle it specially.
+      return null;
+    }
+    ConstructorElement redirectedConstructor =
+        constructor.redirectedConstructor;
+    if (redirectedConstructor == null) {
+      // This can happen if constructor is an external factory constructor.
+      return null;
+    }
+    if (!redirectedConstructor.isConst) {
+      // Delegating to a non-const constructor--this is not allowed (and
+      // is checked elsewhere--see
+      // [ErrorVerifier.checkForRedirectToNonConstConstructor()]).
+      return null;
+    }
+    return redirectedConstructor;
+  }
+
   ConstructorElement _getConstructorBase(ConstructorElement constructor) {
     while (constructor is ConstructorMember) {
       constructor = (constructor as ConstructorMember).baseElement;
     }
     return constructor;
   }
 
   /**
    * Check if the object [obj] matches the type [type] according to runtime type
    * checking rules.
@@ skipping 4020 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;
 }