Issue 29358. Fix for reporting constant errors while evaluating constructor invocations.

pkg/analyzer/lib/src/dart/constant/evaluation.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.dart.constant.evaluation;
 
 import 'dart:collection';
 
 import 'package:analyzer/context/declared_variables.dart';
 import 'package:analyzer/dart/ast/ast.dart';
@@ skipping 532 matching lines @@
       // Instantiate the constructor with the in-scope type arguments.
       definingClass = constantVisitor.evaluateType(definingClass);
       constructor = ConstructorMember.from(constructorBase, definingClass);
 
       typeArgumentMap = new HashMap<String, DartObjectImpl>.fromIterables(
           definingClass.typeParameters.map((t) => t.name),
           definingClass.typeArguments.map(constantVisitor.typeConstant));
     }
 
     var fieldMap = new HashMap<String, DartObjectImpl>();
-    var fieldInitVisitor = new ConstantVisitor(this, errorReporter,
+
+    // The errors reported while computing values for field initializers, or
+    // default values for the constructor parameters, cannot be reported
+    // into the current ErrorReporter, because they usually happen in a
+    // different source. But they still should cause a constant evaluation
+    // error for the current node.
+    var externalErrorListener = new RecordingErrorListener();
+    var externalErrorReporter =
+        new ErrorReporter(externalErrorListener, constructor.source);
+
+    void reportLocalErrorForRecordedExternalErrors() {
+      ErrorCode errorCode;
+      for (AnalysisError error in externalErrorListener.errors) {
+        if (error.errorCode is CompileTimeErrorCode) {
+          errorCode = CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION;
+          break;
+        }
+        if (error.errorCode is CheckedModeCompileTimeErrorCode) {
+          errorCode =
+              CheckedModeCompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION;
+          break;
+        }
+      }
+      if (errorCode != null) {
+        errorReporter.reportErrorForNode(errorCode, node);
+      }
+    }
+
+    var fieldInitVisitor = new ConstantVisitor(this, externalErrorReporter,
         lexicalEnvironment: typeArgumentMap);
     // Start with final fields that are initialized at their declaration site.
     List<FieldElement> fields = constructor.enclosingElement.fields;
     for (int i = 0; i < fields.length; i++) {
       FieldElement field = fields[i];
       if ((field.isFinal || field.isConst) &&
           !field.isStatic &&
           field is ConstFieldElementImpl) {
         validator.beforeGetFieldEvaluationResult(field);
 
@@ skipping 102 matching lines @@
                   CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION, node);
             }
             fieldMap[fieldName] = argumentValue;
           }
         }
         String name = baseParameter.name;
         parameterMap[name] = argumentValue;
       }
     }
     ConstantVisitor initializerVisitor = new ConstantVisitor(
-        this, errorReporter,
+        this, externalErrorReporter,
         lexicalEnvironment: parameterMap);
     String superName = null;
     NodeList<Expression> superArguments = null;
     for (ConstructorInitializer initializer in initializers) {
       if (initializer is ConstructorFieldInitializer) {
         Expression initializerExpression = initializer.expression;
         DartObjectImpl evaluationResult =
             initializerExpression.accept(initializerVisitor);
         if (evaluationResult != null) {
           String fieldName = initializer.fieldName.name;
@@ skipping 18 matching lines @@
         SimpleIdentifier name = initializer.constructorName;
         if (name != null) {
           superName = name.name;
         }
         superArguments = initializer.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(
+          DartObjectImpl result = evaluateConstructorCall(
               node,
               initializer.argumentList.arguments,
               constructor,
               initializerVisitor,
-              errorReporter,
+              externalErrorReporter,
               invocation: invocation);
+          reportLocalErrorForRecordedExternalErrors();
+          return result;
         }
       }
     }
     // 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 = astFactory.nodeList/*<Expression>*/(null);
         }
 
         evaluateSuperConstructorCall(node, fieldMap, superConstructor,
-            superArguments, initializerVisitor, errorReporter);
+            superArguments, initializerVisitor, externalErrorReporter);
       }
     }
+    reportLocalErrorForRecordedExternalErrors();
     return new DartObjectImpl(
         definingClass, new GenericState(fieldMap, invocation: invocation));
   }
 
   void evaluateSuperConstructorCall(
       AstNode node,
       HashMap<String, DartObjectImpl> fieldMap,
       ConstructorElement superConstructor,
       List<Expression> superArguments,
       ConstantVisitor initializerVisitor,
@@ skipping 1347 matching lines @@
   }
 
   @override
   String toString() {
     if (value == null) {
       return "error";
     }
     return value.toString();
   }
 }