Remove const instance creation expressions from the dependency graph.

pkg/analyzer/lib/src/generated/resolver.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 engine.resolver;
 
 import "dart:math" as math;
 import 'dart:collection';
 
 import 'package:analyzer/src/generated/utilities_collection.dart';
@@ skipping 894 matching lines @@
   @override
   Object visitFunctionExpression(FunctionExpression node) {
     super.visitFunctionExpression(node);
     _validateDefaultValues(node.parameters);
     return null;
   }
 
   @override
   Object visitInstanceCreationExpression(InstanceCreationExpression node) {
     if (node.isConst) {
-      EvaluationResultImpl evaluationResult = node.evaluationResult;
-      // Note: evaluationResult might be null if there are circular references
-      // among constants.
-      if (evaluationResult != null) {
-        _reportErrors(evaluationResult.errors, null);
+      // We need to evaluate the constant to see if any errors occur during its
+      // evaluation.
+      ConstructorElement constructor = node.staticElement;
+      if (constructor != null) {
+        ConstantEvaluationEngine evaluationEngine =
+            new ConstantEvaluationEngine(_typeProvider, declaredVariables);
+        ConstantVisitor constantVisitor =
+            new ConstantVisitor(evaluationEngine, _errorReporter);
+        evaluationEngine.evaluateConstructorCall(node,
+            node.argumentList.arguments, constructor, constantVisitor,
+            _errorReporter);
       }
     }
     _validateInstanceCreationArguments(node);
     return super.visitInstanceCreationExpression(node);
   }
 
   @override
   Object visitListLiteral(ListLiteral node) {
     super.visitListLiteral(node);
     if (node.constKeyword != null) {
@@ skipping 115 matching lines @@
     if (!foundError) {
       _checkForCaseExpressionTypeImplementsEquals(node, firstType);
     }
     return super.visitSwitchStatement(node);
   }
 
   @override
   Object visitVariableDeclaration(VariableDeclaration node) {
     super.visitVariableDeclaration(node);
     Expression initializer = node.initializer;
-    if (initializer != null && node.isConst) {
+    if (initializer != null && (node.isConst || node.isFinal)) {
       VariableElementImpl element = node.element as VariableElementImpl;
       EvaluationResultImpl result = element.evaluationResult;
       if (result == null) {
-        //
-        // Normally we don't need to visit const variable declarations because
-        // we have already computed their values. But if we missed it for some
-        // reason, this gives us a second chance.
-        //
-        result = new EvaluationResultImpl.con1(_validate(initializer,
-            CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE));
-        element.evaluationResult = result;
+        // Variables marked "const" should have had their values computed by
+        // ConstantValueComputer.  Other variables will only have had their
+        // values computed if the value was needed (e.g. final variables in a
+        // class containing const constructors).
+        assert(!node.isConst);
         return null;
       }
       _reportErrors(result.errors,
           CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE);
       _reportErrorIfFromDeferredLibrary(initializer,
           CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY);
     }
     return null;
   }
 
@@ skipping 75 matching lines @@
       ErrorCode dataErrorCode = data.errorCode;
       if (identical(dataErrorCode,
               CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION) ||
           identical(
               dataErrorCode, CompileTimeErrorCode.CONST_EVAL_THROWS_IDBZE) ||
           identical(dataErrorCode,
               CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_INT) ||
           identical(dataErrorCode, CompileTimeErrorCode.CONST_EVAL_TYPE_NUM) ||
+          identical(dataErrorCode, CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT) ||
           identical(dataErrorCode,
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_FIELD_TYPE_MISMATCH) ||
           identical(dataErrorCode,
               CheckedModeCompileTimeErrorCode.CONST_CONSTRUCTOR_PARAM_TYPE_MISMATCH) ||
           identical(dataErrorCode,
               CheckedModeCompileTimeErrorCode.VARIABLE_TYPE_MISMATCH)) {
         _errorReporter.reportError(data);
       } else if (errorCode != null) {
         _errorReporter.reportError(new AnalysisError.con2(
             data.source, data.offset, data.length, errorCode));
@@ skipping 1683 matching lines @@
     //of this parameter.
     //
     ElementHolder holder = new ElementHolder();
     _visitChildren(holder, node);
     (node.element as ParameterElementImpl).parameters = holder.parameters;
     holder.validate();
     return null;
   }
 
   @override
-  Object visitInstanceCreationExpression(InstanceCreationExpression node) {
-    if (node.isConst) {
-      node.constantHandle = new ConstantInstanceCreationHandle();
-    }
-    return super.visitInstanceCreationExpression(node);
-  }
-
-  @override
   Object visitLabeledStatement(LabeledStatement node) {
     bool onSwitchStatement = node.statement is SwitchStatement;
     for (Label label in node.labels) {
       SimpleIdentifier labelName = label.label;
       LabelElementImpl element =
           new LabelElementImpl(labelName, onSwitchStatement, false);
       _currentHolder.addLabel(element);
       labelName.staticElement = element;
     }
     return super.visitLabeledStatement(node);
@@ skipping 12555 matching lines @@
     nonFields.add(node);
     return null;
   }
 
   @override
   Object visitNode(AstNode node) => node.accept(TypeResolverVisitor_this);
 
   @override
   Object visitWithClause(WithClause node) => null;
 }