Use error-names for 'specializationOf'.

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 82 matching lines @@
   /// In particular, we want errors of the same category to share the same
   /// explanation page, and want to disable warnings of the same category
   /// with just one line.
   final String id;
 
   /// The sub-id of the error.
   ///
   /// This id just needs to be unique within the same [id].
   final int subId;
 
-  /// The error sub-id of which this message is a specialization.
+  /// The error of which this message is a specialization.
   ///
   /// 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.
-  final int specializationOf;
+  ///
+  /// Specializations must have the same error-id (but not sub-id) as the more
+  /// generic message.
+  final String specializationOf;
 
   final Category category;
   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: -1,
+      this.specializationOf: null,
       this.category,
       this.template,
       this.templateHoleOrder,
       this.howToFix,
       this.options,
       this.usedBy: const [],
       this.examples});
 }
 
 String get messagesAsJson {
@@ skipping 56 matching lines @@
          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: 0,
+      specializationOf: "CONST_CONSTRUCTOR_OR_FACTORY_WITH_BODY",
       category: Category.parserError,
       template: "Const constructor can't have a body.",
       howToFix: "Try removing the 'const' keyword or the body.",
       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: 0,
+      specializationOf: "CONST_CONSTRUCTOR_OR_FACTORY_WITH_BODY",
       category: 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
       ],
       examples: const [
         r"""
@@ skipping 47 matching lines @@
         // "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 1, but the example below triggers 0.
-      specializationOf: 0,
+      // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
+      // example below triggers 'EXTRANEOUS_MODIFIER'.
+      specializationOf: 'EXTRANEOUS_MODIFIER',
       category: 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
       ],
       examples: const [
         r"""
         const class C {}
 
         main() => new C();
         """
       ]),
 
   'CONST_METHOD': new Message(
       id: 'GRKIQE',
       subId: 3,
-      // The specialization could also be 1, but the example below triggers 0.
-      specializationOf: 0,
+      // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
+      // example below triggers 'EXTRANEOUS_MODIFIER'.
+      specializationOf: 'EXTRANEOUS_MODIFIER',
       category: Category.parserError,
       template: "Getters, setters and methods can't be declared to be 'const'",
       howToFix: "Try removing the 'const' keyword.",
       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 1, but the example below triggers 0.
-      specializationOf: 0,
+      // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
+      // example below triggers 'EXTRANEOUS_MODIFIER'.
+      specializationOf: 'EXTRANEOUS_MODIFIER',
       category: 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 1, but the example below triggers 0.
-      specializationOf: 0,
+      // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
+      // example below triggers 'EXTRANEOUS_MODIFIER'.
+      specializationOf: 'EXTRANEOUS_MODIFIER',
       category: 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 1, but the example below triggers 0.
-      specializationOf: 0,
+      // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
+      // example below triggers 'EXTRANEOUS_MODIFIER'.
+      specializationOf: 'EXTRANEOUS_MODIFIER',
       category: 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
       ],
       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 1, but the example below triggers 0.
-      specializationOf: 0,
+      // The specialization could also be 'EXTRANEOUS_MODIFIER_REPLACE', but the
+      // example below triggers 'EXTRANEOUS_MODIFIER'.
+      specializationOf: 'EXTRANEOUS_MODIFIER',
       category: 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
       ],
       examples: const [
         "var const x = 499; main() {}",
         "const var x = 499; main() {}",
         "class A { var const x = 499; } main() {}",
@@ skipping 91 matching lines @@
         """
         foo() async* { return 0; }
         main() => foo();
         """,
         """
         foo() sync* { return 0; }
         main() => foo();
         """
       ]),
 };