Add a validation for the name parameter not matching the function name

pkg/intl/lib/src/intl_message.dart

 // Copyright (c) 2013, 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.
 
 /**
  * This provides classes to represent the internal structure of the
  * arguments to `Intl.message`. It is used when parsing sources to extract
  * messages or to generate code for message substitution. Normal programs
  * using Intl would not import this library.
  *
@@ skipping 71 matching lines @@
         (eachArg) => eachArg is NamedExpression &&
             eachArg.name.label.name == 'name',
         orElse: () => null);
     if (messageName == null) {
       return "The 'name' argument for Intl.message must be specified";
     }
     if (messageName.expression is! SimpleStringLiteral) {
       return "The 'name' argument for Intl.message must be a simple string "
           "literal.";
     }
+    if (outerName != null && outerName != messageName.expression.value) {
+      return "The 'name' argument for Intl.message must match "
+          "the name of the containing function ("
+          "'${messageName.expression.value}' vs. '$outerName')";
+    }
     var simpleArguments = arguments.where(
         (each) => each is NamedExpression
         && ["desc", "name"].contains(each.name.label.name));
     var values = simpleArguments.map((each) => each.expression).toList();
     for (var arg in values) {
       if (arg is! SimpleStringLiteral) {
         return "Intl.message argument '$arg' must be "
             "a simple string literal";
       }
     }
+    return null;
   }
 
   /**
    * Turn a value, typically read from a translation file or created out of an
    * AST for a source program, into the appropriate
    * subclass. We expect to get literal Strings, variable substitutions
    * represented by integers, things that are already MessageChunks and
    * lists of the same.
    */
   static Message from(value, Message parent) {
@@ skipping 232 matching lines @@
    * When generating code, we store translations for each locale
    * associated with the original message.
    */
   Map<String, String> translations = new Map();
 
   /**
    * If the message was not given a name, we use the entire message string as
    * the name.
    */
   String get name => _name == null ? computeName() : _name;
-  void set name(x) {_name = x;}
+  set name(String newName) { _name = newName; }

[Emily Fortuna, 2014/02/24 18:38:23]

I'd be inclined to leave the "void" in this line, but personal preference.

[Alan Knight, 2014/02/24 18:46:44]

I got dinged before in a review for having that, since a setter is always void.
Which made sense to me.

 
   String computeName() => name = expanded((msg, chunk) => "");
 
   /**
    * Return the full message, with any interpolation expressions transformed
    * by [f] and all the results concatenated. The chunk argument to [f] may be
    * either a String, an int or an object representing a more complex
    * message entity.
    * See [messagePieces].
    */
   String expanded([Function f = _nullTransform]) =>
       messagePieces.map((chunk) => f(this, chunk)).join("");
 
   /**
    * Record the translation for this message in the given locale, after
    * suitably escaping it.
    */
-  String addTranslation(String locale, Message translated) {
+  void addTranslation(String locale, Message translated) {
       translated.parent = this;
       translations[locale] = translated.toCode();
   }
 
   toCode() => throw
       new UnsupportedError("MainMessage.toCode requires a locale");
 
   /**
    * Generate code for this message, expecting it to be part of a map
    * keyed by name with values the function that calls Intl.message.
@@ skipping 286 matching lines @@
     out.write('(');
     out.write(mainArgument);
     var args = codeAttributeNames;
     out.write(", {");
     args.fold(out, (buffer, arg) => buffer..write(
         "'$arg': '${this[arg].toCode()}', "));
     out.write("})}");
     return out.toString();
   }
 }