Add support for Intl.select

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 15 matching lines @@
  * CompositeMessage containing three pieces, a LiteralString for
  * 'This is plural (', a VariableSubstitution for `num`. amd a LiteralString
  * for '.)'.
  *
  * This representation isn't used at runtime. Rather, we read some format
  * from a translation file, parse it into these objects, and they are then
  * used to generate the code representation above.
  */
 library intl_message;
 
+import 'package:analyzer_experimental/analyzer.dart';
+
 /** A default function for the [Message.expanded] method. */
 _nullTransform(msg, chunk) => chunk;
 
 /**
  * An abstract superclass for Intl.message/plural/gender calls in the
  * program's source text. We
  * assemble these into objects that can be used to write out some translation
  * format and can also print themselves into code.
  */
 abstract class Message {
 
   /**
    * All [Message]s except a [MainMessage] are contained inside some parent,
    * terminating at an Intl.message call which supplies the arguments we
    * use for variable substitutions.
    */
   Message parent;
 
   Message(this.parent);
 
   /**
    * We find the arguments from the top-level [MainMessage] and use those to
    * do variable substitutions.
    */
   get arguments => parent == null ? const [] : parent.arguments;
 
+  String checkValidity(MethodInvocation node, List arguments,
+                       String outerName, FormalParameterList outerArgs) {
+    var hasArgs = arguments.any(
+        (each) => each is NamedExpression && each.name.label.name == 'args');
+    var hasParameters = !outerArgs.parameters.isEmpty;
+    if (!hasArgs && hasParameters) {
+      return "The 'args' argument for Intl.message must be specified";
+    }
+
+    var messageName = arguments.firstWhere(
+        (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)
+        || messageName.expression.value != outerName) {
+      return "The 'name' argument for Intl.message must be a simple string "
+          "literal and match the containing function name.";
+    }
+    var simpleArguments = arguments.where(
+        (each) => each is NamedExpression
+        && ["desc", "locale", "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.name.label.name}' must be "
+            "a simple string literal";
+      }
+    }
+  }
+
   /**
    * 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) {
     if (value is String) return new LiteralString(value, parent);
     if (value is int) return new VariableSubstitution(value, parent);
@@ skipping 155 matching lines @@
 
   MainMessage() : super(null);
 
   /**
    * All the pieces of the message. When we go to print, these will
    * all be expanded appropriately. The exact form depends on what we're
    * printing it for See [expanded], [toCode].
    */
   List<Message> messagePieces = [];
 
+  /** Verify that this looks like a correct Intl.message invocation. */
+  String checkValidity(MethodInvocation node, List arguments,
+      String outerName, FormalParameterList outerArgs) {
+    if (arguments.first is! StringLiteral) {
+      return "Intl.message messages must be string literals";
+    }
+
+    return super.checkValidity(node, arguments, outerName, outerArgs);
+  }
+
   void addPieces(List<Message> messages) {
     for (var each in messages) {
       messagePieces.add(Message.from(each, this));
     }
   }
 
   /** The description provided in the Intl.message call. */
   String description;
 
   /** The examples from the Intl.message call */
@@ skipping 130 matching lines @@
 
   toString() => expanded();
 
   /**
    * The name of the main argument, which is expected to have the value
    * which is one of [attributeNames] and is used to decide which clause to use.
    */
   String mainArgument;
 
   /**
+   * Return the arguments that affect this SubMessage as a map of
+   * argument names and values.
+   */
+  Map argumentsOfInterestFor(MethodInvocation node) {
+    var basicArguments = node.argumentList.arguments.elements;
+    var others = basicArguments.where((each) => each is NamedExpression);
+    return new Map.fromIterable(others,
+        key: (node) => node.name.label.token.value(),
+        value: (node) => node.expression);
+  }
+
+  /**
    * Return the list of attribute names to use when generating code. This
    *  may be different from [attributeNames] if there are multiple aliases
    *  that map to the same clause.
    */
   List<String> get codeAttributeNames;
 
   String expanded([Function transform = _nullTransform]) {
     fullMessageForClause(key) => key + '{' +
         transform(parent, this[key]).toString() + '}';
     var clauses = attributeNames
@@ skipping 19 matching lines @@
 
 /**
  * Represents a message send of [Intl.gender] inside a message that is to
  * be internationalized. This corresponds to an ICU message syntax "select"
  * with "male", "female", and "other" as the possible options.
  */
 class Gender extends SubMessage {
 
   Gender();
   /**
-   * Create a new IntlGender providing [mainArgument] and the list of possible
+   * Create a new Gender providing [mainArgument] and the list of possible
    * clauses. Each clause is expected to be a list whose first element is a
-   * variable name and whose second element is either a String or
-   * a list of strings and IntlMessageSends or IntlVariableSubstitution.
+   * variable name and whose second element is either a [String] or
+   * a list of strings and [Message] or [VariableSubstitution].
    */
-  Gender.from(mainArgument, List clauses, parent) :
+  Gender.from(String mainArgument, List clauses, Message parent) :
       super.from(mainArgument, clauses, parent);
 
   Message female;
   Message male;
   Message other;
 
   String get icuMessageName => "select";
   String get dartMessageName => 'Intl.gender';
 
   get attributeNames => ["female", "male", "other"];
@@ skipping 18 matching lines @@
       case "male" : return male;
       case "other" : return other;
       default: return other;
     }
   }
 }
 
 class Plural extends SubMessage {
 
    Plural();
-   Plural.from(mainArgument, clauses, parent) :
+   Plural.from(String mainArgument, List clauses, Message parent) :
      super.from(mainArgument, clauses, parent);
 
    Message zero;
    Message one;
    Message two;
    Message few;
    Message many;
    Message other;
 
    String get icuMessageName => "plural";
@@ skipping 31 matching lines @@
        case "two" : return two;
        case "=2" : return two;
        case "few" : return few;
        case "many" : return many;
        case "other" : return other;
        default: return other;
      }
    }
 }
 
+/**
+ * Represents a message send of [Intl.select] inside a message that is to
+ * be internationalized. This corresponds to an ICU message syntax "select"
+ * with arbitrary options.
+ */
+class Select extends SubMessage {
+
+  Select();
+  /**
+   * Create a new [Select] providing [mainArgument] and the list of possible
+   * clauses. Each clause is expected to be a list whose first element is a
+   * variable name and whose second element is either a String or
+   * a list of strings and [Message]s or [VariableSubstitution]s.
+   */
+  Select.from(String mainArgument, List clauses, Message parent) :
+      super.from(mainArgument, clauses, parent);
+
+  Map<String, Message> cases = new Map<String, Message>();
+
+  String get icuMessageName => "select";
+  String get dartMessageName => 'Intl.select';
+
+  get attributeNames => cases.keys;
+  get codeAttributeNames => attributeNames;
+
+  void operator []=(attributeName, rawValue) {
+    var value = Message.from(rawValue, this);
+    cases[attributeName] = value;
+  }
+
+  Message operator [](String attributeName) {
+    var exact = cases[attributeName];
+    return exact == null ? cases["other"] : exact;
+  }
+
+  /**
+   * Return the arguments that we care about for the select. In this
+   * case they will all be passed in as a Map rather than as the named
+   * arguments used in Plural/Gender.
+   */
+  Map argumentsOfInterestFor(MethodInvocation node) {
+    var casesArgument = node.argumentList.arguments.elements[1];
+    return new Map.fromIterable(casesArgument.entries,
+      key: (node) => node.key.value,
+      value: (node) => node.value);
+  }
+
+  /**
+   * Write out the generated representation of this message. This differs
+   * from Plural/Gender in that it prints a literal map rather than
+   * named arguments.
+   */
+  String toCode() {
+    var out = new StringBuffer();
+    out.write('\${');
+    out.write(dartMessageName);
+    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();
+  }
+}