anchor.diff:      });
       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);
  
positive.code:       if (constructor == null) {
          continue;
        }
        constructor = _followConstantRedirectionChain(constructor);
        ConstructorDeclaration declaration =
            findConstructorDeclaration(constructor);
        // An instance creation expression depends both on the constructor and
  
negative.code:    */
    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) {
  