Improvements to warnings on message extraction.

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 15 matching lines @@
 import 'package:analyzer_experimental/analyzer.dart';
 import 'package:intl/src/intl_message.dart';
 
 /**
  * If this is true, print warnings for skipped messages. Otherwise, warnings
  * are suppressed.
  */
 bool suppressWarnings = false;
 
 /**
+ * If this is true, then treat all warnings as errors.
+ */
+bool warningsAreErrors = false;
+
+/**
+ * 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;
+
+/**
  * 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) {
   _root = parseDartFile(file.path);
   _origin = file.path;
   var visitor = new MessageFindingVisitor();
   _root.accept(visitor);
   return visitor.messages;
 }
 
 /**
  * The root of the compilation unit, and the first node we visit. We hold
  * on to this for error reporting, as it can give us line numbers of other
  * nodes.
  */
 CompilationUnit _root;
 
 /**
  * An arbitrary string describing where the source code came from. Most
  * obviously, this could be a file path. We use this when reporting
  * invalid messages.
  */
 String _origin;
 
-void _reportErrorLocation(ASTNode node) {
-  if (_origin != null) print("    from $_origin");
+String _reportErrorLocation(ASTNode node) {
+  var result = new StringBuffer();
+  if (_origin != null) result.write("    from $_origin");
   var info = _root.lineInfo;
   if (info != null) {
     var line = info.getLocation(node.offset);
-    print("    line: ${line.lineNumber}, column: ${line.columnNumber}");
+    result.write("    line: ${line.lineNumber}, column: ${line.columnNumber}");
   }
+  return result.toString();
 }
 
 /**
  * This visits the program source nodes looking for Intl.message uses
  * that conform to its pattern and then creating the corresponding
  * IntlMessage objects. We have to find both the enclosing function, and
  * the Intl.message invocation.
  */
 class MessageFindingVisitor extends GeneralizingASTVisitor {
 
@@ skipping 44 matching lines @@
     // 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";
     }
-    if (!notArgs.any((each) => each.name.label.name == 'name')) {
+    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;
   }
 
   /**
    * 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;
-    String name = node.name.name;
+    name = node.name.name;
     super.visitMethodDeclaration(node);
   }
 
   /**
    * Record the parameters of the function or method declaration we last
    * encountered before seeing the Intl.message call.
    */
-  void visitFunctionExpression(FunctionExpression node) {
-    parameters = node.parameters;
-    name = null;
-    super.visitFunctionExpression(node);
-  }
-
-  /**
-   * Record the parameters of the function or method declaration we last
-   * 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) {
     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]. Return true
    * if we successfully extracted a message and should stop looking. Return
    * false if we didn't, so should continue recursing.
    */
   bool addIntlMessage(MethodInvocation node) {
     if (!looksLikeIntlMessage(node)) return false;
     var reason = checkValidity(node);
     if (reason != null) {
       if (!suppressWarnings) {
-        print("Skipping invalid Intl.message invocation\n    <$node>");
-        print("    reason: $reason");
-        _reportErrorLocation(node);
+        var err = new StringBuffer();
+        err.write("Skipping invalid Intl.message invocation\n    <$node>\n");
+        err.write("    reason: $reason\n");
+        err.write(_reportErrorLocation(node));
+        warnings.add(err.toString());
+        print(err);
       }
       // We found one, but it's not valid. Stop recursing.
       return true;
     }
     var message;
     if (node.methodName.name == "message") {
       message = messageFromIntlMessageCall(node);
     } else {
       message = messageFromDirectPluralOrGenderCall(node);
     }
@@ skipping 33 matching lines @@
    */
   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);
+        var err = new StringBuffer();
+        err.write("Error $e\n");
+        err.write("Processing <$node>\n");
+        err.write(_reportErrorLocation(node));
+        print(err);
+        warnings.add(err);
       }
     }
 
     void setValue(MainMessage message, String fieldName, String fieldValue) {
       message[fieldName] = fieldValue;
     }
 
     return _messageFromNode(node, extractFromIntlCall, setValue);
   }
 
@@ skipping 165 matching lines @@
     message.parent = parent;
 
     var arguments = node.argumentList.arguments.elements;
     for (var arg in arguments.where((each) => each is NamedExpression)) {
       try {
         var interpolation = new InterpolationVisitor(message);
         arg.expression.accept(interpolation);
         message[arg.name.label.token.toString()] = interpolation.pieces;
       } on IntlMessageExtractionException catch (e) {
         message = null;
-        print("Error $e");
-        print("Processing <$node>");
-        _reportErrorLocation(node);
+        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";
 }