Add support for Intl.select

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 91 matching lines @@
   /**
    * We keep track of the data from the last MethodDeclaration,
    * FunctionDeclaration or FunctionExpression that we saw on the way down,
    * as that will be the nearest parent of the Intl.message invocation.
    */
   FormalParameterList parameters;
   String name;
 
   /** Return true if [node] matches the pattern we expect for Intl.message() */
   bool looksLikeIntlMessage(MethodInvocation node) {
-    const validNames = const ["message", "plural", "gender"];
+    const validNames = const ["message", "plural", "gender", "select"];
     if (!validNames.contains(node.methodName.name)) return false;
     if (!(node.target is SimpleIdentifier)) return false;
     SimpleIdentifier target = node.target;
     if (target.token.toString() != "Intl") return false;
     return true;
   }
 
+  Message _expectedInstance(String type) {
+    switch (type) {
+      case 'message' : return new MainMessage();
+      case 'plural' : return new Plural();
+      case 'gender' : return new Gender();
+      case 'select' : return new Select();
+      default: return null;
+    }
+  }
+
   /**
    * 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) {
     // The containing function cannot have named parameters.
     if (parameters.parameters.any((each) => each.kind == ParameterKind.NAMED)) {
       return "Named parameters on message functions are not supported.";
     }
     var arguments = node.argumentList.arguments;
-
-    if (node.methodName.name == 'message') {
-      if (!(arguments.first is StringLiteral)) {
-        return "Intl.message messages must be string literals";
-      }
-    }
-
-    var namedArguments = arguments.skip(1);
-    // This seems unlikely to happen, but make sure all are NamedExpression
-    // before doing the tests below.
-    if (!namedArguments.every((each) => each is NamedExpression)) {
-      return "Message arguments except the message must be named";
-    }
-    var notArgs = namedArguments.where(
-        (each) => each.name.label.name != 'args');
-    var values = notArgs.map((each) => each.expression).toList();
-    if (!values.every((each) => each is SimpleStringLiteral)) {
-      "Intl.message arguments must be simple string literals";
-    }
-    var messageName = notArgs.firstWhere(
-        (eachArg) => 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)
-        || messageName.expression.value != name) {
-      return "The 'name' argument for Intl.message must be a simple string "
-          "literal and match the containing function name.";
-    }
-    var hasArgs = namedArguments.any((each) => each.name.label.name == 'args');
-    var hasParameters = !parameters.parameters.isEmpty;
-    if (!hasArgs && hasParameters) {
-      return "The 'args' argument for Intl.message must be specified";
-    }
-    return null;
+    var instance = _expectedInstance(node.methodName.name);
+    return instance.checkValidity(node, arguments, name, parameters);
   }
 
   /**
    * Record the parameters of the function or method declaration we last
    * encountered before seeing the Intl.message call.
    */
   void visitMethodDeclaration(MethodDeclaration node) {
     parameters = node.parameters;
     name = node.name.name;
     super.visitMethodDeclaration(node);
@@ skipping 61 matching lines @@
    */
   MainMessage _messageFromNode(MethodInvocation node, Function extract,
       Function setAttribute) {
     var message = new MainMessage();
     message.name = name;
     message.arguments = parameters.parameters.elements.map(
         (x) => x.identifier.name).toList();
     var arguments = node.argumentList.arguments.elements;
     extract(message, arguments);
 
-    for (NamedExpression namedArgument in arguments.skip(1)) {
+    for (var namedArgument in arguments.where((x) => x is NamedExpression)) {
       var name = namedArgument.name.label.name;
       var exp = namedArgument.expression;
       var string = exp is SimpleStringLiteral ? exp.value : exp.toString();
       setAttribute(message, name, string);
     }
     return message;
   }
 
   /**
    * Create a MainMessage from [node] using the name and
@@ skipping 154 matching lines @@
     super.visitInterpolationExpression(node);
   }
 
   visitMethodInvocation(MethodInvocation node) {
     pieces.add(messageFromMethodInvocation(node));
     super.visitMethodInvocation(node);
   }
 
   /** Return true if [node] matches the pattern for plural or gender message.*/
   bool looksLikePluralOrGender(MethodInvocation node) {
-    if (!["plural", "gender"].contains(node.methodName.name)) return false;
+    if (!["plural", "gender", "select"].contains(node.methodName.name)) {
+      return false;
+    }
     if (!(node.target is SimpleIdentifier)) return false;
     SimpleIdentifier target = node.target;
     if (target.token.toString() != "Intl") return false;
     return true;
   }
 
   /**
    * 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.
   }
 
   /**
    * 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.
    */
   Message messageFromMethodInvocation(MethodInvocation node) {
     var message;
-    if (node.methodName.name == "gender") {
-      message = new Gender();
-    } else if (node.methodName.name == "plural") {
-      message = new Plural();
-    } else {
-      throw new IntlMessageExtractionException("Invalid plural/gender 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 = node.argumentList.arguments.elements;
-    for (var arg in arguments.where((each) => each is NamedExpression)) {
+    var arguments = message.argumentsOfInterestFor(node);
+    arguments.forEach((key, value) {
       try {
         var interpolation = new InterpolationVisitor(message);
-        arg.expression.accept(interpolation);
-        message[arg.name.label.token.toString()] = interpolation.pieces;
+        value.accept(interpolation);
+        message[key] = interpolation.pieces;
       } on IntlMessageExtractionException catch (e) {
         message = null;
         var err = new StringBuffer();
         err.write("Error $e");
         err.write("Processing <$node>");
         err.write(_reportErrorLocation(node));
         print(err);
         warnings.add(err);
       }
-    }
+    });
     var mainArg = node.argumentList.arguments.elements.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";
 }