[messages] Migrate shared_type_analyzer.dart to literate diagnostic reporting.

For all the diagnostic messages used by `shared_type_analyzer.dart`,
replaces the placeholder parameter names `p0`, `p1`, `p2`, etc. with
descriptive parameter names, and updates the call sites that use those
diagnostic messages to use the new literate diagnostic reporting API.

The changes to `dart` code had to be done manually, since the types
substituted into the diagnostic messages needed to be converted from
`SharedTypeView` to `TypeImpl` by calling
`.unwrapTypeView<TypeImpl>()`.

Change-Id: I6a6a6964147dbb304cb21b3fed427ab0d5ed1e6d
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/467740
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Paul Berry <[email protected]>
Reviewed-by: Johnni Winther <[email protected]>

Author: stereotype441

pkg/analyzer/lib/src/dart/resolver/shared_type_analyzer.dart

@@ -8,6 +8,7 @@ import 'package:_fe_analyzer_shared/src/type_inference/type_analyzer.dart'
 import 'package:_fe_analyzer_shared/src/types/shared_type.dart';
 import 'package:analyzer/src/dart/ast/ast.dart';
 import 'package:analyzer/src/dart/element/element.dart';
+import 'package:analyzer/src/dart/element/type.dart';
 import 'package:analyzer/src/diagnostic/diagnostic.dart' as diag;
 import 'package:analyzer/src/diagnostic/diagnostic_factory.dart';
 import 'package:analyzer/src/error/listener.dart';
@@ -42,10 +43,13 @@ class SharedTypeAnalyzerErrors
     required SharedTypeView scrutineeType,
     required SharedTypeView caseExpressionType,
   }) {
-    _diagnosticReporter.atNode(
-      caseExpression,
-      diag.caseExpressionTypeIsNotSwitchExpressionSubtype,
-      arguments: [caseExpressionType, scrutineeType],
+    _diagnosticReporter.report(
+      diag.caseExpressionTypeIsNotSwitchExpressionSubtype
+          .withArguments(
+            caseExpressionType: caseExpressionType.unwrapTypeView<TypeImpl>(),
+            scrutineeType: scrutineeType.unwrapTypeView<TypeImpl>(),
+          )
+          .at(caseExpression),
     );
   }
 
@@ -110,10 +114,14 @@ class SharedTypeAnalyzerErrors
     required PromotableElementImpl variable,
     required PromotableElementImpl component,
   }) {
-    _diagnosticReporter.atElement2(
-      component,
-      diag.inconsistentPatternVariableLogicalOr,
-      arguments: [variable.name!],
+    // Local variables are never synthetic.
+    assert(identical(component.nonSynthetic, component));
+    var offset = component.firstFragment.nameOffset ?? 0;
+    var length = component.name?.length ?? 1;
+    _diagnosticReporter.report(
+      diag.inconsistentPatternVariableLogicalOr
+          .withArguments(name: variable.name!)
+          .atOffset(offset: offset, length: length),
     );
   }
 
@@ -155,10 +163,13 @@ class SharedTypeAnalyzerErrors
     required Expression expression,
     required SharedTypeView expressionType,
   }) {
-    _diagnosticReporter.atNode(
-      expression,
-      diag.forInOfInvalidType,
-      arguments: [expressionType, 'Iterable'],
+    _diagnosticReporter.report(
+      diag.forInOfInvalidType
+          .withArguments(
+            expressionType: expressionType.unwrapTypeView<TypeImpl>(),
+            expectedType: 'Iterable',
+          )
+          .at(expression),
     );
   }
 
@@ -169,10 +180,13 @@ class SharedTypeAnalyzerErrors
     required SharedTypeView matchedType,
     required SharedTypeView requiredType,
   }) {
-    _diagnosticReporter.atNode(
-      pattern,
-      diag.patternTypeMismatchInIrrefutableContext,
-      arguments: [matchedType, requiredType],
+    _diagnosticReporter.report(
+      diag.patternTypeMismatchInIrrefutableContext
+          .withArguments(
+            matchedType: matchedType.unwrapTypeView<TypeImpl>(),
+            requiredType: requiredType.unwrapTypeView<TypeImpl>(),
+          )
+          .at(pattern),
     );
   }
 
@@ -192,10 +206,14 @@ class SharedTypeAnalyzerErrors
     required SharedTypeView operandType,
     required SharedTypeView parameterType,
   }) {
-    _diagnosticReporter.atNode(
-      pattern.operand,
-      diag.relationalPatternOperandTypeNotAssignable,
-      arguments: [operandType, parameterType, pattern.operator.lexeme],
+    _diagnosticReporter.report(
+      diag.relationalPatternOperandTypeNotAssignable
+          .withArguments(
+            operandType: operandType.unwrapTypeView<TypeImpl>(),
+            parameterType: parameterType.unwrapTypeView<TypeImpl>(),
+            operator: pattern.operator.lexeme,
+          )
+          .at(pattern.operand),
     );
   }
 

pkg/analyzer/lib/src/diagnostic/diagnostic.g.dart

@@ -1338,10 +1338,13 @@ caseExpressionTypeImplementsEquals = DiagnosticWithArguments(
 );
 
 /// Parameters:
-/// Type p0: the type of the case expression
-/// Type p1: the type of the switch expression
+/// Type caseExpressionType: the type of the case expression
+/// Type scrutineeType: the type of the switch expression
 const DiagnosticWithArguments<
-  LocatableDiagnostic Function({required DartType p0, required DartType p1})
+  LocatableDiagnostic Function({
+    required DartType caseExpressionType,
+    required DartType scrutineeType,
+  })
 >
 caseExpressionTypeIsNotSwitchExpressionSubtype = DiagnosticWithArguments(
   name: 'case_expression_type_is_not_switch_expression_subtype',
@@ -6148,11 +6151,14 @@ forInOfInvalidElementType = DiagnosticWithArguments(
 );
 
 /// Parameters:
-/// Type p0: the type of the iterable expression.
-/// String p1: the sequence type -- Iterable for `for` or Stream for `await
-///            for`.
+/// Type expressionType: the type of the iterable expression.
+/// String expectedType: the sequence type -- Iterable for `for` or Stream for
+///                      `await for`.
 const DiagnosticWithArguments<
-  LocatableDiagnostic Function({required DartType p0, required String p1})
+  LocatableDiagnostic Function({
+    required DartType expressionType,
+    required String expectedType,
+  })
 >
 forInOfInvalidType = DiagnosticWithArguments(
   name: 'for_in_of_invalid_type',
@@ -7087,9 +7093,9 @@ const DiagnosticWithoutArguments inconsistentLanguageVersionOverride =
     );
 
 /// Parameters:
-/// String p0: the name of the pattern variable
+/// String name: the name of the pattern variable
 const DiagnosticWithArguments<
-  LocatableDiagnostic Function({required String p0})
+  LocatableDiagnostic Function({required String name})
 >
 inconsistentPatternVariableLogicalOr = DiagnosticWithArguments(
   name: 'inconsistent_pattern_variable_logical_or',
@@ -13190,10 +13196,13 @@ patternNeverMatchesValueType = DiagnosticWithArguments(
 );
 
 /// Parameters:
-/// Type p0: the matched type
-/// Type p1: the required type
+/// Type matchedType: the matched type
+/// Type requiredType: the required type
 const DiagnosticWithArguments<
-  LocatableDiagnostic Function({required DartType p0, required DartType p1})
+  LocatableDiagnostic Function({
+    required DartType matchedType,
+    required DartType requiredType,
+  })
 >
 patternTypeMismatchInIrrefutableContext = DiagnosticWithArguments(
   name: 'pattern_type_mismatch_in_irrefutable_context',
@@ -14090,14 +14099,14 @@ refutablePatternInIrrefutableContext = DiagnosticWithoutArgumentsImpl(
 );
 
 /// Parameters:
-/// Type p0: the operand type
-/// Type p1: the parameter type of the invoked operator
-/// String p2: the name of the invoked operator
+/// Type operandType: the operand type
+/// Type parameterType: the parameter type of the invoked operator
+/// String operator: the name of the invoked operator
 const DiagnosticWithArguments<
   LocatableDiagnostic Function({
-    required DartType p0,
-    required DartType p1,
-    required String p2,
+    required DartType operandType,
+    required DartType parameterType,
+    required String operator,
   })
 >
 relationalPatternOperandTypeNotAssignable = DiagnosticWithArguments(
@@ -18007,12 +18016,12 @@ LocatableDiagnostic _withArgumentsCaseExpressionTypeImplementsEquals({
 
 LocatableDiagnostic
 _withArgumentsCaseExpressionTypeIsNotSwitchExpressionSubtype({
-  required DartType p0,
-  required DartType p1,
+  required DartType caseExpressionType,
+  required DartType scrutineeType,
 }) {
   return LocatableDiagnosticImpl(
     diag.caseExpressionTypeIsNotSwitchExpressionSubtype,
-    [p0, p1],
+    [caseExpressionType, scrutineeType],
   );
 }
 
@@ -18921,10 +18930,13 @@ LocatableDiagnostic _withArgumentsForInOfInvalidElementType({
 }
 
 LocatableDiagnostic _withArgumentsForInOfInvalidType({
-  required DartType p0,
-  required String p1,
+  required DartType expressionType,
+  required String expectedType,
 }) {
-  return LocatableDiagnosticImpl(diag.forInOfInvalidType, [p0, p1]);
+  return LocatableDiagnosticImpl(diag.forInOfInvalidType, [
+    expressionType,
+    expectedType,
+  ]);
 }
 
 LocatableDiagnostic _withArgumentsGenericStructSubclass({
@@ -19140,10 +19152,10 @@ LocatableDiagnostic _withArgumentsInconsistentInheritanceGetterAndMethod({
 }
 
 LocatableDiagnostic _withArgumentsInconsistentPatternVariableLogicalOr({
-  required String p0,
+  required String name,
 }) {
   return LocatableDiagnosticImpl(diag.inconsistentPatternVariableLogicalOr, [
-    p0,
+    name,
   ]);
 }
 
@@ -20299,12 +20311,12 @@ LocatableDiagnostic _withArgumentsPatternNeverMatchesValueType({
 }
 
 LocatableDiagnostic _withArgumentsPatternTypeMismatchInIrrefutableContext({
-  required DartType p0,
-  required DartType p1,
+  required DartType matchedType,
+  required DartType requiredType,
 }) {
   return LocatableDiagnosticImpl(diag.patternTypeMismatchInIrrefutableContext, [
-    p0,
-    p1,
+    matchedType,
+    requiredType,
   ]);
 }
 
@@ -20501,13 +20513,13 @@ LocatableDiagnostic _withArgumentsReferencedBeforeDeclaration({
 }
 
 LocatableDiagnostic _withArgumentsRelationalPatternOperandTypeNotAssignable({
-  required DartType p0,
-  required DartType p1,
-  required String p2,
+  required DartType operandType,
+  required DartType parameterType,
+  required String operator,
 }) {
   return LocatableDiagnosticImpl(
     diag.relationalPatternOperandTypeNotAssignable,
-    [p0, p1, p2],
+    [operandType, parameterType, operator],
   );
 }
 

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

@@ -2958,10 +2958,13 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
     String loopNamedType = awaitKeyword != null ? 'Stream' : 'Iterable';
 
     if (iterableType is DynamicType && strictCasts) {
-      diagnosticReporter.atNode(
-        node.iterable,
-        diag.forInOfInvalidType,
-        arguments: [iterableType, loopNamedType],
+      diagnosticReporter.report(
+        diag.forInOfInvalidType
+            .withArguments(
+              expressionType: iterableType,
+              expectedType: loopNamedType,
+            )
+            .at(node.iterable),
       );
       return false;
     }
@@ -2997,10 +3000,13 @@ class ErrorVerifier extends RecursiveAstVisitor<void>
       requiredSequenceType,
       strictCasts: strictCasts,
     )) {
-      diagnosticReporter.atNode(
-        node.iterable,
-        diag.forInOfInvalidType,
-        arguments: [iterableType, loopNamedType],
+      diagnosticReporter.report(
+        diag.forInOfInvalidType
+            .withArguments(
+              expressionType: iterableType,
+              expectedType: loopNamedType,
+            )
+            .at(node.iterable),
       );
       return false;
     }

pkg/analyzer/messages.yaml

@@ -2432,9 +2432,9 @@ CompileTimeErrorCode:
   caseExpressionTypeIsNotSwitchExpressionSubtype:
     type: compileTimeError
     parameters:
-      Type p0: the type of the case expression
-      Type p1: the type of the switch expression
-    problemMessage: "The switch case expression type '#p0' must be a subtype of the switch expression type '#p1'."
+      Type caseExpressionType: the type of the case expression
+      Type scrutineeType: the type of the switch expression
+    problemMessage: "The switch case expression type '#caseExpressionType' must be a subtype of the switch expression type '#scrutineeType'."
     hasPublishedDocs: true
     documentation: |-
       #### Description
@@ -7601,9 +7601,9 @@ CompileTimeErrorCode:
   forInOfInvalidType:
     type: compileTimeError
     parameters:
-      Type p0: the type of the iterable expression.
-      String p1: the sequence type -- Iterable for `for` or Stream for `await for`.
-    problemMessage: "The type '#p0' used in the 'for' loop must implement '#p1'."
+      Type expressionType: the type of the iterable expression.
+      String expectedType: the sequence type -- Iterable for `for` or Stream for `await for`.
+    problemMessage: "The type '#expressionType' used in the 'for' loop must implement '#expectedType'."
     hasPublishedDocs: true
     documentation: |-
       #### Description
@@ -8510,8 +8510,8 @@ CompileTimeErrorCode:
   inconsistentPatternVariableLogicalOr:
     type: compileTimeError
     parameters:
-      String p0: the name of the pattern variable
-    problemMessage: "The variable '#p0' has a different type and/or finality in this branch of the logical-or pattern."
+      String name: the name of the pattern variable
+    problemMessage: "The variable '#name' has a different type and/or finality in this branch of the logical-or pattern."
     correctionMessage: Try declaring the variable pattern with the same type and finality in both branches.
     hasPublishedDocs: true
     documentation: |-
@@ -14402,9 +14402,9 @@ CompileTimeErrorCode:
   patternTypeMismatchInIrrefutableContext:
     type: compileTimeError
     parameters:
-      Type p0: the matched type
-      Type p1: the required type
-    problemMessage: "The matched value of type '#p0' isn't assignable to the required type '#p1'."
+      Type matchedType: the matched type
+      Type requiredType: the required type
+    problemMessage: "The matched value of type '#matchedType' isn't assignable to the required type '#requiredType'."
     correctionMessage: "Try changing the required type of the pattern, or the matched value type."
     hasPublishedDocs: true
     documentation: |-
@@ -15870,10 +15870,10 @@ CompileTimeErrorCode:
   relationalPatternOperandTypeNotAssignable:
     type: compileTimeError
     parameters:
-      Type p0: the operand type
-      Type p1: the parameter type of the invoked operator
-      String p2: the name of the invoked operator
-    problemMessage: "The constant expression type '#p0' is not assignable to the parameter type '#p1' of the '#p2' operator."
+      Type operandType: the operand type
+      Type parameterType: the parameter type of the invoked operator
+      String operator: the name of the invoked operator
+    problemMessage: "The constant expression type '#operandType' is not assignable to the parameter type '#parameterType' of the '#operator' operator."
     hasPublishedDocs: true
     documentation: |-
       #### Description