Extract DiagnosticReporter implementation from Compiler.

pkg/compiler/lib/src/compile_time_constants.dart

 // Copyright (c) 2012, 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 dart2js.compile_time_constant_evaluator;
 
 import 'common/resolution.dart' show
     Resolution;
 import 'common/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
 import 'constant_system_dart.dart';
 import 'constants/constant_system.dart';
 import 'constants/evaluation.dart';
 import 'constants/expressions.dart';
 import 'constants/values.dart';
 import 'dart_types.dart';
+import 'diagnostics/diagnostic_listener.dart' show
+    DiagnosticReporter;
 import 'diagnostics/invariant.dart' show
     invariant;
 import 'diagnostics/messages.dart' show
     MessageKind;
 import 'enqueue.dart' show
     WorldImpact;
 import 'elements/elements.dart';
 import 'elements/modelx.dart' show
     FunctionElementX;
 import 'resolution/tree_elements.dart' show
@@ skipping 127 matching lines @@
       new Map<VariableElement, ConstantExpression>();
 
   /** The set of variable elements that are in the process of being computed. */
   final Set<VariableElement> pendingVariables = new Set<VariableElement>();
 
   final Map<ConstantExpression, ConstantValue> constantValueMap =
       <ConstantExpression, ConstantValue>{};
 
   ConstantCompilerBase(this.compiler, this.constantSystem);
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   @override
   ConstantValue getConstantValueForVariable(VariableElement element) {
     return getConstantValue(initialVariableValues[element.declaration]);
   }
 
   @override
   ConstantExpression getConstantForVariable(VariableElement element) {
     return initialVariableValues[element.declaration];
   }
 
@@ skipping 17 matching lines @@
   /// Compile [element] into a constant expression. If [isConst] is true,
   /// then [element] is a constant variable. If [checkType] is true, then
   /// report an error if [element] does not typecheck.
   ConstantExpression internalCompileVariable(
       VariableElement element, bool isConst, bool checkType) {
     if (initialVariableValues.containsKey(element.declaration)) {
       ConstantExpression result = initialVariableValues[element.declaration];
       return result;
     }
     AstElement currentElement = element.analyzableElement;
-    return compiler.withCurrentElement(currentElement, () {
+    return reporter.withCurrentElement(currentElement, () {
       // TODO(johnniwinther): Avoid this eager analysis.
       _analyzeElementEagerly(compiler, currentElement);
 
       ConstantExpression constant = compileVariableWithDefinitions(
           element, currentElement.resolvedAst.elements,
           isConst: isConst, checkType: checkType);
       return constant;
     });
   }
 
   /**
    * Returns the a compile-time constant if the variable could be compiled
    * eagerly. If the variable needs to be initialized lazily returns `null`.
    * If the variable is `const` but cannot be compiled eagerly reports an
    * error.
    */
   ConstantExpression compileVariableWithDefinitions(
       VariableElement element, TreeElements definitions,
       {bool isConst: false, bool checkType: true}) {
     Node node = element.node;
     if (pendingVariables.contains(element)) {
       if (isConst) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
         ConstantExpression expression = new ErroneousConstantExpression();
         constantValueMap[expression] = constantSystem.createNull();
         return expression;
       }
       return null;
     }
     pendingVariables.add(element);
 
     Expression initializer = element.initializer;
     ConstantExpression expression;
     if (initializer == null) {
       // No initial value.
       expression = new NullConstantExpression();
       constantValueMap[expression] = constantSystem.createNull();
     } else {
       expression = compileNodeWithDefinitions(initializer, definitions,
           isConst: isConst);
       if (compiler.enableTypeAssertions &&
           checkType &&
           expression != null &&
           element.isField) {
         DartType elementType = element.type;
         ConstantValue value = getConstantValue(expression);
         if (elementType.isMalformed && !value.isNull) {
           if (isConst) {
             ErroneousElement element = elementType.element;
-            compiler.reportErrorMessage(
+            reporter.reportErrorMessage(
                 node, element.messageKind, element.messageArguments);
           } else {
             // We need to throw an exception at runtime.
             expression = null;
           }
         } else {
           DartType constantType = value.getType(compiler.coreTypes);
           if (!constantSystem.isSubtype(
               compiler.types, constantType, elementType)) {
             if (isConst) {
-              compiler.reportErrorMessage(
+              reporter.reportErrorMessage(
                   node,
                   MessageKind.NOT_ASSIGNABLE,
                   {'fromType': constantType,
                    'toType': elementType});
             } else {
               // If the field cannot be lazily initialized, we will throw
               // the exception at runtime.
               expression = null;
             }
           }
@@ skipping 87 matching lines @@
 
   Element get context => elements.analyzedElement;
 
   CompileTimeConstantEvaluator(this.handler, this.elements, this.compiler,
       {bool isConst: false})
       : this.isEvaluatingConstant = isConst;
 
   ConstantSystem get constantSystem => handler.constantSystem;
   Resolution get resolution => compiler.resolution;
 
+  DiagnosticReporter get reporter => compiler.reporter;
+
   AstConstant evaluate(Node node) {
     // TODO(johnniwinther): should there be a visitErrorNode?
     if (node is ErrorNode) return new ErroneousAstConstant(context, node);
     return node.accept(this);
   }
 
   AstConstant evaluateConstant(Node node) {
     bool oldIsEvaluatingConstant = isEvaluatingConstant;
     isEvaluatingConstant = true;
     AstConstant result = node.accept(this);
@@ skipping 61 matching lines @@
       if (key == null) {
         return null;
       }
       AstConstant value = evaluateConstant(entry.value);
       if (value == null) {
         return null;
       }
       if (!map.containsKey(key.value)) {
         keyValues.add(key.value);
       } else {
-        compiler.reportWarningMessage(
+        reporter.reportWarningMessage(
             entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
       }
       keyExpressions.add(key.expression);
       valueExpressions.add(value.expression);
       map[key.value] = value.value;
     }
     InterfaceType type = elements.getType(node);
     return new AstConstant(context, node,
         new MapConstantExpression(type, keyExpressions, valueExpressions),
         constantSystem.createMap(
@@ skipping 154 matching lines @@
           result = new AstConstant(context, send,
               new VariableConstantExpression(element),
               handler.getConstantValue(variableExpression));
         }
       }
       if (result == null) {
         return signalNotCompileTimeConstant(send);
       }
       if (isDeferredUse(send)) {
         if (isEvaluatingConstant) {
-          compiler.reportErrorMessage(
+          reporter.reportErrorMessage(
               send, MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
         }
         PrefixElement prefix =
             compiler.deferredLoadTask.deferredPrefixElement(send, elements);
         result = new AstConstant(context, send,
             new DeferredConstantExpression(result.expression, prefix),
             new DeferredConstantValue(result.value, prefix));
         compiler.deferredLoadTask.registerConstantDeferredUse(
             result.value, prefix);
       }
@@ skipping 16 matching lines @@
     } else if (send.isPrefix) {
       assert(send.isOperator);
       AstConstant receiverConstant = evaluate(send.receiver);
       if (receiverConstant == null) {
         return null;
       }
       Operator node = send.selector;
       UnaryOperator operator = UnaryOperator.parse(node.source);
       UnaryOperation operation = constantSystem.lookupUnary(operator);
       if (operation == null) {
-        compiler.internalError(send.selector, "Unexpected operator.");
+        reporter.internalError(send.selector, "Unexpected operator.");
       }
       ConstantValue folded = operation.fold(receiverConstant.value);
       if (folded == null) {
         return signalNotCompileTimeConstant(send);
       }
       return new AstConstant(context, send,
           new UnaryConstantExpression(operator, receiverConstant.expression),
           folded);
     } else if (send.isOperator && !send.isPostfix) {
       assert(send.argumentCount() == 1);
@@ skipping 42 matching lines @@
     return signalNotCompileTimeConstant(send);
   }
 
   AstConstant visitConditional(Conditional node) {
     AstConstant condition = evaluate(node.condition);
     if (condition == null) {
       return null;
     } else if (!condition.value.isBool) {
       DartType conditionType = condition.value.getType(compiler.coreTypes);
       if (isEvaluatingConstant) {
-        compiler.reportErrorMessage(
+        reporter.reportErrorMessage(
             node.condition,
             MessageKind.NOT_ASSIGNABLE,
             {'fromType': conditionType,
              'toType': compiler.boolClass.rawType});
         return new ErroneousAstConstant(context, node);
       }
       return null;
     }
     AstConstant thenExpression = evaluate(node.thenExpression);
     AstConstant elseExpression = evaluate(node.elseExpression);
@@ skipping 28 matching lines @@
       ConstantExpression constant = handler.compileConstant(element);
       return new AstConstant.fromDefaultValue(
           element, constant, handler.getConstantValue(constant));
     }
     target.computeType(resolution);
 
     FunctionSignature signature = target.functionSignature;
     if (!callStructure.signatureApplies(signature)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           node, MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS,
           {'constructorName': name});
 
       return new List<AstConstant>.filled(
           target.functionSignature.parameterCount,
           new ErroneousAstConstant(context, node));
     }
     return callStructure.makeArgumentsList(
         arguments, target, compileArgument, compileDefaultValue);
   }
@@ skipping 83 matching lines @@
   }
 
   AstConstant createFromEnvironmentConstant(Node node, InterfaceType type,
       ConstructorElement constructor, CallStructure callStructure,
       List<AstConstant> normalizedArguments,
       List<AstConstant> concreteArguments) {
     var firstArgument = normalizedArguments[0].value;
     ConstantValue defaultValue = normalizedArguments[1].value;
 
     if (firstArgument.isNull) {
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
       return null;
     }
 
     if (!firstArgument.isString) {
       DartType type = defaultValue.getType(compiler.coreTypes);
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           normalizedArguments[0].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type,
            'toType': compiler.stringClass.rawType});
       return null;
     }
 
     if (constructor == compiler.intEnvironment &&
         !(defaultValue.isNull || defaultValue.isInt)) {
       DartType type = defaultValue.getType(compiler.coreTypes);
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type,
            'toType': compiler.intClass.rawType});
       return null;
     }
 
     if (constructor == compiler.boolEnvironment &&
         !(defaultValue.isNull || defaultValue.isBool)) {
       DartType type = defaultValue.getType(compiler.coreTypes);
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type,
            'toType': compiler.boolClass.rawType});
       return null;
     }
 
     if (constructor == compiler.stringEnvironment &&
         !(defaultValue.isNull || defaultValue.isString)) {
       DartType type = defaultValue.getType(compiler.coreTypes);
-      compiler.reportErrorMessage(
+      reporter.reportErrorMessage(
           normalizedArguments[1].node,
           MessageKind.NOT_ASSIGNABLE,
           {'fromType': type,
            'toType': compiler.stringClass.rawType});
       return null;
     }
 
     String name = firstArgument.primitiveValue.slowToString();
     String value = compiler.fromEnvironment(name);
 
@@ skipping 73 matching lines @@
         new ConstructedConstantValue(constructedType, fieldValues));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   AstConstant signalNotCompileTimeConstant(Node node,
       {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT}) {
     if (isEvaluatingConstant) {
-      compiler.reportErrorMessage(node, message);
+      reporter.reportErrorMessage(node, message);
 
       return new AstConstant(context, node, new ErroneousConstantExpression(),
           new NullConstantValue());
     }
     // Else we don't need to do anything. The final handler is only
     // optimistically trying to compile constants. So it is normal that we
     // sometimes see non-compile time constants.
     // Simply return [:null:] which is used to propagate a failing
     // compile-time compilation.
     return null;
@@ skipping 19 matching lines @@
         super(handler, _analyzeElementEagerly(compiler, constructor), compiler,
             isConst: true) {
     assert(invariant(constructor, constructor.isImplementation));
   }
 
   AstConstant visitSend(Send send) {
     Element element = elements[send];
     if (Elements.isLocal(element)) {
       AstConstant constant = definitions[element];
       if (constant == null) {
-        compiler.internalError(send, "Local variable without value.");
+        reporter.internalError(send, "Local variable without value.");
       }
       return constant;
     }
     return super.visitSend(send);
   }
 
   void potentiallyCheckType(TypedElement element, AstConstant constant) {
     if (compiler.enableTypeAssertions) {
       DartType elementType = element.type.substByContext(constructedType);
       DartType constantType = constant.value.getType(compiler.coreTypes);
       if (!constantSystem.isSubtype(
           compiler.types, constantType, elementType)) {
-        compiler.withCurrentElement(constant.element, () {
-          compiler.reportErrorMessage(
+        reporter.withCurrentElement(constant.element, () {
+          reporter.reportErrorMessage(
               constant.node,
               MessageKind.NOT_ASSIGNABLE,
               {'fromType': constantType,
                'toType': elementType});
         });
       }
     }
   }
 
   void updateFieldValue(Node node, TypedElement element, AstConstant constant) {
@@ skipping 105 matching lines @@
     }
   }
 
   /**
    * Simulates the execution of the [constructor] with the given
    * [arguments] to obtain the field values that need to be passed to the
    * native JavaScript constructor.
    */
   void evaluateConstructorFieldValues(List<AstConstant> arguments) {
     if (constructor.isErroneous) return;
-    compiler.withCurrentElement(constructor, () {
+    reporter.withCurrentElement(constructor, () {
       assignArgumentsToParameters(arguments);
       evaluateConstructorInitializers();
     });
   }
 
   /// Builds a normalized list of the constant values for each field in the
   /// inheritance chain of [classElement].
   Map<FieldElement, AstConstant> buildFieldConstants(
       ClassElement classElement) {
     Map<FieldElement, AstConstant> fieldConstants = <FieldElement, AstConstant>{
@@ skipping 62 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }