Bump _fe_analyzer_shared to SDK 3.7 and reformat

Change-Id: I70157caf90c0955c2eb8426f5721ba4ed527eb76
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/427900
Commit-Queue: Konstantin Shcheglov <[email protected]>
Auto-Submit: Paul Berry <[email protected]>
Reviewed-by: Konstantin Shcheglov <[email protected]>

Author: stereotype441

pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_call_counts.dart

@@ -111,11 +111,15 @@ void main() {
 
 /// Test that [cases] are exhaustive over [type] if and only if all cases are
 /// included and that all subsets of the cases are not exhaustive.
-void expectExhaustiveOnlyAll(ObjectPropertyLookup objectFieldLookup,
-    StaticType type, List<Map<String, Object>> cases) {
+void expectExhaustiveOnlyAll(
+  ObjectPropertyLookup objectFieldLookup,
+  StaticType type,
+  List<Map<String, Object>> cases,
+) {
   var spaces = cases.map((c) => ty(type, c)).toList();
   profile.reset();
   print(
-      isExhaustive(objectFieldLookup, Space(const Path.root(), type), spaces));
+    isExhaustive(objectFieldLookup, Space(const Path.root(), type), spaces),
+  );
   profile.log();
 }

pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_fields_timed.dart

@@ -110,8 +110,11 @@ void main() {
 
 /// Test that [cases] are exhaustive over [type] if and only if all cases are
 /// included and that all subsets of the cases are not exhaustive.
-void expectExhaustiveOnlyAll(ObjectPropertyLookup objectFieldLookup,
-    StaticType type, List<Map<String, Object>> cases) {
+void expectExhaustiveOnlyAll(
+  ObjectPropertyLookup objectFieldLookup,
+  StaticType type,
+  List<Map<String, Object>> cases,
+) {
   var valueSpace = Space(const Path.root(), type);
   var caseSpaces = cases.map((c) => ty(type, c)).toList();
 

pkg/_fe_analyzer_shared/benchmark/exhaustiveness/large_subtype_count.dart

@@ -88,12 +88,17 @@ void testFieldCount(int n) {
   expectExhaustive('Field count $n', env, t, [fields]);
 }
 
-void expectExhaustive(String title, ObjectPropertyLookup objectFieldLookup,
-    StaticType type, List<Map<String, Object>> cases) {
+void expectExhaustive(
+  String title,
+  ObjectPropertyLookup objectFieldLookup,
+  StaticType type,
+  List<Map<String, Object>> cases,
+) {
   var spaces = cases.map((c) => ty(type, c)).toList();
   profile.reset();
   print(
-      isExhaustive(objectFieldLookup, Space(const Path.root(), type), spaces));
+    isExhaustive(objectFieldLookup, Space(const Path.root(), type), spaces),
+  );
   print('--------------------------------------------------------------------');
   print(title);
   profile.log();

pkg/_fe_analyzer_shared/lib/src/base/errors.dart

@@ -66,8 +66,8 @@ abstract class DiagnosticCode {
     required this.name,
     required String problemMessage,
     required this.uniqueName,
-  })  : _correctionMessage = correctionMessage,
-        _problemMessage = problemMessage;
+  }) : _correctionMessage = correctionMessage,
+       _problemMessage = problemMessage;
 
   /**
    * The template used to create the correction to be displayed for this error,
@@ -99,7 +99,7 @@ abstract class DiagnosticCode {
     String? correctionMessage = _correctionMessage;
     for (String s in [
       _problemMessage,
-      if (correctionMessage != null) correctionMessage
+      if (correctionMessage != null) correctionMessage,
     ]) {
       for (RegExpMatch match in _positionalArgumentRegExp.allMatches(s)) {
         result = max(result, int.parse(match.group(1)!) + 1);
@@ -145,33 +145,49 @@ class DiagnosticSeverity implements Comparable<DiagnosticSeverity> {
    * The severity representing a non-error. This is never used for any error
    * code, but is useful for clients.
    */
-  static const DiagnosticSeverity NONE =
-      const DiagnosticSeverity('NONE', 0, " ", "none");
+  static const DiagnosticSeverity NONE = const DiagnosticSeverity(
+    'NONE',
+    0,
+    " ",
+    "none",
+  );
 
   /**
    * The severity representing an informational level analysis issue.
    */
-  static const DiagnosticSeverity INFO =
-      const DiagnosticSeverity('INFO', 1, "I", "info");
+  static const DiagnosticSeverity INFO = const DiagnosticSeverity(
+    'INFO',
+    1,
+    "I",
+    "info",
+  );
 
   /**
    * The severity representing a warning. Warnings can become errors if the
    * `-Werror` command line flag is specified.
    */
-  static const DiagnosticSeverity WARNING =
-      const DiagnosticSeverity('WARNING', 2, "W", "warning");
+  static const DiagnosticSeverity WARNING = const DiagnosticSeverity(
+    'WARNING',
+    2,
+    "W",
+    "warning",
+  );
 
   /**
    * The severity representing an error.
    */
-  static const DiagnosticSeverity ERROR =
-      const DiagnosticSeverity('ERROR', 3, "E", "error");
+  static const DiagnosticSeverity ERROR = const DiagnosticSeverity(
+    'ERROR',
+    3,
+    "E",
+    "error",
+  );
 
   static const List<DiagnosticSeverity> values = const [
     NONE,
     INFO,
     WARNING,
-    ERROR
+    ERROR,
   ];
 
   final String name;
@@ -189,7 +205,11 @@ class DiagnosticSeverity implements Comparable<DiagnosticSeverity> {
   final String displayName;
 
   const DiagnosticSeverity(
-      this.name, this.ordinal, this.machineCode, this.displayName);
+    this.name,
+    this.ordinal,
+    this.machineCode,
+    this.displayName,
+  );
 
   @override
   int get hashCode => ordinal;
@@ -219,53 +239,74 @@ class DiagnosticType implements Comparable<DiagnosticType> {
   /**
    * Task (todo) comments in user code.
    */
-  static const DiagnosticType TODO =
-      const DiagnosticType('TODO', 0, DiagnosticSeverity.INFO);
+  static const DiagnosticType TODO = const DiagnosticType(
+    'TODO',
+    0,
+    DiagnosticSeverity.INFO,
+  );
 
   /**
    * Extra analysis run over the code to follow best practices, which are not in
    * the Dart Language Specification.
    */
-  static const DiagnosticType HINT =
-      const DiagnosticType('HINT', 1, DiagnosticSeverity.INFO);
+  static const DiagnosticType HINT = const DiagnosticType(
+    'HINT',
+    1,
+    DiagnosticSeverity.INFO,
+  );
 
   /**
    * Compile-time errors are errors that preclude execution. A compile time
    * error must be reported by a Dart compiler before the erroneous code is
    * executed.
    */
-  static const DiagnosticType COMPILE_TIME_ERROR =
-      const DiagnosticType('COMPILE_TIME_ERROR', 2, DiagnosticSeverity.ERROR);
+  static const DiagnosticType COMPILE_TIME_ERROR = const DiagnosticType(
+    'COMPILE_TIME_ERROR',
+    2,
+    DiagnosticSeverity.ERROR,
+  );
 
   /**
    * Checked mode compile-time errors are errors that preclude execution in
    * checked mode.
    */
   static const DiagnosticType CHECKED_MODE_COMPILE_TIME_ERROR =
       const DiagnosticType(
-          'CHECKED_MODE_COMPILE_TIME_ERROR', 3, DiagnosticSeverity.ERROR);
+        'CHECKED_MODE_COMPILE_TIME_ERROR',
+        3,
+        DiagnosticSeverity.ERROR,
+      );
 
   /**
    * Static warnings are those warnings reported by the static checker. They
    * have no effect on execution. Static warnings must be provided by Dart
    * compilers used during development.
    */
-  static const DiagnosticType STATIC_WARNING =
-      const DiagnosticType('STATIC_WARNING', 4, DiagnosticSeverity.WARNING);
+  static const DiagnosticType STATIC_WARNING = const DiagnosticType(
+    'STATIC_WARNING',
+    4,
+    DiagnosticSeverity.WARNING,
+  );
 
   /**
    * Syntactic errors are errors produced as a result of input that does not
    * conform to the grammar.
    */
-  static const DiagnosticType SYNTACTIC_ERROR =
-      const DiagnosticType('SYNTACTIC_ERROR', 6, DiagnosticSeverity.ERROR);
+  static const DiagnosticType SYNTACTIC_ERROR = const DiagnosticType(
+    'SYNTACTIC_ERROR',
+    6,
+    DiagnosticSeverity.ERROR,
+  );
 
   /**
    * Lint warnings describe style and best practice recommendations that can be
    * used to formalize a project's style guidelines.
    */
-  static const DiagnosticType LINT =
-      const DiagnosticType('LINT', 7, DiagnosticSeverity.INFO);
+  static const DiagnosticType LINT = const DiagnosticType(
+    'LINT',
+    7,
+    DiagnosticSeverity.INFO,
+  );
 
   static const List<DiagnosticType> values = const [
     TODO,

pkg/_fe_analyzer_shared/lib/src/base/syntactic_entity.dart

@@ -9,7 +9,8 @@ import 'package:_fe_analyzer_shared/src/base/analyzer_public_api.dart';
  * which has a location and extent in the source file.
  */
 @AnalyzerPublicApi(
-    message: 'exported by package:analyzer/dart/ast/syntactic_entity.dart')
+  message: 'exported by package:analyzer/dart/ast/syntactic_entity.dart',
+)
 abstract class SyntacticEntity {
   /**
    * Return the offset from the beginning of the file to the character after the

pkg/_fe_analyzer_shared/lib/src/deferred_function_literal_heuristic.dart

@@ -11,8 +11,11 @@ import 'package:_fe_analyzer_shared/src/util/dependency_walker.dart';
 /// https://github.com/dart-lang/language/issues/731 (improved inference for
 /// fold etc.) to choose the proper order in which to recursively analyze
 /// function literals passed as invocation arguments.
-abstract class FunctionLiteralDependencies<TypeVariable, ParamInfo,
-    DeferredParamInfo extends ParamInfo> {
+abstract class FunctionLiteralDependencies<
+  TypeVariable,
+  ParamInfo,
+  DeferredParamInfo extends ParamInfo
+> {
   final List<_Node<ParamInfo>> _paramNodes = [];
 
   /// Construct a [FunctionLiteralDependencies] object that's prepared to
@@ -22,15 +25,18 @@ abstract class FunctionLiteralDependencies<TypeVariable, ParamInfo,
   /// [unDeferredParams] should contain information about any parameters
   /// corresponding to arguments that have already been type inferred.
   FunctionLiteralDependencies(
-      Iterable<DeferredParamInfo> deferredParams,
-      Iterable<TypeVariable> typeVariables,
-      Iterable<ParamInfo> unDeferredParams) {
+    Iterable<DeferredParamInfo> deferredParams,
+    Iterable<TypeVariable> typeVariables,
+    Iterable<ParamInfo> unDeferredParams,
+  ) {
     Map<TypeVariable, Set<_Node<ParamInfo>>> paramsDependingOnTypeVar = {};
     Map<TypeVariable, Set<_Node<ParamInfo>>> paramsConstrainingTypeVar = {};
     int deferredParamIndex = 0;
     for (DeferredParamInfo param in deferredParams) {
-      _Node<ParamInfo> paramNode =
-          new _Node<ParamInfo>(param, deferredParamIndex: deferredParamIndex++);
+      _Node<ParamInfo> paramNode = new _Node<ParamInfo>(
+        param,
+        deferredParamIndex: deferredParamIndex++,
+      );
       _paramNodes.add(paramNode);
       for (TypeVariable v in typeVarsFreeInParamParams(param)) {
         (paramsDependingOnTypeVar[v] ??= {}).add(paramNode);
@@ -40,8 +46,10 @@ abstract class FunctionLiteralDependencies<TypeVariable, ParamInfo,
       }
     }
     for (ParamInfo param in unDeferredParams) {
-      _Node<ParamInfo> paramNode =
-          new _Node<ParamInfo>(param, deferredParamIndex: null);
+      _Node<ParamInfo> paramNode = new _Node<ParamInfo>(
+        param,
+        deferredParamIndex: null,
+      );
       _paramNodes.add(paramNode);
       // Note: for un-deferred parameters, we only care about
       // typeVarsFreeInParamReturns, because these parameters have already been
@@ -53,8 +61,9 @@ abstract class FunctionLiteralDependencies<TypeVariable, ParamInfo,
     for (TypeVariable typeVariable in typeVariables) {
       for (_Node<ParamInfo> paramNode
           in paramsDependingOnTypeVar[typeVariable] ?? const {}) {
-        paramNode.dependencies
-            .addAll(paramsConstrainingTypeVar[typeVariable] ?? const {});
+        paramNode.dependencies.addAll(
+          paramsConstrainingTypeVar[typeVariable] ?? const {},
+        );
       }
     }
   }
@@ -93,8 +102,8 @@ abstract class FunctionLiteralDependencies<TypeVariable, ParamInfo,
       for (List<_Node<ParamInfo>> stage in walker.reconciliationStages)
         [
           for (_Node<ParamInfo> node in _sortStage(stage))
-            node.param as DeferredParamInfo
-        ]
+            node.param as DeferredParamInfo,
+        ],
     ];
   }
 

pkg/_fe_analyzer_shared/lib/src/exhaustiveness/dart_template_buffer.dart

@@ -13,8 +13,11 @@
 ///
 /// Clients who do not need the additional semantic information may obtain the
 /// final string immediately using [SimpleDartBuffer].
-abstract class DartTemplateBuffer<ConstantValue extends Object,
-    EnumValue extends Object, Type extends Object> {
+abstract class DartTemplateBuffer<
+  ConstantValue extends Object,
+  EnumValue extends Object,
+  Type extends Object
+> {
   /// Adds a text string to the buffer.
   void write(String text);