fix #26122, classify strong mode errors correctly

pkg/analyzer/lib/src/generated/error.dart

 // Copyright (c) 2014, 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.
 
 library analyzer.src.generated.error;
 
 import 'dart:collection';
 
 import 'package:analyzer/dart/ast/ast.dart' show AstNode;
 import 'package:analyzer/dart/ast/token.dart';
@@ skipping 4908 matching lines @@
   /**
    * 5 Variables: It is a static warning if a library, static or local variable
    * <i>v</i> is final and <i>v</i> is not initialized at its point of
    * declaration.
    *
    * Parameters:
    * 0: the name of the uninitialized final variable
    */
   static const StaticWarningCode FINAL_NOT_INITIALIZED =
       const StaticWarningCode('FINAL_NOT_INITIALIZED',
-          "The final variable '{0}' must be initialized");
+          "The final variable '{0}' must be initialized", null, false);
 
   /**
    * 7.6.1 Generative Constructors: Each final instance variable <i>f</i>
    * declared in the immediately enclosing class must have an initializer in
    * <i>k</i>'s initializer list unless it has already been initialized by one
    * of the following means:
    * * Initialization at the declaration of <i>f</i>.
    * * Initialization by means of an initializing formal of <i>k</i>.
    * or a static warning occurs.
    *
    * Parameters:
    * 0: the name of the uninitialized final variable
    */
   static const StaticWarningCode FINAL_NOT_INITIALIZED_CONSTRUCTOR_1 =
       const StaticWarningCode('FINAL_NOT_INITIALIZED_CONSTRUCTOR_1',
-          "The final variable '{0}' must be initialized");
+          "The final variable '{0}' must be initialized", null, false);
 
   /**
    * 7.6.1 Generative Constructors: Each final instance variable <i>f</i>
    * declared in the immediately enclosing class must have an initializer in
    * <i>k</i>'s initializer list unless it has already been initialized by one
    * of the following means:
    * * Initialization at the declaration of <i>f</i>.
    * * Initialization by means of an initializing formal of <i>k</i>.
    * or a static warning occurs.
    *
    * Parameters:
    * 0: the name of the uninitialized final variable
    * 1: the name of the uninitialized final variable
    */
   static const StaticWarningCode FINAL_NOT_INITIALIZED_CONSTRUCTOR_2 =
-      const StaticWarningCode('FINAL_NOT_INITIALIZED_CONSTRUCTOR_2',
-          "The final variables '{0}' and '{1}' must be initialized");
+      const StaticWarningCode(
+          'FINAL_NOT_INITIALIZED_CONSTRUCTOR_2',
+          "The final variables '{0}' and '{1}' must be initialized",
+          null,
+          false);
 
   /**
    * 7.6.1 Generative Constructors: Each final instance variable <i>f</i>
    * declared in the immediately enclosing class must have an initializer in
    * <i>k</i>'s initializer list unless it has already been initialized by one
    * of the following means:
    * * Initialization at the declaration of <i>f</i>.
    * * Initialization by means of an initializing formal of <i>k</i>.
    * or a static warning occurs.
    *
    * Parameters:
    * 0: the name of the uninitialized final variable
    * 1: the name of the uninitialized final variable
    * 2: the number of additional not initialized variables that aren't listed
    */
   static const StaticWarningCode FINAL_NOT_INITIALIZED_CONSTRUCTOR_3_PLUS =
-      const StaticWarningCode('FINAL_NOT_INITIALIZED_CONSTRUCTOR_3',
-          "The final variables '{0}', '{1}' and '{2}' more must be initialized");
+      const StaticWarningCode(
+          'FINAL_NOT_INITIALIZED_CONSTRUCTOR_3',
+          "The final variables '{0}', '{1}' and '{2}' more must be initialized",
+          null,
+          false);
 
   /**
    * 15.5 Function Types: It is a static warning if a concrete class implements
    * Function and does not have a concrete method named call().
    */
   static const StaticWarningCode FUNCTION_WITHOUT_CALL = const StaticWarningCode(
       'FUNCTION_WITHOUT_CALL',
       "Concrete classes that implement Function must implement the method call()");
 
   /**
@@ skipping 300 matching lines @@
   static const StaticWarningCode MAP_VALUE_TYPE_NOT_ASSIGNABLE =
       const StaticWarningCode('MAP_VALUE_TYPE_NOT_ASSIGNABLE',
           "The element type '{0}' cannot be assigned to the map value type '{1}'");
 
   /**
    * 7.3 Setters: It is a static warning if a class has a setter named <i>v=</i>
    * with argument type <i>T</i> and a getter named <i>v</i> with return type
    * <i>S</i>, and <i>T</i> may not be assigned to <i>S</i>.
    */
   static const StaticWarningCode MISMATCHED_GETTER_AND_SETTER_TYPES =
-      const StaticWarningCode('MISMATCHED_GETTER_AND_SETTER_TYPES',
-          "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}')");
+      const StaticWarningCode(
+          'MISMATCHED_GETTER_AND_SETTER_TYPES',
+          "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}')",
+          null,
+          false);
 
   /**
    * 7.3 Setters: It is a static warning if a class has a setter named <i>v=</i>
    * with argument type <i>T</i> and a getter named <i>v</i> with return type
    * <i>S</i>, and <i>T</i> may not be assigned to <i>S</i>.
    */
   static const StaticWarningCode
       MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE =
       const StaticWarningCode(
           'MISMATCHED_GETTER_AND_SETTER_TYPES_FROM_SUPERTYPE',
-          "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}'), from superclass '{3}'");
+          "The parameter type for setter '{0}' is '{1}' which is not assignable to its getter (of type '{2}'), from superclass '{3}'",
+          null,
+          false);
 
   /**
    * 13.12 Return: It is a static warning if a function contains both one or
    * more return statements of the form <i>return;</i> and one or more return
    * statements of the form <i>return e;</i>.
    */
   static const StaticWarningCode MIXED_RETURN_TYPES = const StaticWarningCode(
       'MIXED_RETURN_TYPES',
-      "Methods and functions cannot use return both with and without values");
+      "Methods and functions cannot use return both with and without values",
+      null,
+      false);
 
   /**
    * 12.11.1 New: It is a static warning if <i>q</i> is a constructor of an
    * abstract class and <i>q</i> is not a factory constructor.
    */
   static const StaticWarningCode NEW_WITH_ABSTRACT_CLASS =
       const StaticWarningCode('NEW_WITH_ABSTRACT_CLASS',
           "Abstract classes cannot be created with a 'new' expression");
 
   /**
@@ skipping 191 matching lines @@
   static const StaticWarningCode NON_TYPE_IN_CATCH_CLAUSE =
       const StaticWarningCode('NON_TYPE_IN_CATCH_CLAUSE',
           "The name '{0}' is not a type and cannot be used in an on-catch clause");
 
   /**
    * 7.1.1 Operators: It is a static warning if the return type of the
    * user-declared operator []= is explicitly declared and not void.
    */
   static const StaticWarningCode NON_VOID_RETURN_FOR_OPERATOR =
       const StaticWarningCode('NON_VOID_RETURN_FOR_OPERATOR',
-          "The return type of the operator []= must be 'void'");
+          "The return type of the operator []= must be 'void'", null, false);
 
   /**
    * 7.3 Setters: It is a static warning if a setter declares a return type
    * other than void.
    */
   static const StaticWarningCode NON_VOID_RETURN_FOR_SETTER =
       const StaticWarningCode('NON_VOID_RETURN_FOR_SETTER',
-          "The return type of the setter must be 'void'");
+          "The return type of the setter must be 'void'", null, false);
 
   /**
    * 15.1 Static Types: A type <i>T</i> is malformed iff:
    * * <i>T</i> has the form <i>id</i> or the form <i>prefix.id</i>, and in the
    *   enclosing lexical scope, the name <i>id</i> (respectively
    *   <i>prefix.id</i>) does not denote a type.
    * * <i>T</i> denotes a type parameter in the enclosing lexical scope, but
    * occurs in the signature or body of a static member.
    * * <i>T</i> is a parameterized type of the form <i>G&lt;S<sub>1</sub>, ..,
    * S<sub>n</sub>&gt;</i>,
@@ skipping 78 matching lines @@
       "The name '{0}' is not a type and cannot be used in a redirected constructor");
 
   /**
    * 13.12 Return: Let <i>f</i> be the function immediately enclosing a return
    * statement of the form <i>return;</i> It is a static warning if both of the
    * following conditions hold:
    * * <i>f</i> is not a generative constructor.
    * * The return type of <i>f</i> may not be assigned to void.
    */
   static const StaticWarningCode RETURN_WITHOUT_VALUE = const StaticWarningCode(
-      'RETURN_WITHOUT_VALUE', "Missing return value after 'return'");
+      'RETURN_WITHOUT_VALUE',
+      "Missing return value after 'return'",
+      null,
+      false);
 
   /**
    * 12.16.3 Static Invocation: It is a static warning if <i>C</i> does not
    * declare a static method or getter <i>m</i>.
    *
    * Parameters:
    * 0: the name of the instance member
    */
   static const StaticWarningCode STATIC_ACCESS_TO_INSTANCE_MEMBER =
       const StaticWarningCode('STATIC_ACCESS_TO_INSTANCE_MEMBER',
@@ skipping 162 matching lines @@
    * 1: the name of the enclosing type where the setter is being looked for
    */
   static const StaticWarningCode UNDEFINED_SUPER_SETTER =
       shared_messages.UNDEFINED_SUPER_SETTER_STATIC_WARNING;
 
   /**
    * 7.2 Getters: It is a static warning if the return type of a getter is void.
    */
   static const StaticWarningCode VOID_RETURN_FOR_GETTER =
       const StaticWarningCode('VOID_RETURN_FOR_GETTER',
-          "The return type of the getter must not be 'void'");
+          "The return type of the getter must not be 'void'", null, false);
 
   /**
    * 17.9 Switch: It is a static warning if all of the following conditions
    * hold:
    * * The switch statement does not have a 'default' clause.
    * * The static type of <i>e</i> is an enumerated typed with elements
    *   <i>id<sub>1</sub></i>, &hellip;, <i>id<sub>n</sub></i>.
    * * The sets {<i>e<sub>1</sub></i>, &hellip;, <i>e<sub>k</sub></i>} and
    *   {<i>id<sub>1</sub></i>, &hellip;, <i>id<sub>n</sub></i>} are not the
    *   same.
    *
    * Parameters:
    * 0: the name of the constant that is missing
    */
   static const StaticWarningCode MISSING_ENUM_CONSTANT_IN_SWITCH =
       const StaticWarningCode(
           'MISSING_ENUM_CONSTANT_IN_SWITCH',
           "Missing case clause for '{0}'",
-          "Add a case clause for the missing constant or add a default clause.");
+          "Add a case clause for the missing constant or add a default clause.",
+          false);
 
   /**
    * A flag indicating whether this warning is an error when running with strong
    * mode enabled.
    */
   final bool isStrongModeError;
 
   /**
    * Initialize a newly created error code to have the given [name]. The message
    * associated with the error will be created from the given [message]
    * template. The correction associated with the error will be created from the
    * given [correction] template.
    */
   const StaticWarningCode(String name, String message,
-      [String correction, this.isStrongModeError = false])
+      [String correction, this.isStrongModeError = true])
       : super(name, message, correction);
 
   @override
   ErrorSeverity get errorSeverity => ErrorType.STATIC_WARNING.severity;
 
   @override
   ErrorType get type => ErrorType.STATIC_WARNING;
 }
 
 /**
@@ skipping 112 matching lines @@
   static const StrongModeCode IMPLICIT_DYNAMIC_VARIABLE = const StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'IMPLICIT_DYNAMIC_VARIABLE',
       "Missing variable type for '{0}'$_implicitDynamicTip");
 
   static const StrongModeCode IMPLICIT_DYNAMIC_FIELD = const StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'IMPLICIT_DYNAMIC_FIELD',
       "Missing field type for '{0}'$_implicitDynamicTip");
 
-  static const StrongModeCode IMPLICIT_DYNAMIC_TYPE =
-      const StrongModeCode(
-          ErrorType.COMPILE_TIME_ERROR,
-          'IMPLICIT_DYNAMIC_TYPE',
-          "Missing type arguments for generic type '{0}'"
-          "$_implicitDynamicTip");
+  static const StrongModeCode IMPLICIT_DYNAMIC_TYPE = const StrongModeCode(
+      ErrorType.COMPILE_TIME_ERROR,
+      'IMPLICIT_DYNAMIC_TYPE',
+      "Missing type arguments for generic type '{0}'"
+      "$_implicitDynamicTip");
 
   static const StrongModeCode IMPLICIT_DYNAMIC_LIST_LITERAL =
       const StrongModeCode(
           ErrorType.COMPILE_TIME_ERROR,
           'IMPLICIT_DYNAMIC_LIST_LITERAL',
           "Missing type argument for list literal$_implicitDynamicTip");
 
   static const StrongModeCode IMPLICIT_DYNAMIC_MAP_LITERAL =
       const StrongModeCode(
           ErrorType.COMPILE_TIME_ERROR,
           'IMPLICIT_DYNAMIC_MAP_LITERAL',
           'Missing type arguments for map literal$_implicitDynamicTip');
 
   static const StrongModeCode IMPLICIT_DYNAMIC_FUNCTION = const StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'IMPLICIT_DYNAMIC_FUNCTION',
       "Missing type arguments for generic function '{0}<{1}>'"
       "$_implicitDynamicTip");
 
   static const StrongModeCode IMPLICIT_DYNAMIC_METHOD = const StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'IMPLICIT_DYNAMIC_METHOD',
       "Missing type arguments for generic method '{0}<{1}>'"
       "$_implicitDynamicTip");
 
   static const StrongModeCode IMPLICIT_DYNAMIC_INVOKE = const StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'IMPLICIT_DYNAMIC_INVOKE',
       "Missing type arguments for calling generic function type '{0}'"
-          "$_implicitDynamicTip");
+      "$_implicitDynamicTip");
 
   @override
   final ErrorType type;
 
   /**
    * Initialize a newly created error code to have the given [type] and [name].
    *
    * The message associated with the error will be created from the given
    * [message] template. The correction associated with the error will be
    * created from the optional [correction] template.
@@ skipping 37 matching lines @@
    * Initialize a newly created error code to have the given [name].
    */
   const TodoCode(String name) : super(name, "{0}");
 
   @override
   ErrorSeverity get errorSeverity => ErrorSeverity.INFO;
 
   @override
   ErrorType get type => ErrorType.TODO;
 }