Handle non-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 773 matching lines @@
             }
           }
         }
       } else if (initializer is SuperConstructorInvocation) {
         SuperConstructorInvocation superConstructorInvocation = initializer;
         SimpleIdentifier name = superConstructorInvocation.constructorName;
         if (name != null) {
           superName = name.name;
         }
         superArguments = superConstructorInvocation.argumentList.arguments;
+      } else if (initializer is RedirectingConstructorInvocation) {
+        // This is a redirecting constructor, so just evaluate the constructor
+        // it redirects to.
+        ConstructorElement constructor = initializer.staticElement;
+        if (constructor != null && constructor.isConst) {
+          return _evaluateConstructorCall(
+              node, initializer.argumentList.arguments, constructor,
+              initializerVisitor, errorReporter);
+        }
       }
     }
     // Evaluate explicit or implicit call to super().
     InterfaceType superclass = definingClass.superclass;
     if (superclass != null && !superclass.isObject) {
       ConstructorElement superConstructor = superclass.lookUpConstructor(superName, constructor.library);
       if (superConstructor != null) {
         if (superArguments == null) {
           superArguments = new NodeList<Expression>(null);
         }
@@ skipping 104 matching lines @@
     identifier.staticElement = node.staticElement;
     return identifier;
   }
 
   @override
   SuperConstructorInvocation visitSuperConstructorInvocation(SuperConstructorInvocation node) {
     SuperConstructorInvocation invocation = super.visitSuperConstructorInvocation(node);
     invocation.staticElement = node.staticElement;
     return invocation;
   }
+
+  @override
+  RedirectingConstructorInvocation visitRedirectingConstructorInvocation(
+      RedirectingConstructorInvocation node) {
+    RedirectingConstructorInvocation invocation =
+        super.visitRedirectingConstructorInvocation(node);
+    invocation.staticElement = node.staticElement;
+    return invocation;
+  }
 }
 
 /**
  * Instances of the class `ConstantVisitor` evaluate constant expressions to produce their
  * compile-time value. According to the Dart Language Specification: <blockquote> A constant
  * expression is one of the following:
  * * A literal number.
  * * A literal boolean.
  * * A literal string where any interpolated expression is a compile-time constant that evaluates
  * to a numeric, string or boolean value or to <b>null</b>.
@@ skipping 3523 matching lines @@
       // The declaration will be null when the constructor is not defined in the compilation
       // units that were used to produce the constructorDeclarationMap.  In such cases, the
       // constructor should already have its initializer AST's stored in it, but we don't bother
       // to check because there's nothing we can do about it at this point.
       if (constructorDeclaration != null) {
         _referenceGraph.addEdge(_source, constructorDeclaration);
       }
     }
     return null;
   }
+
+  @override
+  Object visitRedirectingConstructorInvocation(RedirectingConstructorInvocation node) {
+    super.visitRedirectingConstructorInvocation(node);
+    ConstructorElement target = node.staticElement;
+    if (target != null && target.isConst) {
+      ConstructorDeclaration targetDeclaration = _constructorDeclarationMap[target];
+      if (targetDeclaration != null) {
+        _referenceGraph.addEdge(_source, targetDeclaration);
+      }
+    }
+    return null;
+  }
 }
 
 /**
  * Instances of the class `StringState` represent the state of an object representing a
  * string.
  */
 class StringState extends InstanceState {
   /**
    * The value of this instance.
    */
@@ skipping 185 matching lines @@
 
   @override
   String get typeName => "Type";
 
   @override
   int get hashCode => _element == null ? 0 : _element.hashCode;
 
   @override
   String toString() => _element == null ? "-unknown-" : _element.name;
 }