Use named arguments for messages.

sdk/lib/_internal/compiler/implementation/resolution/members.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 resolution;
 
 abstract class TreeElements {
   Element operator[](Node node);
   Selector getSelector(Send send);
   DartType getType(Node node);
@@ skipping 136 matching lines @@
       Element patchParameter = patchParameters.head;
       // Hack: Use unparser to test parameter equality. This only works because
       // we are restricting patch uses and the approach cannot be used
       // elsewhere.
       String originParameterText =
           originParameter.parseNode(compiler).toString();
       String patchParameterText =
           patchParameter.parseNode(compiler).toString();
       if (originParameterText != patchParameterText) {
         error(originParameter.parseNode(compiler),
-            MessageKind.PATCH_PARAMETER_MISMATCH,
-            [origin.name, originParameterText, patchParameterText]);
+              MessageKind.PATCH_PARAMETER_MISMATCH,
+              {'methodName': origin.name,
+               'originParameter': originParameterText,
+               'patchParameter': patchParameterText});
       }
 
       originParameters = originParameters.tail;
       patchParameters = patchParameters.tail;
     }
   }
 
   void checkMatchingPatchSignatures(FunctionElement origin,
                                     FunctionElement patch) {
     // TODO(johnniwinther): Show both origin and patch locations on errors.
     FunctionExpression originTree = compiler.withCurrentElement(origin, () {
       return origin.parseNode(compiler);
     });
     FunctionSignature originSignature = compiler.withCurrentElement(origin, () {
       return origin.computeSignature(compiler);
     });
     FunctionExpression patchTree = compiler.withCurrentElement(patch, () {
       return patch.parseNode(compiler);
     });
     FunctionSignature patchSignature = compiler.withCurrentElement(patch, () {
       return patch.computeSignature(compiler);
     });
 
     if (originSignature.returnType != patchSignature.returnType) {
       compiler.withCurrentElement(patch, () {
         Node errorNode =
             patchTree.returnType != null ? patchTree.returnType : patchTree;
-        error(errorNode, MessageKind.PATCH_RETURN_TYPE_MISMATCH, [origin.name,
-              originSignature.returnType, patchSignature.returnType]);
+        error(errorNode, MessageKind.PATCH_RETURN_TYPE_MISMATCH,
+              {'methodName': origin.name,
+               'originReturnType': originSignature.returnType,
+               'patchReturnType': patchSignature.returnType});
       });
     }
     if (originSignature.requiredParameterCount !=
         patchSignature.requiredParameterCount) {
       compiler.withCurrentElement(patch, () {
         error(patchTree,
               MessageKind.PATCH_REQUIRED_PARAMETER_COUNT_MISMATCH,
-              [origin.name, originSignature.requiredParameterCount,
-               patchSignature.requiredParameterCount]);
+              {'methodName': origin.name,
+               'originParameterCount': originSignature.requiredParameterCount,
+               'patchParameterCount': patchSignature.requiredParameterCount});
       });
     } else {
       checkMatchingPatchParameters(origin,
                                    originSignature.requiredParameters,
                                    patchSignature.requiredParameters);
     }
     if (originSignature.optionalParameterCount != 0 &&
         patchSignature.optionalParameterCount != 0) {
       if (originSignature.optionalParametersAreNamed !=
           patchSignature.optionalParametersAreNamed) {
         compiler.withCurrentElement(patch, () {
           error(patchTree,
-              MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH,
-              [origin.name]);
+                MessageKind.PATCH_OPTIONAL_PARAMETER_NAMED_MISMATCH,
+                {'methodName': origin.name});
         });
       }
     }
     if (originSignature.optionalParameterCount !=
         patchSignature.optionalParameterCount) {
       compiler.withCurrentElement(patch, () {
         error(patchTree,
               MessageKind.PATCH_OPTIONAL_PARAMETER_COUNT_MISMATCH,
-              [origin.name, originSignature.optionalParameterCount,
-               patchSignature.optionalParameterCount]);
+              {'methodName': origin.name,
+               'originParameterCount': originSignature.optionalParameterCount,
+               'patchParameterCount': patchSignature.optionalParameterCount});
       });
     } else {
       checkMatchingPatchParameters(origin,
                                    originSignature.optionalParameters,
                                    patchSignature.optionalParameters);
     }
   }
 
   TreeElements resolveMethodElement(FunctionElement element) {
     assert(invariant(element, element.isDeclaration));
@@ skipping 73 matching lines @@
     visitor.visit(body);
   }
 
   void resolveConstructorImplementation(FunctionElement constructor,
                                         FunctionExpression node) {
     if (!identical(constructor.defaultImplementation, constructor)) return;
     ClassElement intrface = constructor.getEnclosingClass();
     if (!intrface.isInterface()) return;
     DartType defaultType = intrface.defaultClass;
     if (defaultType == null) {
-      error(node, MessageKind.NO_DEFAULT_CLASS, [intrface.name]);
+      error(node, MessageKind.NO_DEFAULT_CLASS,
+            {'interfaceName': intrface.name});
     }
     ClassElement defaultClass = defaultType.element;
     defaultClass.ensureResolved(compiler);
     assert(defaultClass.resolutionState == STATE_DONE);
     assert(defaultClass.supertypeLoadState == STATE_DONE);
     if (defaultClass.isInterface()) {
       error(node, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
-            [defaultClass.name]);
+            {'interfaceName': defaultClass.name});
     }
     // We have now established the following:
     // [intrface] is an interface, let's say "MyInterface".
     // [defaultClass] is a class, let's say "MyClass".
 
     Selector selector;
     // If the default class implements the interface then we must use the
     // default class' name. Otherwise we look for a factory with the name
     // of the interface.
     if (defaultClass.implementsInterface(intrface)) {
@@ skipping 20 matching lines @@
       constructor.defaultImplementation =
           defaultClass.lookupFactoryConstructor(selector);
     }
     if (constructor.defaultImplementation == null) {
       // We failed to find a constructor named either
       // "MyInterface.name" or "MyClass.name".
       // TODO(aprelev@gmail.com): Use constructorNameForDiagnostics in
       // the error message below.
       error(node,
             MessageKind.CANNOT_FIND_CONSTRUCTOR2,
-            [selector.name, defaultClass.name]);
+            {'constructorName': selector.name, 'className': defaultClass.name});
     }
   }
 
   TreeElements resolveField(VariableElement element) {
     Node tree = element.parseNode(compiler);
     if(element.modifiers.isStatic() && element.variables.isTopLevel()) {
       error(element.modifiers.getStatic(),
             MessageKind.TOP_LEVEL_VARIABLE_DECLARED_STATIC);
     }
     ResolverVisitor visitor = visitorFor(element);
@@ skipping 35 matching lines @@
    *
    * Warning: do not call this method directly. It should only be
    * called by [resolveClass] and [ClassSupertypeResolver].
    */
   void loadSupertypes(ClassElement cls, Spannable from) {
     compiler.withCurrentElement(cls, () => measure(() {
       if (cls.supertypeLoadState == STATE_DONE) return;
       if (cls.supertypeLoadState == STATE_STARTED) {
         compiler.reportMessage(
           compiler.spanFromSpannable(from),
-          MessageKind.CYCLIC_CLASS_HIERARCHY.error([cls.name]),
+          MessageKind.CYCLIC_CLASS_HIERARCHY.error({'className': cls.name}),
           Diagnostic.ERROR);
         cls.supertypeLoadState = STATE_DONE;
         cls.allSupertypes = const Link<DartType>().prepend(
             compiler.objectClass.computeType(compiler));
         // TODO(ahe): We should also set cls.supertype here to avoid
         // creating a malformed class hierarchy.
         return;
       }
       cls.supertypeLoadState = STATE_STARTED;
       compiler.withCurrentElement(cls, () {
@@ skipping 91 matching lines @@
     }
   }
 
   void checkMixinApplication(MixinApplicationElement mixinApplication) {
     Modifiers modifiers = mixinApplication.modifiers;
     int illegalFlags = modifiers.flags & ~Modifiers.FLAG_ABSTRACT;
     if (illegalFlags != 0) {
       Modifiers illegalModifiers = new Modifiers.withFlags(null, illegalFlags);
       CompilationError error =
           MessageKind.ILLEGAL_MIXIN_APPLICATION_MODIFIERS.error(
-              [illegalModifiers]);
+              {'modifiers': illegalModifiers});
       compiler.reportMessage(compiler.spanFromSpannable(modifiers),
                              error, Diagnostic.ERROR);
     }
 
     // In case of cyclic mixin applications, the mixin chain will have
     // been cut. If so, we have already reported the error to the
     // user so we just return from here.
     ClassElement mixin = mixinApplication.mixin;
     if (mixin == null) return;
 
@@ skipping 24 matching lines @@
     });
   }
 
   void checkMixinSuperUses(TreeElements resolutionTree,
                            MixinApplicationElement mixinApplication,
                            ClassElement mixin) {
     if (resolutionTree == null) return;
     Set<Node> superUses = resolutionTree.superUses;
     if (superUses.isEmpty) return;
     CompilationError error = MessageKind.ILLEGAL_MIXIN_WITH_SUPER.error(
-        [mixin.name]);
+        {'className': mixin.name});
     compiler.reportMessage(compiler.spanFromElement(mixinApplication),
                            error, Diagnostic.ERROR);
     // Show the user the problematic uses of 'super' in the mixin.
     for (Node use in superUses) {
       CompilationError error = MessageKind.ILLEGAL_MIXIN_SUPER_USE.error();
       compiler.reportMessage(compiler.spanFromNode(use),
                              error, Diagnostic.INFO);
     }
   }
 
@@ skipping 17 matching lines @@
         if (member.isConstructor()) {
           final mismatchedFlagsBits =
               member.modifiers.flags &
               (Modifiers.FLAG_STATIC | Modifiers.FLAG_ABSTRACT);
           if (mismatchedFlagsBits != 0) {
             final mismatchedFlags =
                 new Modifiers.withFlags(null, mismatchedFlagsBits);
             compiler.reportMessage(
                 compiler.spanFromElement(member),
                 MessageKind.ILLEGAL_CONSTRUCTOR_MODIFIERS.error(
-                    [mismatchedFlags]),
+                    {'modifiers': mismatchedFlags}),
                 Diagnostic.ERROR);
           }
           checkConstructorNameHack(holder, member);
         }
         checkAbstractField(member);
         checkValidOverride(member, cls.lookupSuperMember(member.name));
         checkUserDefinableOperator(member);
       });
     });
   }
@@ skipping 13 matching lines @@
 
     // If the name could not be deconstructed, this is is from a
     // factory method from a deprecated interface implementation.
     if (name == null) return;
 
     Element otherMember = holder.lookupLocalMember(name);
     if (otherMember != null) {
       if (compiler.onDeprecatedFeature(member, 'conflicting constructor')) {
         compiler.reportMessage(
             compiler.spanFromElement(otherMember),
-            MessageKind.GENERIC.error(['This member conflicts with a'
-                                       ' constructor.']),
+            MessageKind.GENERIC.error({'text': 'This member conflicts with a'
+                                               ' constructor.'}),
             Diagnostic.INFO);
       }
     }
   }
 
   void checkAbstractField(Element member) {
     // Only check for getters. The test can only fail if there is both a setter
     // and a getter with the same name, and we only need to check each abstract
     // field once, so we just ignore setters.
     if (!member.isGetter()) return;
@@ skipping 12 matching lines @@
 
     if (field.getter == null) return;
     if (field.setter == null) return;
     int getterFlags = field.getter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     int setterFlags = field.setter.modifiers.flags | Modifiers.FLAG_ABSTRACT;
     if (!identical(getterFlags, setterFlags)) {
       final mismatchedFlags =
         new Modifiers.withFlags(null, getterFlags ^ setterFlags);
       compiler.reportMessage(
           compiler.spanFromElement(field.getter),
-          MessageKind.GETTER_MISMATCH.error([mismatchedFlags]),
+          MessageKind.GETTER_MISMATCH.error({'modifiers': mismatchedFlags}),
           Diagnostic.ERROR);
       compiler.reportMessage(
           compiler.spanFromElement(field.setter),
-          MessageKind.SETTER_MISMATCH.error([mismatchedFlags]),
+          MessageKind.SETTER_MISMATCH.error({'modifiers': mismatchedFlags}),
           Diagnostic.ERROR);
     }
   }
 
   void checkUserDefinableOperator(Element member) {
     FunctionElement function = member.asFunctionElement();
     if (function == null) return;
     String value = member.name.stringValue;
     if (value == null) return;
     if (!(isUserDefinableOperator(value) || identical(value, 'unary-'))) return;
@@ skipping 31 matching lines @@
       Node errorNode = node;
       if (node.parameters != null) {
         if (signature.requiredParameterCount < requiredParameterCount) {
           errorNode = node.parameters;
         } else {
           errorNode = node.parameters.nodes.skip(requiredParameterCount).head;
         }
       }
       compiler.reportMessage(
           compiler.spanFromSpannable(errorNode),
-          messageKind.error([function.name]),
+          messageKind.error({'operatorName': function.name}),
           Diagnostic.ERROR);
     }
     if (signature.optionalParameterCount != 0) {
       Node errorNode =
           node.parameters.nodes.skip(signature.requiredParameterCount).head;
       if (signature.optionalParametersAreNamed) {
         compiler.reportMessage(
             compiler.spanFromSpannable(errorNode),
-            MessageKind.OPERATOR_NAMED_PARAMETERS.error([function.name]),
+            MessageKind.OPERATOR_NAMED_PARAMETERS.error(
+                {'operatorName': function.name}),
             Diagnostic.ERROR);
       } else {
         compiler.reportMessage(
             compiler.spanFromSpannable(errorNode),
-            MessageKind.OPERATOR_OPTIONAL_PARAMETERS.error([function.name]),
+            MessageKind.OPERATOR_OPTIONAL_PARAMETERS.error(
+                {'operatorName': function.name}),
             Diagnostic.ERROR);
       }
     }
   }
 
   reportErrorWithContext(Element errorneousElement,
                          MessageKind errorMessage,
                          Element contextElement,
                          MessageKind contextMessage) {
     compiler.reportMessage(
         compiler.spanFromElement(errorneousElement),
-        errorMessage.error([contextElement.name,
-                            contextElement.getEnclosingClass().name]),
+        errorMessage.error(
+            {'memberName': contextElement.name,
+             'className': contextElement.getEnclosingClass().name}),
         Diagnostic.ERROR);
     compiler.reportMessage(
         compiler.spanFromElement(contextElement),
         contextMessage.error(),
         Diagnostic.INFO);
   }
 
   void checkValidOverride(Element member, Element superMember) {
     if (superMember == null) return;
     if (member.modifiers.isStatic()) {
@@ skipping 89 matching lines @@
       ResolverVisitor visitor =
           visitorFor(annotation.annotatedElement.enclosingElement);
       node.accept(visitor);
       annotation.value = compiler.metadataHandler.compileNodeWithDefinitions(
           node, visitor.mapping, isConst: true);
 
       annotation.resolutionState = STATE_DONE;
     }));
   }
 
-  error(Node node, MessageKind kind, [arguments = const []]) {
+  error(Node node, MessageKind kind, [arguments = const {}]) {
     ResolutionError message = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
 }
 
 class InitializerResolver {
   final ResolverVisitor visitor;
   final Map<SourceString, Node> initialized;
   Link<Node> initializers;
   bool hasSuper;
 
   InitializerResolver(this.visitor)
     : initialized = new Map<SourceString, Node>(), hasSuper = false;
 
-  error(Node node, MessageKind kind, [arguments = const []]) {
+  error(Node node, MessageKind kind, [arguments = const {}]) {
     visitor.error(node, kind, arguments);
   }
 
-  warning(Node node, MessageKind kind, [arguments = const []]) {
+  warning(Node node, MessageKind kind, [arguments = const {}]) {
     visitor.warning(node, kind, arguments);
   }
 
   bool isFieldInitializer(SendSet node) {
     if (node.selector.asIdentifier() == null) return false;
     if (node.receiver == null) return true;
     if (node.receiver.asIdentifier() == null) return false;
     return node.receiver.asIdentifier().isThis();
   }
 
   void checkForDuplicateInitializers(SourceString name, Node init) {
     if (initialized.containsKey(name)) {
-      error(init, MessageKind.DUPLICATE_INITIALIZER, [name]);
-      warning(initialized[name], MessageKind.ALREADY_INITIALIZED, [name]);
+      error(init, MessageKind.DUPLICATE_INITIALIZER, {'fieldName': name});
+      warning(initialized[name], MessageKind.ALREADY_INITIALIZED,
+              {'fieldName': name});
     }
     initialized[name] = init;
   }
 
   void resolveFieldInitializer(FunctionElement constructor, SendSet init) {
     // init is of the form [this.]field = value.
     final Node selector = init.selector;
     final SourceString name = selector.asIdentifier().source;
     // Lookup target field.
     Element target;
     if (isFieldInitializer(init)) {
       target = constructor.getEnclosingClass().lookupLocalMember(name);
       if (target == null) {
-        error(selector, MessageKind.CANNOT_RESOLVE, [name]);
+        error(selector, MessageKind.CANNOT_RESOLVE, {'name': name});
       } else if (target.kind != ElementKind.FIELD) {
-        error(selector, MessageKind.NOT_A_FIELD, [name]);
+        error(selector, MessageKind.NOT_A_FIELD, {'fieldName': name});
       } else if (!target.isInstanceMember()) {
-        error(selector, MessageKind.INIT_STATIC_FIELD, [name]);
+        error(selector, MessageKind.INIT_STATIC_FIELD, {'fieldName': name});
       }
     } else {
       error(init, MessageKind.INVALID_RECEIVER_IN_INITIALIZER);
     }
     visitor.useElement(init, target);
     visitor.world.registerStaticUse(target);
     checkForDuplicateInitializers(name, init);
     // Resolve initializing value.
     visitor.visitInStaticContext(init.arguments.head);
   }
@@ skipping 92 matching lines @@
       Selector constructorSelector) {
     if (lookedupConstructor == null
         || !lookedupConstructor.isGenerativeConstructor()) {
       var fullConstructorName =
           visitor.compiler.resolver.constructorNameForDiagnostics(
               className,
               constructorSelector.name);
       MessageKind kind = isImplicitSuperCall
           ? MessageKind.CANNOT_RESOLVE_CONSTRUCTOR_FOR_IMPLICIT
           : MessageKind.CANNOT_RESOLVE_CONSTRUCTOR;
-      error(diagnosticNode, kind, [fullConstructorName]);
+      error(diagnosticNode, kind, {'constructorName': fullConstructorName});
     } else {
       if (!call.applies(lookedupConstructor, visitor.compiler)) {
         MessageKind kind = isImplicitSuperCall
                            ? MessageKind.NO_MATCHING_CONSTRUCTOR_FOR_IMPLICIT
                            : MessageKind.NO_MATCHING_CONSTRUCTOR;
         error(diagnosticNode, kind);
       }
     }
   }
 
@@ skipping 78 matching lines @@
   R visitNode(Node node) {
     cancel(node,
            'internal error: Unhandled node: ${node.getObjectDescription()}');
   }
 
   R visitEmptyStatement(Node node) => null;
 
   /** Convenience method for visiting nodes that may be null. */
   R visit(Node node) => (node == null) ? null : node.accept(this);
 
-  void error(Node node, MessageKind kind, [arguments = const []]) {
+  void error(Node node, MessageKind kind, [Map arguments = const {}]) {
     ResolutionError message  = new ResolutionError(kind, arguments);
     compiler.reportError(node, message);
   }
 
-  void warning(Node node, MessageKind kind, [arguments = const []]) {
+  void warning(Node node, MessageKind kind, [Map arguments = const {}]) {
     ResolutionWarning message  = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, message);
   }
 
   void cancel(Node node, String message) {
     compiler.cancel(message, node: node);
   }
 
   void internalError(Node node, String message) {
     compiler.internalError(message, node: node);
@@ skipping 139 matching lines @@
       }
     }
   }
 
   // TODO(johnniwinther): Change  [onFailure] and [whenResolved] to use boolean
   // flags instead of closures.
   DartType resolveTypeAnnotation(
       TypeAnnotation node,
       Scope scope,
       Element enclosingElement,
-      {onFailure(Node node, MessageKind kind, [List arguments]),
+      {onFailure(Node node, MessageKind kind, [Map arguments]),
        whenResolved(Node node, DartType type)}) {
     if (onFailure == null) {
       onFailure = (n, k, [arguments]) {};
     }
     if (whenResolved == null) {
       whenResolved = (n, t) {};
     }
     if (scope == null) {
       compiler.internalError('resolveTypeAnnotation: no scope specified');
     }
@@ skipping 12 matching lines @@
       prefixName = send.receiver.asIdentifier().source;
       typeName = send.selector.asIdentifier();
     } else {
       typeName = node.typeName.asIdentifier();
     }
 
     Element element = resolveTypeName(scope, prefixName, typeName);
     DartType type;
 
     DartType reportFailureAndCreateType(MessageKind messageKind,
-                                        List messageArguments) {
+                                        Map messageArguments) {
       onFailure(node, messageKind, messageArguments);
       var erroneousElement = new ErroneousElementX(
           messageKind, messageArguments, typeName.source, enclosingElement);
       var arguments = new LinkBuilder<DartType>();
       resolveTypeArguments(
           node, null, enclosingElement,
           scope, onFailure, whenResolved, arguments);
       return new MalformedType(erroneousElement, null, arguments.toLink());
     }
 
     DartType checkNoTypeArguments(DartType type) {
       var arguments = new LinkBuilder<DartType>();
       bool hashTypeArgumentMismatch = resolveTypeArguments(
           node, const Link<DartType>(), enclosingElement,
           scope, onFailure, whenResolved, arguments);
       if (hashTypeArgumentMismatch) {
         type = new MalformedType(
             new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
-                [node], typeName.source, enclosingElement),
+                {'type': node}, typeName.source, enclosingElement),
                 type, arguments.toLink());
       }
       return type;
     }
 
     if (element == null) {
       type = reportFailureAndCreateType(
-          MessageKind.CANNOT_RESOLVE_TYPE, [node.typeName]);
+          MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node.typeName});
     } else if (element.isAmbiguous()) {
       AmbiguousElement ambiguous = element;
       type = reportFailureAndCreateType(
           ambiguous.messageKind, ambiguous.messageArguments);
     } else if (!element.impliesType()) {
       type = reportFailureAndCreateType(
-          MessageKind.NOT_A_TYPE, [node.typeName]);
+          MessageKind.NOT_A_TYPE, {'node': node.typeName});
     } else {
       if (identical(element, compiler.types.voidType.element) ||
           identical(element, compiler.types.dynamicType.element)) {
         type = checkNoTypeArguments(element.computeType(compiler));
       } else if (element.isClass()) {
         ClassElement cls = element;
         compiler.resolver._ensureClassWillBeResolved(cls);
         element.computeType(compiler);
         var arguments = new LinkBuilder<DartType>();
         bool hashTypeArgumentMismatch = resolveTypeArguments(
             node, cls.typeVariables, enclosingElement,
             scope, onFailure, whenResolved, arguments);
         if (hashTypeArgumentMismatch) {
           type = new MalformedType(
               new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
-                  [node], typeName.source, enclosingElement),
+                  {'type': node}, typeName.source, enclosingElement),
               new InterfaceType(cls.declaration, arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = cls.rawType;
           } else {
             type = new InterfaceType(cls.declaration, arguments.toLink());
           }
         }
       } else if (element.isTypedef()) {
         TypedefElement typdef = element;
         // TODO(ahe): Should be [ensureResolved].
         compiler.resolveTypedef(typdef);
         var arguments = new LinkBuilder<DartType>();
         bool hashTypeArgumentMismatch = resolveTypeArguments(
             node, typdef.typeVariables, enclosingElement,
             scope, onFailure, whenResolved, arguments);
         if (hashTypeArgumentMismatch) {
           type = new MalformedType(
               new ErroneousElementX(MessageKind.TYPE_ARGUMENT_COUNT_MISMATCH,
-                  [node], typeName.source, enclosingElement),
+                  {'type': node}, typeName.source, enclosingElement),
               new TypedefType(typdef, arguments.toLink()));
         } else {
           if (arguments.isEmpty) {
             type = typdef.rawType;
           } else {
            type = new TypedefType(typdef, arguments.toLink());
           }
         }
       } else if (element.isTypeVariable()) {
         if (enclosingElement.isInStaticMember()) {
           compiler.reportWarning(node,
               MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER.message(
-                  [node]));
+                  {'typeVariableName': node}));
           type = new MalformedType(
               new ErroneousElementX(
                   MessageKind.TYPE_VARIABLE_WITHIN_STATIC_MEMBER,
-                  [node], typeName.source, enclosingElement),
+                  {'typeVariableName': node},
+                  typeName.source, enclosingElement),
                   element.computeType(compiler));
         } else {
           type = element.computeType(compiler);
         }
         type = checkNoTypeArguments(type);
       } else {
         compiler.cancel("unexpected element kind ${element.kind}",
                         node: node);
       }
     }
@@ skipping 80 matching lines @@
       inCatchBlock = false,
       super(compiler);
 
   ResolutionEnqueuer get world => compiler.enqueuer.resolution;
 
   Element lookup(Node node, SourceString name) {
     Element result = scope.lookup(name);
     if (!Elements.isUnresolved(result)) {
       if (!inInstanceContext && result.isInstanceMember()) {
         compiler.reportMessage(compiler.spanFromSpannable(node),
-            MessageKind.NO_INSTANCE_AVAILABLE.error([name]),
+            MessageKind.NO_INSTANCE_AVAILABLE.error({'name': name}),
             Diagnostic.ERROR);
         return new ErroneousElementX(MessageKind.NO_INSTANCE_AVAILABLE,
-                                    [name],
-                                    name, enclosingElement);
+                                     {'name': name},
+                                     name, enclosingElement);
       } else if (result.isAmbiguous()) {
         AmbiguousElement ambiguous = result;
         compiler.reportMessage(compiler.spanFromSpannable(node),
             ambiguous.messageKind.error(ambiguous.messageArguments),
             Diagnostic.ERROR);
         return new ErroneousElementX(ambiguous.messageKind,
-                                    ambiguous.messageArguments,
-                                    name, enclosingElement);
+                                     ambiguous.messageArguments,
+                                     name, enclosingElement);
       }
     }
     return result;
   }
 
   // Create, or reuse an already created, statement element for a statement.
   TargetElement getOrCreateTargetElement(Node statement) {
     TargetElement element = mapping[statement];
     if (element == null) {
       element = new TargetElementX(statement,
@@ skipping 20 matching lines @@
     return result;
   }
 
   visitInStaticContext(Node node) {
     inStaticContext(() => visit(node));
   }
 
   ErroneousElement warnAndCreateErroneousElement(Node node,
                                                  SourceString name,
                                                  MessageKind kind,
-                                                 List<Node> arguments) {
+                                                 [Map arguments = const {}]) {
     ResolutionWarning warning = new ResolutionWarning(kind, arguments);
     compiler.reportWarning(node, warning);
     return new ErroneousElementX(kind, arguments, name, enclosingElement);
   }
 
   Element visitIdentifier(Identifier node) {
     if (node.isThis()) {
       if (!inInstanceContext) {
-        error(node, MessageKind.NO_INSTANCE_AVAILABLE, [node]);
+        error(node, MessageKind.NO_INSTANCE_AVAILABLE, {'name': node});
       }
       return null;
     } else if (node.isSuper()) {
       if (!inInstanceContext) error(node, MessageKind.NO_SUPER_IN_STATIC);
       if ((ElementCategory.SUPER & allowedCategory) == 0) {
         error(node, MessageKind.INVALID_USE_OF_SUPER);
       }
       return null;
     } else {
       Element element = lookup(node, node.source);
       if (element == null) {
         if (!inInstanceContext) {
           element = warnAndCreateErroneousElement(node, node.source,
                                                   MessageKind.CANNOT_RESOLVE,
-                                                  [node]);
+                                                  {'name': node});
         }
       } else if (element.isErroneous()) {
         // Use the erroneous element.
       } else {
         if ((element.kind.category & allowedCategory) == 0) {
           // TODO(ahe): Improve error message. Need UX input.
-          error(node, MessageKind.GENERIC, ["is not an expression $element"]);
+          error(node, MessageKind.GENERIC,
+                {'text': "is not an expression $element"});
         }
       }
       if (!Elements.isUnresolved(element)
           && element.kind == ElementKind.CLASS) {
         ClassElement classElement = element;
         classElement.ensureResolved(compiler);
       }
       return useElement(node, element);
     }
   }
 
   Element visitTypeAnnotation(TypeAnnotation node) {
     DartType type = resolveTypeAnnotation(node);
     if (type != null) {
       if (inCheckContext) {
         compiler.enqueuer.resolution.registerIsCheck(type);
       }
       return type.element;
     }
     return null;
   }
 
   Element defineElement(Node node, Element element,
                         {bool doAddToScope: true}) {
     compiler.ensure(element != null);
     mapping[node] = element;
     if (doAddToScope) {
       Element existing = scope.add(element);
       if (existing != element) {
-        error(node, MessageKind.DUPLICATE_DEFINITION, [node]);
+        error(node, MessageKind.DUPLICATE_DEFINITION, {'name': node});
       }
     }
     return element;
   }
 
   Element useElement(Node node, Element element) {
     if (element == null) return null;
     return mapping[node] = element;
   }
 
@@ skipping 177 matching lines @@
     Selector selector = resolveSelector(node);
     if (node.isSuperCall) mapping.superUses.add(node);
 
     if (node.receiver == null) {
       // If this send is of the form "assert(expr);", then
       // this is an assertion.
       if (selector.isAssert()) {
         if (selector.argumentCount != 1) {
           error(node.selector,
                 MessageKind.WRONG_NUMBER_OF_ARGUMENTS_FOR_ASSERT,
-                [selector.argumentCount]);
+                {'argumentCount': selector.argumentCount});
         } else if (selector.namedArgumentCount != 0) {
           error(node.selector,
                 MessageKind.ASSERT_IS_GIVEN_NAMED_ARGUMENTS,
-                [selector.namedArgumentCount]);
+                {'argumentCount': selector.namedArgumentCount});
         }
         return compiler.assertMethod;
       }
 
       return node.selector.accept(this);
     }
 
     var oldCategory = allowedCategory;
     allowedCategory |= ElementCategory.PREFIX | ElementCategory.SUPER;
     Element resolvedReceiver = visit(node.receiver);
     allowedCategory = oldCategory;
 
     Element target;
     SourceString name = node.selector.asIdentifier().source;
     if (identical(name.stringValue, 'this')) {
-      error(node.selector, MessageKind.GENERIC, ["expected an identifier"]);
+      error(node.selector, MessageKind.GENERIC,
+            {'text': "expected an identifier"});
     } else if (node.isSuperCall) {
       if (node.isOperator) {
         if (isUserDefinableOperator(name.stringValue)) {
           name = selector.name;
         } else {
-          error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, [name]);
+          error(node.selector, MessageKind.ILLEGAL_SUPER_SEND, {'name': name});
         }
       }
       if (!inInstanceContext) {
-        error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, [name]);
+        error(node.receiver, MessageKind.NO_INSTANCE_AVAILABLE, {'name': name});
         return null;
       }
       if (currentClass.supertype == null) {
         // This is just to guard against internal errors, so no need
         // for a real error message.
-        error(node.receiver, MessageKind.GENERIC, ["Object has no superclass"]);
+        error(node.receiver, MessageKind.GENERIC,
+              {'text': "Object has no superclass"});
       }
       // TODO(johnniwinther): Ensure correct behavior if currentClass is a
       // patch.
       target = currentClass.lookupSuperMember(name);
       // [target] may be null which means invoking noSuchMethod on
       // super.
     } else if (Elements.isUnresolved(resolvedReceiver)) {
       return null;
     } else if (identical(resolvedReceiver.kind, ElementKind.CLASS)) {
       ClassElement receiverClass = resolvedReceiver;
@@ skipping 11 matching lines @@
       if (target == null) {
         // TODO(johnniwinther): With the simplified [TreeElements] invariant,
         // try to resolve injected elements if [currentClass] is in the patch
         // library of [receiverClass].
 
         // TODO(karlklose): this should be reported by the caller of
         // [resolveSend] to select better warning messages for getters and
         // setters.
         return warnAndCreateErroneousElement(node, name,
                                              MessageKind.METHOD_NOT_FOUND,
-                                             [receiverClass.name, name]);
+                                             {'className': receiverClass.name,
+                                              'methodName': name});
       } else if (target.isInstanceMember()) {
-        error(node, MessageKind.MEMBER_NOT_STATIC, [receiverClass.name, name]);
+        error(node, MessageKind.MEMBER_NOT_STATIC,
+              {'className': receiverClass.name,
+               'memberName': name});
       }
     } else if (identical(resolvedReceiver.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = resolvedReceiver;
       target = prefix.lookupLocalMember(name);
       if (Elements.isUnresolved(target)) {
         return warnAndCreateErroneousElement(
             node, name, MessageKind.NO_SUCH_LIBRARY_MEMBER,
-            [prefix.name, name]);
+            {'libraryName': prefix.name, 'memberName': name});
       } else if (target.kind == ElementKind.CLASS) {
         ClassElement classElement = target;
         classElement.ensureResolved(compiler);
       }
     }
     return target;
   }
 
   DartType resolveTypeTest(Node argument) {
     TypeAnnotation node = argument.asTypeAnnotation();
@@ skipping 71 matching lines @@
     if (list == null) return;
     List<SourceString> seenNamedArguments = <SourceString>[];
     for (Link<Node> link = list.nodes; !link.isEmpty; link = link.tail) {
       Expression argument = link.head;
       visit(argument);
       NamedArgument namedArgument = argument.asNamedArgument();
       if (namedArgument != null) {
         SourceString source = namedArgument.name.source;
         if (seenNamedArguments.contains(source)) {
           error(argument, MessageKind.DUPLICATE_DEFINITION,
-                [source.slowToString()]);
+                {'name': source});
         }
         seenNamedArguments.add(source);
       } else if (!seenNamedArguments.isEmpty) {
         error(argument, MessageKind.INVALID_ARGUMENT_AFTER_NAMED);
       }
     }
   }
 
   visitSend(Send node) {
     Element target = resolveSend(node);
     if (!Elements.isUnresolved(target)
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       target = field.getter;
       if (target == null && !inInstanceContext) {
         target =
             warnAndCreateErroneousElement(node.selector, field.name,
-                                          MessageKind.CANNOT_RESOLVE_GETTER,
-                                          [node.selector]);
+                                          MessageKind.CANNOT_RESOLVE_GETTER);
       }
     }
 
     bool resolvedArguments = false;
     if (node.isOperator) {
       String operatorString = node.selector.asOperator().source.stringValue;
       if (identical(operatorString, 'is') || identical(operatorString, 'as')) {
         assert(node.arguments.tail.isEmpty);
         DartType type = resolveTypeTest(node.arguments.head);
         if (type != null) {
@@ skipping 52 matching lines @@
       // It might be the closurization of a method.
       world.registerInstantiatedClass(compiler.functionClass);
     }
     return node.isPropertyAccess ? target : null;
   }
 
   void warnArgumentMismatch(Send node, Element target) {
     // TODO(karlklose): we can be more precise about the reason of the
     // mismatch.
     warning(node.argumentsNode, MessageKind.INVALID_ARGUMENTS,
-            [target.name]);
+            {'methodName': target.name});
   }
 
   /// Callback for native enqueuer to parse a type.  Returns [:null:] on error.
   DartType resolveTypeFromString(String typeName) {
     Element element = scope.lookup(new SourceString(typeName));
     if (element == null) return null;
     if (element is! ClassElement) return null;
     element.ensureResolved(compiler);
     return element.computeType(compiler);
   }
 
   visitSendSet(SendSet node) {
     Element target = resolveSend(node);
     Element setter = target;
     Element getter = target;
     SourceString operatorName = node.assignmentOperator.source;
     String source = operatorName.stringValue;
     bool isComplex = !identical(source, '=');
     if (!Elements.isUnresolved(target)
         && target.kind == ElementKind.ABSTRACT_FIELD) {
       AbstractFieldElement field = target;
       setter = field.setter;
       getter = field.getter;
       if (setter == null && !inInstanceContext) {
         setter =
             warnAndCreateErroneousElement(node.selector, field.name,
-                                          MessageKind.CANNOT_RESOLVE_SETTER,
-                                          [node.selector]);
+                                          MessageKind.CANNOT_RESOLVE_SETTER);
       }
       if (isComplex && getter == null && !inInstanceContext) {
         getter =
             warnAndCreateErroneousElement(node.selector, field.name,
-                                          MessageKind.CANNOT_RESOLVE_GETTER,
-                                          [node.selector]);
+                                          MessageKind.CANNOT_RESOLVE_GETTER);
       }
     }
 
     visit(node.argumentsNode);
 
     // TODO(ngeoffray): Check if the target can be assigned.
     // TODO(ngeoffray): Warn if target is null and the send is
     // unqualified.
 
     Selector selector = mapping.getSelector(node);
@@ skipping 94 matching lines @@
       handleRedirectingFactoryBody(node);
     } else {
       visit(node.expression);
     }
   }
 
   void handleRedirectingFactoryBody(Return node) {
     if (!enclosingElement.isFactoryConstructor()) {
       compiler.reportMessage(
           compiler.spanFromSpannable(node),
-          MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY.error([]),
+          MessageKind.FACTORY_REDIRECTION_IN_NON_FACTORY.error(),
           Diagnostic.ERROR);
       compiler.reportMessage(
           compiler.spanFromSpannable(enclosingElement),
-          MessageKind.MISSING_FACTORY_KEYWORD.error([]),
+          MessageKind.MISSING_FACTORY_KEYWORD.error(),
           Diagnostic.INFO);
     }
     Element redirectionTarget = resolveRedirectingFactory(node);
     var type = mapping.getType(node.expression);
     if (type is InterfaceType && !type.isRaw) {
       unimplemented(node.expression, 'type arguments on redirecting factory');
     }
     useElement(node.expression, redirectionTarget);
     FunctionElement constructor = enclosingElement;
     if (constructor.modifiers.isConst() &&
@@ skipping 155 matching lines @@
     // TODO(ngeoffray): Implement this.
     unimplemented(node, 'modifiers');
   }
 
   visitLiteralList(LiteralList node) {
     world.registerInstantiatedClass(compiler.listClass);
     NodeList arguments = node.typeArguments;
     if (arguments != null) {
       Link<Node> nodes = arguments.nodes;
       if (nodes.isEmpty) {
-        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT, []);
+        error(arguments, MessageKind.MISSING_TYPE_ARGUMENT);
       } else {
         resolveTypeRequired(nodes.head);
         for (nodes = nodes.tail; !nodes.isEmpty; nodes = nodes.tail) {
-          error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT, []);
+          error(nodes.head, MessageKind.ADDITIONAL_TYPE_ARGUMENT);
           resolveTypeRequired(nodes.head);
         }
       }
     }
     visit(node.elements);
   }
 
   visitConditional(Conditional node) {
     node.visitChildren(this);
   }
@@ skipping 14 matching lines @@
       target = statementScope.currentBreakTarget();
       if (target == null) {
         error(node, MessageKind.NO_BREAK_TARGET);
         return;
       }
       target.isBreakTarget = true;
     } else {
       String labelName = node.target.source.slowToString();
       LabelElement label = statementScope.lookupLabel(labelName);
       if (label == null) {
-        error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
+        error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
         return;
       }
       target = label.target;
       if (!target.statement.isValidBreakTarget()) {
-        error(node.target, MessageKind.INVALID_BREAK, [labelName]);
+        error(node.target, MessageKind.INVALID_BREAK);
         return;
       }
       label.setBreakTarget();
       mapping[node.target] = label;
     }
     if (mapping[node] != null) {
       // TODO(ahe): I'm not sure why this node already has an element
       // that is different from target.  I will talk to Lasse and
       // figure out what is going on.
       mapping.remove(node);
     }
     mapping[node] = target;
   }
 
   visitContinueStatement(ContinueStatement node) {
     TargetElement target;
     if (node.target == null) {
       target = statementScope.currentContinueTarget();
       if (target == null) {
         error(node, MessageKind.NO_CONTINUE_TARGET);
         return;
       }
       target.isContinueTarget = true;
     } else {
       String labelName = node.target.source.slowToString();
       LabelElement label = statementScope.lookupLabel(labelName);
       if (label == null) {
-        error(node.target, MessageKind.UNBOUND_LABEL, [labelName]);
+        error(node.target, MessageKind.UNBOUND_LABEL, {'labelName': labelName});
         return;
       }
       target = label.target;
       if (!target.statement.isValidContinueTarget()) {
-        error(node.target, MessageKind.INVALID_CONTINUE, [labelName]);
+        error(node.target, MessageKind.INVALID_CONTINUE);
       }
       // TODO(lrn): Handle continues to switch cases.
       if (target.statement is SwitchCase) {
         unimplemented(node, "continue to switch case");
       }
       label.setContinueTarget();
       mapping[node.target] = label;
     }
     mapping[node] = target;
   }
@@ skipping 22 matching lines @@
     visitLoopBodyIn(node, node.body, blockScope);
 
     // TODO(lrn): Also allow a single identifier.
     if ((declaration is !Send || declaration.asSend().selector is !Identifier
         || declaration.asSend().receiver != null)
         && (declaration is !VariableDefinitions ||
         !declaration.asVariableDefinitions().definitions.nodes.tail.isEmpty))
     {
       // The variable declaration is either not an identifier, not a
       // declaration, or it's declaring more than one variable.
-      error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN, []);
+      error(node.declaredIdentifier, MessageKind.INVALID_FOR_IN);
     }
   }
 
   visitLabel(Label node) {
     // Labels are handled by their containing statements/cases.
   }
 
   visitLabeledStatement(LabeledStatement node) {
     Statement body = node.statement;
     TargetElement targetElement = getOrCreateTargetElement(body);
     Map<String, LabelElement> labelElements = <String, LabelElement>{};
     for (Label label in node.labels) {
       String labelName = label.slowToString();
       if (labelElements.containsKey(labelName)) continue;
       LabelElement element = targetElement.addLabel(label, labelName);
       labelElements[labelName] = element;
     }
     statementScope.enterLabelScope(labelElements);
     visit(node.statement);
     statementScope.exitLabelScope();
     labelElements.forEach((String labelName, LabelElement element) {
       if (element.isTarget) {
         mapping[element.label] = element;
       } else {
-        warning(element.label, MessageKind.UNUSED_LABEL, [labelName]);
+        warning(element.label, MessageKind.UNUSED_LABEL,
+                {'labelName': labelName});
       }
     });
     if (!targetElement.isTarget && identical(mapping[body], targetElement)) {
       // If the body is itself a break or continue for another target, it
       // might have updated its mapping to the target it actually does target.
       mapping.remove(body);
     }
   }
 
   visitLiteralMap(LiteralMap node) {
@@ skipping 17 matching lines @@
     while (!cases.isEmpty) {
       SwitchCase switchCase = cases.head;
       for (Node labelOrCase in switchCase.labelsAndCases) {
         if (labelOrCase is! Label) continue;
         Label label = labelOrCase;
         String labelName = label.slowToString();
 
         LabelElement existingElement = continueLabels[labelName];
         if (existingElement != null) {
           // It's an error if the same label occurs twice in the same switch.
-          warning(label, MessageKind.DUPLICATE_LABEL, [labelName]);
-          error(existingElement.label, MessageKind.EXISTING_LABEL, [labelName]);
+          warning(label, MessageKind.DUPLICATE_LABEL, {'labelName': labelName});
+          error(existingElement.label, MessageKind.EXISTING_LABEL,
+                {'labelName': labelName});
         } else {
           // It's only a warning if it shadows another label.
           existingElement = statementScope.lookupLabel(labelName);
           if (existingElement != null) {
-            warning(label, MessageKind.DUPLICATE_LABEL, [labelName]);
+            warning(label, MessageKind.DUPLICATE_LABEL,
+                    {'labelName': labelName});
             warning(existingElement.label,
-                    MessageKind.EXISTING_LABEL, [labelName]);
+                    MessageKind.EXISTING_LABEL, {'labelName': labelName});
           }
         }
 
         TargetElement targetElement =
             new TargetElementX(switchCase,
                                statementScope.nestingLevel,
                                enclosingElement);
         if (mapping[switchCase] != null) {
           // TODO(ahe): Talk to Lasse about this.
           mapping.remove(switchCase);
@@ skipping 118 matching lines @@
 
     var nameSet = new Set<SourceString>();
     // Resolve the bounds of type variables.
     Link<DartType> typeLink = element.typeVariables;
     Link<Node> nodeLink = node.nodes;
     while (!nodeLink.isEmpty) {
       TypeVariableType typeVariable = typeLink.head;
       SourceString typeName = typeVariable.name;
       TypeVariable typeNode = nodeLink.head;
       if (nameSet.contains(typeName)) {
-        error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME, [typeName]);
+        error(typeNode, MessageKind.DUPLICATE_TYPE_VARIABLE_NAME,
+              {'typeVariableName': typeName});
       }
       nameSet.add(typeName);
 
       TypeVariableElement variableElement = typeVariable.element;
       if (typeNode.bound != null) {
         DartType boundType = typeResolver.resolveTypeAnnotation(
             typeNode.bound, scope, element, onFailure: warning);
         if (boundType != null && boundType.element == variableElement) {
           // TODO(johnniwinther): Check for more general cycles, like
           // [: <A extends B, B extends C, C extends B> :].
           warning(node, MessageKind.CYCLIC_TYPE_VARIABLE,
-                  [variableElement.name]);
+                  {'typeVariableName': variableElement.name});
         } else if (boundType != null) {
           variableElement.bound = boundType;
         } else {
           // TODO(johnniwinther): Should be an erroneous type.
           variableElement.bound = compiler.objectClass.computeType(compiler);
         }
       } else {
         variableElement.bound = compiler.objectClass.computeType(compiler);
       }
       nodeLink = nodeLink.tail;
@@ skipping 160 matching lines @@
     ClassElement mixin = mixinType.element;
     mixin.ensureResolved(compiler);
 
     // Check for cycles in the mixin chain.
     ClassElement previous = mixinApplication;  // For better error messages.
     ClassElement current = mixin;
     while (current != null && current.isMixinApplication) {
       MixinApplicationElement currentMixinApplication = current;
       if (currentMixinApplication == mixinApplication) {
         CompilationError error = MessageKind.ILLEGAL_MIXIN_CYCLE.error(
-            [current.name, previous.name]);
+            {'mixinName1': current.name, 'mixinName2': previous.name});
         compiler.reportMessage(compiler.spanFromElement(mixinApplication),
                                error, Diagnostic.ERROR);
         // We have found a cycle in the mixin chain. Return null as
         // the mixin for this application to avoid getting into
         // infinite recursion when traversing members.
         return null;
       }
       previous = current;
       current = currentMixinApplication.mixin;
     }
     compiler.world.registerMixinUse(mixinApplication, mixin);
     return mixin;
   }
 
   // TODO(johnniwinther): Remove when default class is no longer supported.
   DartType visitTypeAnnotation(TypeAnnotation node) {
     return visit(node.typeName);
   }
 
   // TODO(johnniwinther): Remove when default class is no longer supported.
   DartType visitIdentifier(Identifier node) {
     Element element = scope.lookup(node.source);
     if (element == null) {
-      error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
+      error(node, MessageKind.CANNOT_RESOLVE_TYPE,  {'typeName': node});
       return null;
     } else if (!element.impliesType() && !element.isTypeVariable()) {
-      error(node, MessageKind.NOT_A_TYPE, [node]);
+      error(node, MessageKind.NOT_A_TYPE, {'node': node});
       return null;
     } else {
       if (element.isTypeVariable()) {
         TypeVariableElement variableElement = element;
         return variableElement.type;
       } else if (element.isTypedef()) {
         compiler.unimplemented('visitIdentifier for typedefs', node: node);
       } else {
         // TODO(ngeoffray): Use type variables.
         return element.computeType(compiler);
       }
     }
     return null;
   }
 
   // TODO(johnniwinther): Remove when default class is no longer supported.
   DartType visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return null;
     }
     Element element = scope.lookup(prefix.source);
     if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return null;
     }
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType()) {
-      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
+      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
+            {'typeName': node.selector});
       return null;
     }
     return e.computeType(compiler);
   }
 
   DartType resolveSupertype(ClassElement cls, TypeAnnotation superclass) {
     DartType supertype = typeResolver.resolveTypeAnnotation(
         superclass, scope, cls, onFailure: error);
     if (supertype != null) {
       if (identical(supertype.kind, TypeKind.MALFORMED_TYPE)) {
         // Error has already been reported.
         return null;
       } else if (!identical(supertype.kind, TypeKind.INTERFACE)) {
         // TODO(johnniwinther): Handle dynamic.
-        error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
+        error(superclass.typeName, MessageKind.CLASS_NAME_EXPECTED);
         return null;
       } else if (isBlackListed(supertype)) {
-        error(superclass, MessageKind.CANNOT_EXTEND, [supertype]);
+        error(superclass, MessageKind.CANNOT_EXTEND, {'type': supertype});
         return null;
       }
     }
     return supertype;
   }
 
   Link<DartType> resolveInterfaces(NodeList interfaces, Node superclass) {
     Link<DartType> result = const Link<DartType>();
     if (interfaces == null) return result;
     for (Link<Node> link = interfaces.nodes; !link.isEmpty; link = link.tail) {
       DartType interfaceType = typeResolver.resolveTypeAnnotation(
           link.head, scope, element, onFailure: error);
       if (interfaceType != null) {
         if (identical(interfaceType.kind, TypeKind.MALFORMED_TYPE)) {
           // Error has already been reported.
         } else if (!identical(interfaceType.kind, TypeKind.INTERFACE)) {
           // TODO(johnniwinther): Handle dynamic.
           TypeAnnotation typeAnnotation = link.head;
-          error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED, []);
+          error(typeAnnotation.typeName, MessageKind.CLASS_NAME_EXPECTED);
         } else {
           if (interfaceType == element.supertype) {
             compiler.reportMessage(
                 compiler.spanFromSpannable(superclass),
-                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
+                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error(
+                    {'type': interfaceType}),
                 Diagnostic.ERROR);
             compiler.reportMessage(
                 compiler.spanFromSpannable(link.head),
-                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error([interfaceType]),
+                MessageKind.DUPLICATE_EXTENDS_IMPLEMENTS.error(
+                    {'type': interfaceType}),
                 Diagnostic.ERROR);
           }
           if (result.contains(interfaceType)) {
             compiler.reportMessage(
                 compiler.spanFromSpannable(link.head),
-                MessageKind.DUPLICATE_IMPLEMENTS.error([interfaceType]),
+                MessageKind.DUPLICATE_IMPLEMENTS.error({'type': interfaceType}),
                 Diagnostic.ERROR);
           }
           result = result.prepend(interfaceType);
           if (isBlackListed(interfaceType)) {
-            error(link.head, MessageKind.CANNOT_IMPLEMENT, [interfaceType]);
+            error(link.head, MessageKind.CANNOT_IMPLEMENT,
+                  {'type': interfaceType});
           }
         }
       }
     }
     return result;
   }
 
   void calculateAllSupertypes(ClassElement cls) {
     // TODO(karlklose): Check if type arguments match, if a class
     // element occurs more than once in the supertypes.
@@ skipping 87 matching lines @@
     visitNodeList(node.mixins);
   }
 
   void visitTypeAnnotation(TypeAnnotation node) {
     node.typeName.accept(this);
   }
 
   void visitIdentifier(Identifier node) {
     Element element = context.lookup(node.source);
     if (element == null) {
-      error(node, MessageKind.CANNOT_RESOLVE_TYPE, [node]);
+      error(node, MessageKind.CANNOT_RESOLVE_TYPE, {'typeName': node});
     } else if (!element.impliesType()) {
-      error(node, MessageKind.NOT_A_TYPE, [node]);
+      error(node, MessageKind.NOT_A_TYPE, {'node': node});
     } else {
       if (element.isClass()) {
         loadSupertype(element, node);
       } else {
         compiler.reportMessage(
           compiler.spanFromSpannable(node),
-          MessageKind.CLASS_NAME_EXPECTED.error([]),
+          MessageKind.CLASS_NAME_EXPECTED.error(),
           Diagnostic.ERROR);
       }
     }
   }
 
   void visitSend(Send node) {
     Identifier prefix = node.receiver.asIdentifier();
     if (prefix == null) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     Element element = context.lookup(prefix.source);
     if (element == null || !identical(element.kind, ElementKind.PREFIX)) {
-      error(node.receiver, MessageKind.NOT_A_PREFIX, [node.receiver]);
+      error(node.receiver, MessageKind.NOT_A_PREFIX, {'node': node.receiver});
       return;
     }
     PrefixElement prefixElement = element;
     Identifier selector = node.selector.asIdentifier();
     var e = prefixElement.lookupLocalMember(selector.source);
     if (e == null || !e.impliesType()) {
-      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE, [node.selector]);
+      error(node.selector, MessageKind.CANNOT_RESOLVE_TYPE,
+            {'typeName': node.selector});
       return;
     }
     loadSupertype(e, node);
   }
 }
 
 class VariableDefinitionsVisitor extends CommonResolverVisitor<SourceString> {
   VariableDefinitions definitions;
   ResolverVisitor resolver;
   ElementKind kind;
@@ skipping 103 matching lines @@
       }
     }
   }
 
   // The only valid [Send] can be in constructors and must be of the form
   // [:this.x:] (where [:x:] represents an instance field).
   FieldParameterElement visitSend(Send node) {
     FieldParameterElement element;
     if (node.receiver.asIdentifier() == null ||
         !node.receiver.asIdentifier().isThis()) {
-      error(node, MessageKind.INVALID_PARAMETER, []);
-    } else if (!identical(enclosingElement.kind, ElementKind.GENERATIVE_CONSTRUCTOR)) {
-      error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED, []);
+      error(node, MessageKind.INVALID_PARAMETER);
+    } else if (!identical(enclosingElement.kind,
+                          ElementKind.GENERATIVE_CONSTRUCTOR)) {
+      error(node, MessageKind.FIELD_PARAMETER_NOT_ALLOWED);
     } else {
       SourceString name = getParameterName(node);
       Element fieldElement = currentClass.lookupLocalMember(name);
-      if (fieldElement == null || !identical(fieldElement.kind, ElementKind.FIELD)) {
-        error(node, MessageKind.NOT_A_FIELD, [name]);
+      if (fieldElement == null ||
+          !identical(fieldElement.kind, ElementKind.FIELD)) {
+        error(node, MessageKind.NOT_A_FIELD, {'fieldName': name});
       } else if (!fieldElement.isInstanceMember()) {
-        error(node, MessageKind.NOT_INSTANCE_FIELD, [name]);
+        error(node, MessageKind.NOT_INSTANCE_FIELD, {'fieldName': name});
       }
       Element variables = new VariableListElementX.node(currentDefinitions,
           ElementKind.VARIABLE_LIST, enclosingElement);
       element = new FieldParameterElementX(name, fieldElement, variables, node);
     }
     return element;
   }
 
   Element visitSendSet(SendSet node) {
     Element element;
@@ skipping 40 matching lines @@
   static FunctionSignature analyze(Compiler compiler,
                                    NodeList formalParameters,
                                    Node returnNode,
                                    Element element) {
     SignatureResolver visitor = new SignatureResolver(compiler, element);
     Link<Element> parameters = const Link<Element>();
     int requiredParameterCount = 0;
     if (formalParameters == null) {
       if (!element.isGetter()) {
         compiler.reportMessage(compiler.spanFromElement(element),
-                               MessageKind.MISSING_FORMALS.error([]),
+                               MessageKind.MISSING_FORMALS.error(),
                                Diagnostic.ERROR);
       }
     } else {
       if (element.isGetter()) {
         if (!identical(formalParameters.getEndToken().next.stringValue,
                        // TODO(ahe): Remove the check for native keyword.
                        'native')) {
           if (compiler.rejectDeprecatedFeatures &&
               // TODO(ahe): Remove isPlatformLibrary check.
               !element.getLibrary().isPlatformLibrary) {
             compiler.reportMessage(compiler.spanFromSpannable(formalParameters),
-                                   MessageKind.EXTRA_FORMALS.error([]),
+                                   MessageKind.EXTRA_FORMALS.error(),
                                    Diagnostic.ERROR);
           } else {
             compiler.onDeprecatedFeature(formalParameters, 'getter parameters');
           }
         }
       }
       LinkBuilder<Element> parametersBuilder =
         visitor.analyzeNodes(formalParameters.nodes);
       requiredParameterCount  = parametersBuilder.length;
       parameters = parametersBuilder.toLink();
     }
     DartType returnType = compiler.resolveReturnType(element, returnNode);
     if (element.isSetter() && (requiredParameterCount != 1 ||
                                visitor.optionalParameterCount != 0)) {
       // If there are no formal parameters, we already reported an error above.
       if (formalParameters != null) {
         compiler.reportMessage(compiler.spanFromSpannable(formalParameters),
-                               MessageKind.ILLEGAL_SETTER_FORMALS.error([]),
+                               MessageKind.ILLEGAL_SETTER_FORMALS.error(),
                                Diagnostic.ERROR);
       }
     }
     if (element.isGetter() && (requiredParameterCount != 0
                                || visitor.optionalParameterCount != 0)) {
       compiler.reportMessage(compiler.spanFromSpannable(formalParameters),
-                             MessageKind.EXTRA_FORMALS.error([]),
+                             MessageKind.EXTRA_FORMALS.error(),
                              Diagnostic.ERROR);
     }
     return new FunctionSignatureX(parameters,
                                   visitor.optionalParameters,
                                   requiredParameterCount,
                                   visitor.optionalParameterCount,
                                   visitor.optionalParametersAreNamed,
                                   returnType);
   }
 
@@ skipping 17 matching lines @@
   DartType type;
 
   ConstructorResolver(Compiler compiler, this.resolver) : super(compiler);
 
   visitNode(Node node) {
     throw 'not supported';
   }
 
   failOrReturnErroneousElement(Element enclosing, Node diagnosticNode,
                                SourceString targetName, MessageKind kind,
-                               List arguments) {
+                               Map arguments) {
     if (inConstContext) {
       error(diagnosticNode, kind, arguments);
     } else {
       ResolutionWarning warning  = new ResolutionWarning(kind, arguments);
       compiler.reportWarning(diagnosticNode, warning);
       return new ErroneousElementX(kind, arguments, targetName, enclosing);
     }
   }
 
   Selector createConstructorSelector(SourceString constructorName) {
@@ skipping 15 matching lines @@
     if (result == null) {
       String fullConstructorName =
           resolver.compiler.resolver.constructorNameForDiagnostics(
               cls.name,
               constructorName);
       return failOrReturnErroneousElement(
           cls,
           diagnosticNode,
           new SourceString(fullConstructorName),
           MessageKind.CANNOT_FIND_CONSTRUCTOR,
-          [fullConstructorName]);
+          {'constructorName': fullConstructorName});
     } else if (inConstContext && !result.modifiers.isConst()) {
       error(diagnosticNode, MessageKind.CONSTRUCTOR_IS_NOT_CONST);
     }
     return result;
   }
 
   visitNewExpression(NewExpression node) {
     inConstContext = node.isConst();
     Node selector = node.send.selector;
     Element e = visit(selector);
     return finishConstructorReference(e, node.send.selector, node);
   }
 
   /// Finishes resolution of a constructor reference and records the
   /// type of the constructed instance on [expression].
   FunctionElement finishConstructorReference(Element e,
                                              Node diagnosticNode,
                                              Node expression) {
     // Find the unnamed constructor if the reference resolved to a
     // class.
     if (!Elements.isUnresolved(e) && e.isClass()) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass == null)) {
         // TODO(ahe): Remove this check and error message when we
         // don't have interfaces anymore.
         error(diagnosticNode,
-              MessageKind.CANNOT_INSTANTIATE_INTERFACE, [cls.name]);
+              MessageKind.CANNOT_INSTANTIATE_INTERFACE,
+              {'interfaceName': cls.name});
       }
       // The unnamed constructor may not exist, so [e] may become unresolved.
       e = lookupConstructor(cls, diagnosticNode, const SourceString(''));
     }
     if (type == null) {
       if (Elements.isUnresolved(e)) {
         type = compiler.dynamicClass.computeType(compiler);
       } else {
         type = e.getEnclosingClass().computeType(compiler).asRaw();
       }
@@ skipping 11 matching lines @@
   visitSend(Send node) {
     Element e = visit(node.receiver);
     if (Elements.isUnresolved(e)) return e;
     Identifier name = node.selector.asIdentifier();
     if (name == null) internalError(node.selector, 'unexpected node');
 
     if (identical(e.kind, ElementKind.CLASS)) {
       ClassElement cls = e;
       cls.ensureResolved(compiler);
       if (cls.isInterface() && (cls.defaultClass == null)) {
-        error(node.receiver, MessageKind.CANNOT_INSTANTIATE_INTERFACE,
-              [cls.name]);
+        error(node.receiver,
+              MessageKind.CANNOT_INSTANTIATE_INTERFACE,
+              {'interfaceName': cls.name});
       }
       return lookupConstructor(cls, name, name.source);
     } else if (identical(e.kind, ElementKind.PREFIX)) {
       PrefixElement prefix = e;
       e = prefix.lookupLocalMember(name.source);
       if (e == null) {
         return failOrReturnErroneousElement(resolver.enclosingElement, name,
                                             name.source,
                                             MessageKind.CANNOT_RESOLVE,
-                                            [name]);
+                                            {'name': name});
       } else if (!identical(e.kind, ElementKind.CLASS)) {
-        error(node, MessageKind.NOT_A_TYPE, [name]);
+        error(node, MessageKind.NOT_A_TYPE, {'node': name});
       }
     } else {
       internalError(node.receiver, 'unexpected element $e');
     }
     return e;
   }
 
   Element visitIdentifier(Identifier node) {
     SourceString name = node.source;
     Element e = resolver.lookup(node, name);
     // TODO(johnniwinther): Change errors to warnings, cf. 11.11.1.
     if (e == null) {
       return failOrReturnErroneousElement(resolver.enclosingElement, node, name,
-                                          MessageKind.CANNOT_RESOLVE, [name]);
+                                          MessageKind.CANNOT_RESOLVE,
+                                          {'name': name});
     } else if (e.isErroneous()) {
       return e;
     } else if (identical(e.kind, ElementKind.TYPEDEF)) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF, [name]);
+      error(node, MessageKind.CANNOT_INSTANTIATE_TYPEDEF,
+            {'typedefName': name});
     } else if (identical(e.kind, ElementKind.TYPE_VARIABLE)) {
-      error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE, [name]);
+      error(node, MessageKind.CANNOT_INSTANTIATE_TYPE_VARIABLE,
+            {'typeVariableName': name});
     } else if (!identical(e.kind, ElementKind.CLASS)
         && !identical(e.kind, ElementKind.PREFIX)) {
-      error(node, MessageKind.NOT_A_TYPE, [name]);
+      error(node, MessageKind.NOT_A_TYPE, {'node': name});
     }
     return e;
   }
 
   /// Assumed to be called by [resolveRedirectingFactory].
   Element visitReturn(Return node) {
     Node expression = node.expression;
     return finishConstructorReference(visit(expression),
                                       expression, expression);
   }
 }