Analyzer: Recategorize COULD_NOT_INFER as CompileTimeErrorCode

Change-Id: I2aec1fd6499fcbcc35e7cf9b765dd43559d3ef67
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/155846
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: srawlins

pkg/analyzer/lib/error/error.dart

@@ -139,6 +139,7 @@ const List<ErrorCode> errorCodeValues = [
   CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR,
   CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT,
   CompileTimeErrorCode.CONTINUE_LABEL_ON_SWITCH,
+  CompileTimeErrorCode.COULD_NOT_INFER,
   CompileTimeErrorCode.DEFAULT_LIST_CONSTRUCTOR,
   CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER,
   CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR,
@@ -790,7 +791,6 @@ const List<ErrorCode> errorCodeValues = [
   StaticWarningCode.INVALID_OVERRIDE_DIFFERENT_DEFAULT_VALUES_POSITIONAL,
   StaticWarningCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
   StaticWarningCode.UNNECESSARY_NON_NULL_ASSERTION,
-  StrongModeCode.COULD_NOT_INFER,
   StrongModeCode.IMPLICIT_DYNAMIC_FIELD,
   StrongModeCode.IMPLICIT_DYNAMIC_FUNCTION,
   StrongModeCode.IMPLICIT_DYNAMIC_INVOKE,

pkg/analyzer/lib/src/dart/element/generic_inferrer.dart

@@ -17,7 +17,8 @@ import 'package:analyzer/src/dart/element/type_constraint_gatherer.dart';
 import 'package:analyzer/src/dart/element/type_demotion.dart';
 import 'package:analyzer/src/dart/element/type_schema.dart';
 import 'package:analyzer/src/dart/element/type_system.dart';
-import 'package:analyzer/src/error/codes.dart' show HintCode, StrongModeCode;
+import 'package:analyzer/src/error/codes.dart'
+    show CompileTimeErrorCode, HintCode;
 import 'package:meta/meta.dart';
 
 /// Tracks upper and lower type bounds for a set of type parameters.
@@ -187,7 +188,7 @@ class GenericInferrer {
       if (!success) {
         if (failAtError) return null;
         errorReporter?.reportErrorForNode(
-            StrongModeCode.COULD_NOT_INFER,
+            CompileTimeErrorCode.COULD_NOT_INFER,
             errorNode,
             [typeParam.name, _formatError(typeParam, inferred, constraints)]);
 
@@ -201,8 +202,8 @@ class GenericInferrer {
         if (failAtError) return null;
         var typeFormals = (inferred as FunctionType).typeFormals;
         var typeFormalsStr = typeFormals.map(_elementStr).join(', ');
-        errorReporter
-            ?.reportErrorForNode(StrongModeCode.COULD_NOT_INFER, errorNode, [
+        errorReporter?.reportErrorForNode(
+            CompileTimeErrorCode.COULD_NOT_INFER, errorNode, [
           typeParam.name,
           ' Inferred candidate type ${_typeStr(inferred)} has type parameters'
               ' [$typeFormalsStr], but a function with'
@@ -248,8 +249,8 @@ class GenericInferrer {
         var typeParamBound = Substitution.fromPairs(typeFormals, inferredTypes)
             .substituteType(typeParam.bound ?? typeProvider.objectType);
         // TODO(jmesserly): improve this error message.
-        errorReporter
-            ?.reportErrorForNode(StrongModeCode.COULD_NOT_INFER, errorNode, [
+        errorReporter?.reportErrorForNode(
+            CompileTimeErrorCode.COULD_NOT_INFER, errorNode, [
           typeParam.name,
           "\nRecursive bound cannot be instantiated: '$typeParamBound'."
               "\nConsider passing explicit type argument(s) "

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

@@ -1321,6 +1321,14 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
           correction: "Try converting the getter to a method, or "
               "renaming the field to a name that doesn't conflict.");
 
+  /**
+   * Parameters:
+   * 0: the name of the type parameter
+   * 1: detail text explaining why the type could not be inferred
+   */
+  static const CompileTimeErrorCode COULD_NOT_INFER = CompileTimeErrorCode(
+      'COULD_NOT_INFER', "Couldn't infer type parameter '{0}'.{1}");
+
   /**
    * 10.10 Superinterfaces: It is a compile-time error if a class `C` has two
    * superinterfaces that are different instantiations of the same generic
@@ -1330,7 +1338,7 @@ class CompileTimeErrorCode extends AnalyzerErrorCode {
    * Parameters:
    * 0: the name of the class implementing the conflicting interface
    * 1: the first conflicting type
-   * 1: the second conflicting type
+   * 2: the second conflicting type
    */
   static const CompileTimeErrorCode CONFLICTING_GENERIC_INTERFACES =
       CompileTimeErrorCode(
@@ -10690,11 +10698,6 @@ class StrongModeCode extends ErrorCode {
       "Try adding an explicit type like 'dynamic', or "
       "enable implicit-dynamic in your analysis options file.";
 
-  static const StrongModeCode COULD_NOT_INFER = StrongModeCode(
-      ErrorType.COMPILE_TIME_ERROR,
-      'COULD_NOT_INFER',
-      "Couldn't infer type parameter '{0}'.{1}");
-
   static const StrongModeCode IMPLICIT_DYNAMIC_FIELD = StrongModeCode(
       ErrorType.COMPILE_TIME_ERROR,
       'IMPLICIT_DYNAMIC_FIELD',

pkg/analyzer/test/generated/compile_time_error_code.dart

@@ -335,7 +335,7 @@ var b = const bool.fromEnvironment('x', defaultValue: 1);
 T f<T>(T t) => null;
 main() { f(<S>(S s) => s); }
 ''', [
-      error(StrongModeCode.COULD_NOT_INFER, 30, 1),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 30, 1),
     ]);
   }
 
@@ -344,7 +344,7 @@ main() { f(<S>(S s) => s); }
 T Function<T>(T) f;
 main() { f(<S>(S s) => s); }
 ''', [
-      error(StrongModeCode.COULD_NOT_INFER, 29, 1),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 29, 1),
     ]);
   }
 
@@ -355,7 +355,7 @@ class C {
 }
 main() { new C().f(<S>(S s) => s); }
 ''', [
-      error(StrongModeCode.COULD_NOT_INFER, 52, 1),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 52, 1),
     ]);
   }
 

pkg/analyzer/test/generated/strong_mode_test.dart

@@ -335,9 +335,9 @@ class StrongModeLocalInferenceTest extends ResolverTestCase {
 
   test_constrainedByBounds5() async {
     // Test that upwards inference with two type variables does not
-    // propogate from the constrained variable to the unconstrained
+    // propagate from the constrained variable to the unconstrained
     // variable if they are ordered right to left, when the variable
-    // appears co and contra variantly, and that an error is issued
+    // appears co- and contra-variantly, and that an error is issued
     // for the non-matching bound.
     String code = r'''
     typedef To Func1<From, To>(From x);
@@ -346,7 +346,7 @@ class StrongModeLocalInferenceTest extends ResolverTestCase {
    ''';
     Source source = addSource(code);
     TestAnalysisResult analysisResult = await computeAnalysisResult(source);
-    assertErrors(source, [StrongModeCode.COULD_NOT_INFER]);
+    assertErrors(source, [CompileTimeErrorCode.COULD_NOT_INFER]);
     verify([source]);
     CompilationUnit unit = analysisResult.unit;
     List<Statement> statements =
@@ -981,7 +981,7 @@ class StrongModeLocalInferenceTest extends ResolverTestCase {
     MethodInvocation invoke = await _testFutureOr(r'''
     Future<T> mk<T extends Future<Object>>(FutureOr<T> x) => null;
     dynamic test() => mk(new Future<int>.value(42));
-    ''', errors: [StrongModeCode.COULD_NOT_INFER]);
+    ''', errors: [CompileTimeErrorCode.COULD_NOT_INFER]);
     _isFutureOfInt(invoke.staticType);
   }
 
@@ -1093,7 +1093,7 @@ test() {
  ''');
     await computeAnalysisResult(source);
     _expectInferenceError(source, [
-      StrongModeCode.COULD_NOT_INFER,
+      CompileTimeErrorCode.COULD_NOT_INFER,
       CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ], r'''
 Couldn't infer type parameter 'T'.
@@ -1119,7 +1119,7 @@ test() {
  ''');
     await computeAnalysisResult(source);
     _expectInferenceError(source, [
-      StrongModeCode.COULD_NOT_INFER,
+      CompileTimeErrorCode.COULD_NOT_INFER,
       CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE,
       CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ], r'''
@@ -1170,7 +1170,7 @@ test() {
  ''');
     await computeAnalysisResult(source);
     _expectInferenceError(source, [
-      StrongModeCode.COULD_NOT_INFER,
+      CompileTimeErrorCode.COULD_NOT_INFER,
     ], r'''
 Couldn't infer type parameter 'T'.
 
@@ -1198,7 +1198,7 @@ test(Iterable values) {
  ''');
     await computeAnalysisResult(source);
     _expectInferenceError(source, [
-      StrongModeCode.COULD_NOT_INFER,
+      CompileTimeErrorCode.COULD_NOT_INFER,
       CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ], r'''
 Couldn't infer type parameter 'T'.
@@ -1223,7 +1223,7 @@ test() {
 }
  ''');
     await computeAnalysisResult(source);
-    _expectInferenceError(source, [StrongModeCode.COULD_NOT_INFER], r'''
+    _expectInferenceError(source, [CompileTimeErrorCode.COULD_NOT_INFER], r'''
 Couldn't infer type parameter 'T'.
 
 Tried to infer 'num' for 'T' which doesn't work:
@@ -1364,7 +1364,7 @@ num test(Iterable values) => values.fold(values.first as num, max);
     ''');
     var analysisResult = await computeAnalysisResult(source);
     assertErrors(source, [
-      StrongModeCode.COULD_NOT_INFER,
+      CompileTimeErrorCode.COULD_NOT_INFER,
       CompileTimeErrorCode.ARGUMENT_TYPE_NOT_ASSIGNABLE
     ]);
     verify([source]);
@@ -2375,7 +2375,7 @@ class B<T2, U2> {
     assertErrors(source, errorCodes);
     var errors = analysisResults[source]
         .errors
-        .where((e) => e.errorCode == StrongModeCode.COULD_NOT_INFER)
+        .where((e) => e.errorCode == CompileTimeErrorCode.COULD_NOT_INFER)
         .map((e) => e.message)
         .toList();
     expect(errors.length, 1);
@@ -3341,7 +3341,7 @@ void test() {
 ''', [
       error(HintCode.UNUSED_LOCAL_VARIABLE, 73, 1),
       error(CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS, 81, 1),
-      error(StrongModeCode.COULD_NOT_INFER, 81, 1),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 81, 1),
     ]);
     _assertLocalVarType('c', 'C<List<dynamic>, List<List<dynamic>>>');
   }
@@ -3456,7 +3456,7 @@ void g() {
 ''', [
       error(HintCode.MISSING_RETURN, 3, 1),
       error(HintCode.UNUSED_LOCAL_VARIABLE, 69, 1),
-      error(StrongModeCode.COULD_NOT_INFER, 73, 1),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 73, 1),
     ]);
     _assertLocalVarType('c', 'List<dynamic>');
   }

pkg/analyzer/test/src/dart/element/generic_inferrer_test.dart

@@ -616,7 +616,7 @@ class GenericFunctionInferenceTest extends AbstractTypeSystemNullSafetyTest {
 
     if (expectError) {
       expect(listener.errors.map((e) => e.errorCode).toList(),
-          [StrongModeCode.COULD_NOT_INFER],
+          [CompileTimeErrorCode.COULD_NOT_INFER],
           reason: 'expected exactly 1 could not infer error.');
     } else {
       expect(listener.errors, isEmpty, reason: 'did not expect any errors.');

pkg/analyzer/test/src/dart/resolution/simple_identifier_test.dart

@@ -127,7 +127,7 @@ class A {
 @A([min])
 main() {}
 ''', [
-      error(StrongModeCode.COULD_NOT_INFER, 66, 5),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 66, 5),
     ]);
 
     var identifier = findNode.simple('min]');

pkg/analyzer/test/src/dart/resolution/type_inference/extension_methods_test.dart

@@ -306,7 +306,7 @@ f(String s) {
   E(s).foo();
 }
 ''', [
-      error(StrongModeCode.COULD_NOT_INFER, 69, 1),
+      error(CompileTimeErrorCode.COULD_NOT_INFER, 69, 1),
     ]);
     var override = findNode.extensionOverride('E(s)');
     assertElementTypeStrings(override.typeArgumentTypes, ['String']);