Allow Intl.plural/gender as the top-level, omitting the Intl.message wrapper and the first layer of…

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 74 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) {
-    if (node.methodName.name != "message") return false;
+    const validNames = const ["message", "plural", "gender"];
+    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;
   }
 
   /**
    * 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 (!(arguments.first is StringLiteral)) {
-      return "Intl.message messages must be string literals";
+
+    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)) {
@@ skipping 35 matching lines @@
    * encountered before seeing the Intl.message call.
    */
   void visitFunctionDeclaration(FunctionDeclaration node) {
     parameters = node.functionExpression.parameters;
     name = node.name.name;
     super.visitFunctionDeclaration(node);
   }
 
   /**
    * Examine method invocations to see if they look like calls to Intl.message.
+   * If we've found one, stop recursing. This is important because we can have
+   * Intl.message(...Intl.plural...) and we don't want to treat the inner
+   * plural as if it was an outermost message.
    */
   void visitMethodInvocation(MethodInvocation node) {
-    addIntlMessage(node);
-    return super.visitNode(node);
+    if (!addIntlMessage(node)) {
+      return super.visitMethodInvocation(node);
+    }
   }
 
   /**
    * Check that the node looks like an Intl.message invocation, and create
-   * the [IntlMessage] object from it and store it in [messages].
+   * the [IntlMessage] object from it and store it in [messages]. Return true
+   * if we successfully extracted a message and should stop looking. Return
+   * false if we didn't, so should continue recursing.
    */
-  void addIntlMessage(MethodInvocation node) {
-    if (!looksLikeIntlMessage(node)) return;
+  bool addIntlMessage(MethodInvocation node) {
+    if (!looksLikeIntlMessage(node)) return false;
     var reason = checkValidity(node);
-    if (reason != null && !suppressWarnings) {
-      print("Skipping invalid Intl.message invocation\n    <$node>");
-      print("    reason: $reason");
-      _reportErrorLocation(node);
-      return;
+    if (reason != null) {
+      if (!suppressWarnings) {
+        print("Skipping invalid Intl.message invocation\n    <$node>");
+        print("    reason: $reason");
+        _reportErrorLocation(node);
+      }
+      // We found one, but it's not valid. Stop recursing.
+      return true;
     }
-    var message = messageFromMethodInvocation(node);
+    var message;
+    if (node.methodName.name == "message") {
+      message = messageFromIntlMessageCall(node);
+    } else {
+      message = messageFromDirectPluralOrGenderCall(node);
+    }
     if (message != null) messages[message.name] = message;
+    return true;
   }
 
   /**
-   * Create an IntlMessage from [node] using the name and
-   * parameters of the last function/method declaration we encountered
-   * and the parameters to the Intl.message call.
+   * Create a MainMessage from [node] using the name and
+   * parameters of the last function/method declaration we encountered,
+   * and the values we get by calling [extract]. We set those values
+   * by calling [setAttribute]. This is the common parts between
+   * [messageFromIntlMessageCall] and [messageFromDirectPluralOrGenderCall].
    */
-  MainMessage messageFromMethodInvocation(MethodInvocation node) {
+  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;
-    try {
-      var interpolation = new InterpolationVisitor(message);
-      arguments.first.accept(interpolation);
-      message.messagePieces.addAll(interpolation.pieces);
-    } on IntlMessageExtractionException catch (e) {
-      message = null;
-      print("Error $e");
-      print("Processing <$node>");
-      _reportErrorLocation(node);
-    }
+    extract(message, arguments);
+
     for (NamedExpression namedArgument in arguments.skip(1)) {
       var name = namedArgument.name.label.name;
       var exp = namedArgument.expression;
       var string = exp is SimpleStringLiteral ? exp.value : exp.toString();
-      message[name] = string;
+      setAttribute(message, name, string);
     }
     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) {
+      try {
+        var interpolation = new InterpolationVisitor(message);
+        arguments.first.accept(interpolation);
+        message.messagePieces.addAll(interpolation.pieces);
+      } on IntlMessageExtractionException catch (e) {
+        message = null;
+        print("Error $e");
+        print("Processing <$node>");
+        _reportErrorLocation(node);
+      }
+    }
+
+    void setValue(MainMessage message, String fieldName, String 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, _) {
+      var visitor = new PluralAndGenderVisitor(message.messagePieces, message);
+      node.accept(visitor);
+      pluralOrGender = message.messagePieces.last;
+    }
+
+    void setAttribute(MainMessage msg, String fieldName, String fieldValue) {
+      if (["name", "desc", "examples", "args"].contains(fieldName)) {
+        msg[fieldName] = fieldValue;
+      } else {
+        pluralOrGender[fieldName] = fieldValue;
+      }
+    }
+    return _messageFromNode(node, extractFromPluralOrGender, setAttribute);
+  }
 }
 
 /**
  * Given an interpolation, find all of its chunks, validate that they are only
  * simple variable substitutions or else Intl.plural/gender calls,
  * and keep track of the pieces of text so that other parts
  * of the program can deal with the simple string sections and the generated
  * parts separately. Note that this is a SimpleASTVisitor, so it only
  * traverses one level of children rather than automatically recursing. If we
  * find a plural or gender, which requires recursion, we do it with a separate
@@ skipping 86 matching lines @@
     // TODO(alanknight): Provide better errors for malformed expressions.
     if (!looksLikePluralOrGender(node.expression)) return;
     var reason = checkValidity(node.expression);
     if (reason != null) throw reason;
     var message = messageFromMethodInvocation(node.expression);
     foundPluralOrGender = true;
     pieces.add(message);
     super.visitInterpolationExpression(node);
   }
 
-  /** Return true if [node] matches the pattern we expect for Intl.message() */
+  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 (!(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.
    */
-  messageFromMethodInvocation(MethodInvocation node) {
+  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");
     }
     message.parent = parent;
 
@@ skipping 30 matching lines @@
    */
   final String message;
 
   /**
    * Creates a new exception with an optional error [message].
    */
   const IntlMessageExtractionException([this.message = ""]);
 
   String toString() => "IntlMessageExtractionException: $message";
 }