Add a flag to prohibit plurals/genders that don't take up the whole string.

pkg/intl/lib/extract_messages.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 is for use in extracting messages from a Dart program
  * using the Intl.message() mechanism and writing them to a file for
  * translation. This provides only the stub of a mechanism, because it
  * doesn't define how the file should be written. It provides an
  * [IntlMessage] class that holds the extracted data and [parseString]
@@ skipping 29 matching lines @@
 /**
  * This accumulates a list of all warnings/errors we have found. These are
  * saved as strings right now, so all that can really be done is print and
  * count them.
  */
 List<String> warnings = [];
 
 /** Were there any warnings or errors in extracting messages. */
 bool get hasWarnings => warnings.isNotEmpty;
 
+/** Are plural and gender expressions required to be at the top level
+ * of an expression, or are they allowed to be embedded in string literals.
+ *
+ * For example, the following expression
+ *     'There are ${Intl.plural(...)} items'.
+ * is legal if [allowEmbeddedPluralsAndGenders] is true, but illegal
+ * if [allowEmbeddedPluralsAndGenders] is false.
+ */
+bool allowEmbeddedPluralsAndGenders = true;
+
 /**
  * Parse the source of the Dart program file [file] and return a Map from
  * message names to [IntlMessage] instances.
  */
 Map<String, MainMessage> parseFile(File file) {
   try {
     _root = parseDartFile(file.path);
   } on AnalyzerErrorGroup catch (e) {
     print("Error in parsing ${file.path}, no messages extracted.");
     print("  $e");
@@ skipping 161 matching lines @@
    * by calling [setAttribute]. This is the common parts between
    * [messageFromIntlMessageCall] and [messageFromDirectPluralOrGenderCall].
    */
   MainMessage _messageFromNode(MethodInvocation node, Function extract,
       Function setAttribute) {
     var message = new MainMessage();
     message.name = name;
     message.arguments = parameters.parameters.map(
         (x) => x.identifier.name).toList();
     var arguments = node.argumentList.arguments;
-    extract(message, arguments);
+    var extractionResult = extract(message, arguments);
+    if (extractionResult == null) return null;
 
     for (var namedArgument in arguments.where((x) => x is NamedExpression)) {
       var name = namedArgument.name.label.name;
       var exp = namedArgument.expression;
       var evaluator = new ConstantEvaluator();
       var basicValue = exp.accept(evaluator);
       var value = basicValue == ConstantEvaluator.NOT_A_CONSTANT ?
           exp.toString() : basicValue;
       setAttribute(message, name, value);
     }
     return message;
   }
 
   /**
    * Create a MainMessage from [node] using the name and
    * parameters of the last function/method declaration we encountered
    * and the parameters to the Intl.message call.
    */
   MainMessage messageFromIntlMessageCall(MethodInvocation node) {
 
-    void extractFromIntlCall(MainMessage message, List arguments) {
+    MainMessage extractFromIntlCall(MainMessage message, List arguments) {
       try {
         var interpolation = new InterpolationVisitor(message);
         arguments.first.accept(interpolation);
+        if (interpolation.pieces.any((x) => x is Plural || x is Gender) &&
+            !allowEmbeddedPluralsAndGenders) {
+          if (interpolation.pieces.any((x) => x is String && x.isNotEmpty)) {
+            throw new IntlMessageExtractionException(
+                "Plural and gender expressions must be at the top level, "
+                "they cannot be embedded in larger string literals.\n"
+                "Error at $node");
+          }
+        }
         message.messagePieces.addAll(interpolation.pieces);
       } on IntlMessageExtractionException catch (e) {
         message = null;
         var err = new StringBuffer()
             ..writeAll(["Error ", e, "\nProcessing <", node, ">\n"])
             ..write(_reportErrorLocation(node));
         print(err);
-        warnings.add(err);
+        warnings.add(err.toString());
       }
+      return message; // Because we may have set it to null on an error.
     }
 
     void setValue(MainMessage message, String fieldName, Object fieldValue) {
       message[fieldName] = fieldValue;
     }
 
     return _messageFromNode(node, extractFromIntlCall, setValue);
   }
 
   /**
    * Create a MainMessage from [node] using the name and
    * parameters of the last function/method declaration we encountered
    * and the parameters to the Intl.plural or Intl.gender call.
    */
   MainMessage messageFromDirectPluralOrGenderCall(MethodInvocation node) {
     var pluralOrGender;
 
-    void extractFromPluralOrGender(MainMessage message, _) {
+    MainMessage extractFromPluralOrGender(MainMessage message, _) {
       var visitor = new PluralAndGenderVisitor(message.messagePieces, message);
       node.accept(visitor);
       pluralOrGender = message.messagePieces.last;
+      return message;
     }
 
     void setAttribute(MainMessage msg, String fieldName, String fieldValue) {
       if (msg.attributeNames.contains(fieldName)) {
         msg[fieldName] = fieldValue;
       }
     }
     return _messageFromNode(node, extractFromPluralOrGender, setAttribute);
   }
 }
@@ skipping 121 matching lines @@
    * Returns a String describing why the node is invalid, or null if no
    * reason is found, so it's presumed valid.
    */
   String checkValidity(MethodInvocation node) {
     // TODO(alanknight): Add reasonable validity checks.
     return null;
   }
 
   /**
    * Create a MainMessage from [node] using the name and
-   * parameters of the last function/method declaration we encountered            e
+   * parameters of the last function/method declaration we encountered
    * and the parameters to the Intl.message call.
    */
   Message messageFromMethodInvocation(MethodInvocation node) {
     var message;
     switch(node.methodName.name) {
       case "gender" : message = new Gender(); break;
       case "plural" : message = new Plural(); break;
       case "select" : message = new Select(); break;
       default: throw new IntlMessageExtractionException(
           "Invalid plural/gender/select message");
     }
     message.parent = parent;
 
     var arguments = message.argumentsOfInterestFor(node);
     arguments.forEach((key, value) {
       try {
         var interpolation = new InterpolationVisitor(message);
         value.accept(interpolation);
         message[key] = interpolation.pieces;
       } on IntlMessageExtractionException catch (e) {
         message = null;
         var err = new StringBuffer()
             ..writeAll(["Error ", e, "\nProcessing <", node, ">"])
             ..write(_reportErrorLocation(node));
         print(err);
-        warnings.add(err);
+        warnings.add(err.toString());
       }
     });
     var mainArg = node.argumentList.arguments.firstWhere(
         (each) => each is! NamedExpression);
     if (mainArg is SimpleStringLiteral) {
       message.mainArgument = mainArg.toString();
     } else {
       message.mainArgument = mainArg.name;
     }
     return message;
   }
 }
 
 /**
  * Exception thrown when we cannot process a message properly.
  */
 class IntlMessageExtractionException implements Exception {
   /**
    * A message describing the error.
    */
   final String message;
 
   /**
    * Creates a new exception with an optional error [message].
    */
   const IntlMessageExtractionException([this.message = ""]);
 
   String toString() => "IntlMessageExtractionException: $message";
 }