Use named arguments for messages.

sdk/lib/_internal/compiler/implementation/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.
 
 part of dart2js;
 
 /**
  * The [ConstantHandler] keeps track of compile-time constants,
  * initializations of global and static fields, and default values of
  * optional parameters.
@@ skipping 130 matching lines @@
       // Initializers for parameters must be const.
       isConst = isConst || element.modifiers.isConst()
           || !Elements.isStaticOrTopLevel(element);
       if (!isConst && lazyStatics.contains(element)) return null;
 
       Node node = element.parseNode(compiler);
       if (pendingVariables.contains(element)) {
         if (isConst) {
           MessageKind kind = MessageKind.CYCLIC_COMPILE_TIME_CONSTANTS;
           compiler.reportError(node,
-                               new CompileTimeConstantError(kind, const []));
+                               new CompileTimeConstantError(kind));
         } else {
           lazyStatics.add(element);
           return null;
         }
       }
       pendingVariables.add(element);
 
       SendSet assignment = node.asSendSet();
       Constant value;
       if (assignment == null) {
         // No initial value.
         value = new NullConstant();
       } else {
         Node right = assignment.arguments.head;
         value =
             compileNodeWithDefinitions(right, definitions, isConst: isConst);
         if (compiler.enableTypeAssertions
             && value != null
             && element.isField()) {
           DartType elementType = element.computeType(compiler);
           DartType constantType = value.computeType(compiler);
           if (elementType.isMalformed || constantType.isMalformed ||
               !constantSystem.isSubtype(compiler, constantType, elementType)) {
             if (isConst) {
-              MessageKind kind = MessageKind.NOT_ASSIGNABLE;
               compiler.reportError(node, new CompileTimeConstantError(
-                  kind, [elementType, constantType]));
+                  MessageKind.NOT_ASSIGNABLE,
+                  {'fromType': elementType, 'toType': constantType}));
             } else {
               // If the field can be lazily initialized, we will throw
               // the exception at runtime.
               value = null;
             }
           }
         }
       }
       if (value != null) {
         initialVariableValues[element] = value;
@@ skipping 158 matching lines @@
     }
     List<StringConstant> keys = <StringConstant>[];
     Map<StringConstant, Constant> map = new Map<StringConstant, Constant>();
     for (Link<Node> link = node.entries.nodes;
          !link.isEmpty;
          link = link.tail) {
       LiteralMapEntry entry = link.head;
       Constant key = evaluateConstant(entry.key);
       if (!key.isString() || entry.key.asStringNode() == null) {
         MessageKind kind = MessageKind.KEY_NOT_A_STRING_LITERAL;
-        compiler.reportError(entry.key, new ResolutionError(kind, const []));
+        compiler.reportError(entry.key, new ResolutionError(kind));
       }
       StringConstant keyConstant = key;
       if (!map.containsKey(key)) keys.add(key);
       map[key] = evaluateConstant(entry.value);
     }
     List<Constant> values = <Constant>[];
     Constant protoValue = null;
     for (StringConstant key in keys) {
       if (key.value == MapConstant.PROTO_PROPERTY) {
         protoValue = map[key];
@@ skipping 93 matching lines @@
         }
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
         return makeTypeConstant(element);
       } else if (send.receiver != null) {
         // Fall through to error handling.
       } else if (!Elements.isUnresolved(element)
                  && element.isVariable()
                  && element.modifiers.isConst()) {
         Constant result = handler.compileConstant(element);
-        if (result != null) return result; 
+        if (result != null) return result;
       }
       return signalNotCompileTimeConstant(send);
     } else if (send.isCall) {
       if (identical(element, compiler.identicalFunction)
           && send.argumentCount() == 2) {
         Constant left = evaluate(send.argumentsNode.nodes.head);
         Constant right = evaluate(send.argumentsNode.nodes.tail.head);
         Constant result = constantSystem.identity.fold(left, right);
         if (result != null) return result;
       } else if (Elements.isClass(element) || Elements.isTypedef(element)) {
@@ skipping 135 matching lines @@
     Function compileConstant = handler.compileConstant;
     bool succeeded = selector.addArgumentsToList(arguments,
                                                  compiledArguments,
                                                  target,
                                                  compileArgument,
                                                  compileConstant,
                                                  compiler);
     if (!succeeded) {
       MessageKind kind = MessageKind.INVALID_ARGUMENTS;
       compiler.reportError(node,
-          new CompileTimeConstantError(kind, [target.name.slowToString()]));
+          new CompileTimeConstantError(kind, {'methodName': target.name}));
     }
     return compiledArguments;
   }
 
   Constant visitNewExpression(NewExpression node) {
     if (!node.isConst()) {
       return signalNotCompileTimeConstant(node);
     }
 
     Send send = node.send;
@@ skipping 27 matching lines @@
   }
 
   Constant visitParenthesizedExpression(ParenthesizedExpression node) {
     return node.expression.accept(this);
   }
 
   error(Node node) {
     // TODO(floitsch): get the list of constants that are currently compiled
     // and present some kind of stack-trace.
     MessageKind kind = MessageKind.NOT_A_COMPILE_TIME_CONSTANT;
-    compiler.reportError(node, new CompileTimeConstantError(kind, const []));
+    compiler.reportError(node, new CompileTimeConstantError(kind));
   }
 
   Constant signalNotCompileTimeConstant(Node node) {
     if (isEvaluatingConstant) {
       error(node);
     }
     // 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;
   }
 }
 
 class TryCompileTimeConstantEvaluator extends CompileTimeConstantEvaluator {
   TryCompileTimeConstantEvaluator(ConstantHandler handler,
                                   TreeElements elements,
                                   Compiler compiler)
       : super(handler, elements, compiler, isConst: true);
 
   error(Node node) {
     // Just fail without reporting it anywhere.
     throw new CompileTimeConstantError(
-        MessageKind.NOT_A_COMPILE_TIME_CONSTANT, const []);
+        MessageKind.NOT_A_COMPILE_TIME_CONSTANT);
   }
 }
 
 class ConstructorEvaluator extends CompileTimeConstantEvaluator {
   final FunctionElement constructor;
   final Map<Element, Constant> definitions;
   final Map<Element, Constant> fieldValues;
 
   /**
    * Documentation wanted -- johnniwinther
@@ skipping 27 matching lines @@
   }
 
   void potentiallyCheckType(Node node, Element element, Constant constant) {
     if (compiler.enableTypeAssertions) {
       DartType elementType = element.computeType(compiler);
       DartType constantType = constant.computeType(compiler);
       // TODO(ngeoffray): Handle type parameters.
       if (elementType.element.isTypeVariable()) return;
       if (elementType.isMalformed || constantType.isMalformed ||
           !constantSystem.isSubtype(compiler, constantType, elementType)) {
-        MessageKind kind = MessageKind.NOT_ASSIGNABLE;
         compiler.reportError(node, new CompileTimeConstantError(
-            kind, [elementType, constantType]));
+            MessageKind.NOT_ASSIGNABLE,
+            {'fromType': elementType, 'toType': constantType}));
       }
     }
   }
 
   void updateFieldValue(Node node, Element element, Constant constant) {
     potentiallyCheckType(node, element, constant);
     fieldValues[element] = constant;
   }
 
   /**
@@ skipping 116 matching lines @@
             // Use the default value.
             fieldValue = handler.compileConstant(field);
           }
           jsNewArguments.add(fieldValue);
         },
         includeBackendMembers: true,
         includeSuperMembers: true);
     return jsNewArguments;
   }
 }