Report info messages together with their error, warning, or hint.

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/tasks.dart' show
     CompilerTask;
 import 'compiler.dart' show
     Compiler;
@@ skipping 203 matching lines @@
    * 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.reportError(node, MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS);
+        compiler.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.reportError(
+            compiler.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.reportError(node, MessageKind.NOT_ASSIGNABLE, {
-                'fromType': constantType,
-                'toType': elementType
-              });
+              compiler.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;
             }
           }
         }
       }
     }
     if (expression != null) {
@@ skipping 163 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.reportWarning(entry.key, MessageKind.EQUAL_MAP_ENTRY_KEY);
+        compiler.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(
             compiler, type, keyValues, map.values.toList()));
@@ skipping 153 matching lines @@
           result = new AstConstant(context, send,
               new VariableConstantExpression(element),
               handler.getConstantValue(variableExpression));
         }
       }
       if (result == null) {
         return signalNotCompileTimeConstant(send);
       }
       if (isDeferredUse(send)) {
         if (isEvaluatingConstant) {
-          error(send, MessageKind.DEFERRED_COMPILE_TIME_CONSTANT);
+          compiler.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);
       }
       return result;
@@ skipping 78 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.reportError(node.condition, MessageKind.NOT_ASSIGNABLE, {
-          'fromType': conditionType,
-          'toType': compiler.boolClass.rawType
-        });
+        compiler.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);
     if (thenExpression == null || elseExpression == null) {
       return null;
     }
     BoolConstantValue boolCondition = condition.value;
@@ skipping 24 matching lines @@
       ConstantExpression constant = handler.compileConstant(element);
       return new AstConstant.fromDefaultValue(
           element, constant, handler.getConstantValue(constant));
     }
     target.computeType(compiler);
 
     FunctionSignature signature = target.functionSignature;
     if (!callStructure.signatureApplies(signature)) {
       String name = Elements.constructorNameForDiagnostics(
           target.enclosingClass.name, target.name);
-      compiler.reportError(node, MessageKind.INVALID_CONSTRUCTOR_ARGUMENTS, {
-        'constructorName': name
-      });
+      compiler.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);
   }
 
   AstConstant visitNewExpression(NewExpression node) {
@@ skipping 81 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.reportError(
+      compiler.reportErrorMessage(
           normalizedArguments[0].node, MessageKind.NULL_NOT_ALLOWED);
       return null;
     }
 
     if (!firstArgument.isString) {
       DartType type = defaultValue.getType(compiler.coreTypes);
-      compiler.reportError(normalizedArguments[0].node,
-          MessageKind.NOT_ASSIGNABLE, {
-        'fromType': type,
-        'toType': compiler.stringClass.rawType
-      });
+      compiler.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.reportError(normalizedArguments[1].node,
-          MessageKind.NOT_ASSIGNABLE, {
-        'fromType': type,
-        'toType': compiler.intClass.rawType
-      });
+      compiler.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.reportError(normalizedArguments[1].node,
-          MessageKind.NOT_ASSIGNABLE, {
-        'fromType': type,
-        'toType': compiler.boolClass.rawType
-      });
+      compiler.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.reportError(normalizedArguments[1].node,
-          MessageKind.NOT_ASSIGNABLE, {
-        'fromType': type,
-        'toType': compiler.stringClass.rawType
-      });
+      compiler.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);
 
     AstConstant createEvaluatedConstant(ConstantValue value) {
       ConstantExpression expression;
       ConstantExpression name = concreteArguments[0].expression;
       ConstantExpression defaultValue;
@@ skipping 66 matching lines @@
     return new AstConstant(context, node, new ConstructedConstantExpression(
             type, constructor, callStructure,
             concreteArguments.map((e) => e.expression).toList()),
         new ConstructedConstantValue(constructedType, fieldValues));
   }
 
   AstConstant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
-  error(Node node, MessageKind message) {
-    // TODO(floitsch): get the list of constants that are currently compiled
-    // and present some kind of stack-trace.
-    compiler.reportError(node, message);
-  }
-
   AstConstant signalNotCompileTimeConstant(Node node,
       {MessageKind message: MessageKind.NOT_A_COMPILE_TIME_CONSTANT}) {
     if (isEvaluatingConstant) {
-      error(node, message);
+      compiler.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 33 matching lines @@
     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.reportError(constant.node, MessageKind.NOT_ASSIGNABLE, {
-            'fromType': constantType,
-            'toType': elementType
-          });
+          compiler.reportErrorMessage(
+              constant.node,
+              MessageKind.NOT_ASSIGNABLE,
+              {'fromType': constantType,
+               'toType': elementType});
         });
       }
     }
   }
 
   void updateFieldValue(Node node, TypedElement element, AstConstant constant) {
     potentiallyCheckType(element, constant);
     fieldValues[element] = constant;
   }
 
@@ skipping 184 matching lines @@
 class _CompilerEnvironment implements Environment {
   final Compiler compiler;
 
   _CompilerEnvironment(this.compiler);
 
   @override
   String readFromEnvironment(String name) {
     return compiler.fromEnvironment(name);
   }
 }