Support multiple categories per message.

pkg/dart_messages/lib/shared_messages.dart

 // Copyright (c) 2015, 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.
 
 // An update to this file must be followed by regenerating the corresponding
 // json, dart2js and analyzer file. Use `publish.dart` in the bin directory.
 //
 // Every message in this file must have an id. Use `message_id.dart` in the
 // bin directory to generate a fresh one.
 
@@ skipping 59 matching lines @@
 
   static final analysisOptionsWarning = new Category("AnalysisOptionsWarning");
 
   static final checkedModeCompileTimeError =
       new Category("CheckedModeCompileTimeError");
 
   static final parserError = new Category("ParserError");
 
   static final compileTimeError = new Category("CompileTimeError");
 
+  static final staticTypeWarning = new Category("StaticTypeWarning");
+
+  static final staticWarning = new Category("StaticWarning");
+
+  static final hint = new Category("Hint");
+
   final String name;
 
   Category(this.name);
 }
 
 enum Platform { dart2js, analyzer, }
 const dart2js = Platform.dart2js;
 const analyzer = Platform.analyzer;
 
 class Message {
@@ skipping 15 matching lines @@
   /// For example, "Const is not allowed on getters" may be a specialization of
   /// "The 'const' keyword is not allowed here".
   ///
   /// Examples of the specialized message, should trigger for the more generic
   /// message, when the platform doesn't support the more specialized message.
   ///
   /// Specializations must have the same error-id (but not sub-id) as the more
   /// generic message.
   final String specializationOf;
 
-  final Category category;
+  /// The categories of this message.
+  ///
+  /// The same message can be used in multiple categories, for example, as
+  /// hint and warning.
+  final List<Category> categories;
+
   final String template;
   // The analyzer fills holes positionally (and not named). The following field
   // overrides the order of the holes.
   // For example the template "The argument #field in #cls is bad", could have
   // the order `["cls", "field"]', which means that the analyzer would first
   // provide the class `cls` and then only `field`.
   // This list is generally `null`, but when it is provided it must contain all
   // holes.
   final List<String> templateHoleOrder;
   final String howToFix;
   final List<String> options;
   final List examples;
   final List<Platform> usedBy;
 
   Message(
       {this.id,
       this.subId: 0,
       this.specializationOf: null,
-      this.category,
+      this.categories,
       this.template,
       this.templateHoleOrder,
       this.howToFix,
       this.options,
       this.usedBy: const [],
       this.examples});
 }
 
 String get messagesAsJson {
   var jsonified = {};
   MESSAGES.forEach((String name, Message message) {
     jsonified[name] = {
       'id': message.id,
       'subId': message.subId,
-      'category': message.category.name,
+      'categories':
+          message.categories.map((category) => category.name).toList(),
       'template': message.template,
       'templateHoleOrder': message.templateHoleOrder,
       'howToFix': message.howToFix,
       'options': message.options,
       'usedBy': message.usedBy.map((platform) => platform.toString()).toList(),
       'examples': message.examples,
     };
   });
   return new JsonEncoder.withIndent('  ').convert(jsonified);
 }
 
 final Map<String, Message> MESSAGES = {
   'exampleMessage': new Message(
       id: 'use an Id generated by bin/message_id.dart',
-      category: Category.analysisOptionsError,
+      categories: [Category.analysisOptionsError],
       template: "#use #named #arguments",
       templateHoleOrder: ["arguments", "named", "use"],
       howToFix: "an explanation on how to fix things",
       examples: [
         r'''
       Some multiline example;
       That generates the bug.''',
         {
           'fileA.dart': '''
         or a map from file to content.
         again multiline''',
           'fileB.dart': '''
         with possibly multiple files.
         muliline too'''
         }
       ]),
 
   // Const constructors (factory or not) may not have a body.
   'CONST_CONSTRUCTOR_OR_FACTORY_WITH_BODY': new Message(
       id: 'LGJGHW',
       subId: 0,
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Const constructor or factory can't have a body.",
       howToFix: "Remove the 'const' keyword or the body.",
-      usedBy: [
-        dart2js
-      ],
+      usedBy: [dart2js],
       examples: const [
         r"""
          class C {
            const C() {}
          }
 
          main() => new C();""",
         r"""
          class C {
            const factory C() {}
          }
 
          main() => new C();"""
       ]),
   // Const constructors may not have a body.
   'CONST_CONSTRUCTOR_WITH_BODY': new Message(
       id: 'LGJGHW',
       subId: 1,
       specializationOf: "CONST_CONSTRUCTOR_OR_FACTORY_WITH_BODY",
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Const constructor can't have a body.",
       howToFix: "Try removing the 'const' keyword or the body.",
-      usedBy: [
-        analyzer
-      ],
+      usedBy: [analyzer],
       examples: const [
         r"""
          class C {
            const C() {}
          }
 
          main() => new C();"""
       ]),
   // Const constructor factories may only redirect (and must not have a body).
   'CONST_FACTORY': new Message(
       id: 'LGJGHW',
       subId: 2,
       specializationOf: "CONST_CONSTRUCTOR_OR_FACTORY_WITH_BODY",
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Only redirecting factory constructors can be declared to "
           "be 'const'.",
       howToFix: "Try removing the 'const' keyword or replacing the body with "
           "'=' followed by a valid target.",
-      usedBy: [
-        analyzer
-      ],
+      usedBy: [analyzer],
       examples: const [
         r"""
          class C {
            const factory C() {}
          }
 
          main() => new C();"""
       ]),
 
   'EXTRANEOUS_MODIFIER': new Message(
       id: 'GRKIQE',
       subId: 0,
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Can't have modifier '#{modifier}' here.",
       howToFix: "Try removing '#{modifier}'.",
-      usedBy: [
-        dart2js
-      ],
+      usedBy: [dart2js],
       examples: const [
         "var String foo; main(){}",
         // "var get foo; main(){}",
         "var set foo; main(){}",
         "var final foo; main(){}",
         "var var foo; main(){}",
         "var const foo; main(){}",
         "var abstract foo; main(){}",
         "var static foo; main(){}",
         "var external foo; main(){}",
         "get var foo; main(){}",
         "set var foo; main(){}",
         "final var foo; main(){}",
         "var var foo; main(){}",
         "const var foo; main(){}",
         "abstract var foo; main(){}",
         "static var foo; main(){}",
         "external var foo; main(){}"
       ]),
 
   'EXTRANEOUS_MODIFIER_REPLACE': new Message(
       id: 'GRKIQE',
       subId: 1,
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Can't have modifier '#{modifier}' here.",
       howToFix: "Try replacing modifier '#{modifier}' with 'var', 'final', "
           "or a type.",
-      usedBy: [
-        dart2js
-      ],
+      usedBy: [dart2js],
       examples: const [
         // "get foo; main(){}",
         "set foo; main(){}",
         "abstract foo; main(){}",
         "static foo; main(){}",
         "external foo; main(){}"
       ]),
 
   'CONST_CLASS': new Message(
       id: 'GRKIQE',
       subId: 2,
       // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
       // example below triggers 'EXTRANEOUS_MODIFIER'.
       specializationOf: 'EXTRANEOUS_MODIFIER',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Classes can't be declared to be 'const'",
       howToFix: "Try removing the 'const' keyword or moving to the class'"
           " constructor(s).",
-      usedBy: [
-        analyzer
-      ],
+      usedBy: [analyzer],
       examples: const [
         r"""
         const class C {}
 
         main() => new C();
         """
       ]),
 
   'CONST_METHOD': new Message(
       id: 'GRKIQE',
       subId: 3,
       // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
       // example below triggers 'EXTRANEOUS_MODIFIER'.
       specializationOf: 'EXTRANEOUS_MODIFIER',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Getters, setters and methods can't be declared to be 'const'",
       howToFix: "Try removing the 'const' keyword.",
-      usedBy: [
-        analyzer
-      ],
+      usedBy: [analyzer],
       examples: const [
         "const int foo() => 499; main() {}",
         "const int get foo => 499; main() {}",
         "const set foo(v) => 499; main() {}",
         "class A { const int foo() => 499; } main() { new A(); }",
         "class A { const int get foo => 499; } main() { new A(); }",
         "class A { const set foo(v) => 499; } main() { new A(); }",
       ]),
 
   'CONST_ENUM': new Message(
       id: 'GRKIQE',
       subId: 4,
       // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
       // example below triggers 'EXTRANEOUS_MODIFIER'.
       specializationOf: 'EXTRANEOUS_MODIFIER',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Enums can't be declared to be 'const'",
       howToFix: "Try removing the 'const' keyword.",
       usedBy: [analyzer],
       examples: const ["const enum Foo { x } main() {}",]),
 
   'CONST_TYPEDEF': new Message(
       id: 'GRKIQE',
       subId: 5,
       // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
       // example below triggers 'EXTRANEOUS_MODIFIER'.
       specializationOf: 'EXTRANEOUS_MODIFIER',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Type aliases can't be declared to be 'const'",
       howToFix: "Try removing the 'const' keyword.",
       usedBy: [analyzer],
       examples: const ["const typedef void Foo(); main() {}",]),
 
   'CONST_AND_FINAL': new Message(
       id: 'GRKIQE',
       subId: 6,
       // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
       // example below triggers 'EXTRANEOUS_MODIFIER'.
       specializationOf: 'EXTRANEOUS_MODIFIER',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Members can't be declared to be both 'const' and 'final'",
       howToFix: "Try removing either the 'const' or 'final' keyword.",
-      usedBy: [
-        analyzer
-      ],
+      usedBy: [analyzer],
       examples: const [
         "final const int x = 499; main() {}",
         "const final int x = 499; main() {}",
         "class A { static final const int x = 499; } main() {}",
         "class A { static const final int x = 499; } main() {}",
       ]),
 
   'CONST_AND_VAR': new Message(
       id: 'GRKIQE',
       subId: 7,
       // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
       // example below triggers 'EXTRANEOUS_MODIFIER'.
       specializationOf: 'EXTRANEOUS_MODIFIER',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Members can't be declared to be both 'const' and 'var'",
       howToFix: "Try removing either the 'const' or 'var' keyword.",
-      usedBy: [
-        analyzer
-      ],
+      usedBy: [analyzer],
       examples: const [
         "var const x = 499; main() {}",
         "const var x = 499; main() {}",
         "class A { var const x = 499; } main() {}",
         "class A { const var x = 499; } main() {}",
       ]),
 
   'CLASS_IN_CLASS': new Message(
       // Dart2js currently reports this as an EXTRANEOUS_MODIFIER error.
       // TODO(floitsch): make dart2js use this error instead.
       id: 'DOTHQH',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Classes can't be declared inside other classes.",
       howToFix: "Try moving the class to the top-level.",
       usedBy: [analyzer],
       examples: const ["class A { class B {} } main() { new A(); }",]),
 
   'CONSTRUCTOR_WITH_RETURN_TYPE': new Message(
       id: 'VOJBWY',
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Constructors can't have a return type",
       howToFix: "Try removing the return type.",
       usedBy: [analyzer, dart2js],
       examples: const ["class A { int A() {} } main() { new A(); }",]),
 
   'MISSING_EXPRESSION_IN_THROW': new Message(
       id: 'FTGGMJ',
       subId: 0,
-      category: Category.parserError,
+      categories: [Category.parserError],
       template: "Missing expression after 'throw'.",
       howToFix: "Did you mean 'rethrow'?",
-      usedBy: [
-        analyzer,
-        dart2js
-      ],
+      usedBy: [analyzer, dart2js],
       examples: const [
         'main() { throw; }',
         'main() { try { throw 0; } catch(e) { throw; } }'
       ]),
 
   /**
    * 12.8.1 Rethrow: It is a compile-time error if an expression of the form
    * <i>rethrow;</i> is not enclosed within a on-catch clause.
    */
   'RETHROW_OUTSIDE_CATCH': new Message(
       id: 'MWETLC',
-      category: Category.compileTimeError,
+      categories: [Category.compileTimeError],
       template: 'Rethrow must be inside of catch clause',
       howToFix: "Try moving the expression into a catch clause, or "
           "using a 'throw' expression.",
       usedBy: [analyzer, dart2js],
       examples: const ["main() { rethrow; }"]),
 
   /**
    * 13.12 Return: It is a compile-time error if a return statement of the form
    * <i>return e;</i> appears in a generative constructor.
    */
   'RETURN_IN_GENERATIVE_CONSTRUCTOR': new Message(
       id: 'UOTDQH',
-      category: Category.compileTimeError,
+      categories: [Category.compileTimeError],
       template: "Constructors can't return values.",
       howToFix:
           "Try removing the return statement or using a factory constructor.",
-      usedBy: [
-        analyzer,
-        dart2js
-      ],
+      usedBy: [analyzer, dart2js],
       examples: const [
         """
         class C {
           C() {
             return 1;
           }
         }
 
         main() => new C();"""
       ]),
 
   /**
    * 13.12 Return: It is a compile-time error if a return statement of the form
    * <i>return e;</i> appears in a generator function.
    */
   'RETURN_IN_GENERATOR': new Message(
       id: 'JRUTUQ',
       subId: 0,
-      category: Category.compileTimeError,
+      categories: [Category.compileTimeError],
       template: "Can't return a value from a generator function "
           "(using the '#{modifier}' modifier).",
       howToFix: "Try removing the value, replacing 'return' with 'yield' or"
           " changing the method body modifier",
-      usedBy: [
-        analyzer,
-        dart2js
-      ],
+      usedBy: [analyzer, dart2js],
       examples: const [
         """
         foo() async* { return 0; }
         main() => foo();
         """,
         """
         foo() sync* { return 0; }
         main() => foo();
         """
       ]),
+
+  'NOT_ASSIGNABLE': new Message(
+      id: 'FYQYXB',
+      subId: 0,
+      categories: [Category.staticTypeWarning],
+      template: "'#{fromType}' is not assignable to '#{toType}'.",
+      usedBy: [dart2js]),
+
+  'FORIN_NOT_ASSIGNABLE': new Message(
+      id: 'FYQYXB',
+      subId: 1,
+      categories: [Category.hint],
+      template: "The element type '#{currentType}' of '#{expressionType}' "
+          "is not assignable to '#{elementType}'.",
+      usedBy: [dart2js],
+      examples: const [
+        """
+        main() {
+          List<int> list = <int>[1, 2];
+          for (String x in list) x;
+        }
+        """
+      ]),
+
+  /**
+   * 13.11 Return: It is a static type warning if the type of <i>e</i> may not
+   * be assigned to the declared return type of the immediately enclosing
+   * function.
+   */
+  'RETURN_OF_INVALID_TYPE': new Message(
+      id: 'FYQYXB',
+      subId: 2,
+      specializationOf: 'NOT_ASSIGNABLE',
+      categories: [Category.staticTypeWarning],
+      template: "The return type '#{fromType}' is not a '#{toType}', as "
+          "defined by the method '#{method}'.",
+      usedBy: [analyzer],
+      examples: const ["int foo() => 'foo'; main() { foo(); }"]),
+
+  /**
+   * 12.11.1 New: It is a static warning if the static type of <i>a<sub>i</sub>,
+   * 1 &lt;= i &lt;= n+ k</i> may not be assigned to the type of the
+   * corresponding formal parameter of the constructor <i>T.id</i> (respectively
+   * <i>T</i>).
+   *
+   * 12.11.2 Const: It is a static warning if the static type of
+   * <i>a<sub>i</sub>, 1 &lt;= i &lt;= n+ k</i> may not be assigned to the type
+   * of the corresponding formal parameter of the constructor <i>T.id</i>
+   * (respectively <i>T</i>).
+   *
+   * 12.14.2 Binding Actuals to Formals: Let <i>T<sub>i</sub></i> be the static
+   * type of <i>a<sub>i</sub></i>, let <i>S<sub>i</sub></i> be the type of
+   * <i>p<sub>i</sub>, 1 &lt;= i &lt;= n+k</i> and let <i>S<sub>q</sub></i> be
+   * the type of the named parameter <i>q</i> of <i>f</i>. It is a static
+   * warning if <i>T<sub>j</sub></i> may not be assigned to <i>S<sub>j</sub>, 1
+   * &lt;= j &lt;= m</i>.
+   *
+   * 12.14.2 Binding Actuals to Formals: Furthermore, each <i>q<sub>i</sub>, 1
+   * &lt;= i &lt;= l</i>, must have a corresponding named parameter in the set
+   * <i>{p<sub>n+1</sub>, &hellip; p<sub>n+k</sub>}</i> or a static warning
+   * occurs. It is a static warning if <i>T<sub>m+j</sub></i> may not be
+   * assigned to <i>S<sub>r</sub></i>, where <i>r = q<sub>j</sub>, 1 &lt;= j
+   * &lt;= l</i>.
+   */
+  'ARGUMENT_TYPE_NOT_ASSIGNABLE': new Message(
+      id: 'FYQYXB',
+      subId: 3,
+      specializationOf: 'NOT_ASSIGNABLE',
+      categories: [Category.hint, Category.staticWarning],
+      template: "The argument type '#{fromType}' cannot be assigned to the "
+          "parameter type '#{toType}'.",
+      usedBy: [analyzer],
+      // TODO(floitsch): support hint warnings and ways to specify which
+      // category an example should trigger for.
+      examples: const ["foo(int x) => x; main() { foo('bar'); }"]),
 };