Bump lints to a97011b4b031b1df94765dbacd7d92b0b765c8b9

Changes:
```
> git log --format="%C(auto) %h %s" af68bf0..a97011b
 https://dart.googlesource.com/lints.git/+/a97011b add unintended_html_in_doc_comment; rev to 5.1.0 (211)

```

Diff: https://dart.googlesource.com/lints.git/+/af68bf0cbad88002a2ae19ee8db37b64eb120c32..a97011b4b031b1df94765dbacd7d92b0b765c8b9/
Change-Id: I998d73f5f72e94d5f2922b0751d31620a837555e
Tested: analysis only change
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/387601
Reviewed-by: Nate Bosch <nbosch@google.com>
Commit-Queue: Devon Carew <devoncarew@google.com>

DEPS

@@ -157,7 +157,7 @@ vars = {
   "intl_rev": "5d65e3808ce40e6282e40881492607df4e35669f",
   "json_rpc_2_rev": "b4810dc7bee5828f240586c81f3f34853cacdbce",
   "leak_tracker_rev": "f5620600a5ce1c44f65ddaa02001e200b096e14c", # manually rolled
-  "lints_rev": "af68bf0cbad88002a2ae19ee8db37b64eb120c32",
+  "lints_rev": "a97011b4b031b1df94765dbacd7d92b0b765c8b9",
   "logging_rev": "8752902b75a476d2c7b64dcf01aaaee885f35c4c",
   "markdown_rev": "f6eaea38146d8901756418c4e7123eb7bd77249e",
   "matcher_rev": "d6d573d0f8d65b36550ce62aad3ce6b5e987b642",

pkg/_macros/analysis_options.yaml

@@ -4,6 +4,8 @@ analyzer:
   language:
     strict-casts: true
   errors:
+    # Remove on next publish or protocol refactoring:
+    unintended_html_in_doc_comment: ignore
     # Remove on next publish or protocol refactoring;
     # https://github.com/dart-lang/language/issues/3706.
     unnecessary_library_name: ignore

pkg/analysis_server/analysis_options.yaml

@@ -24,6 +24,8 @@ analyzer:
     non_constant_identifier_names: ignore
     overridden_fields: ignore
     todo: ignore
+    # Existing violations (361)
+    unintended_html_in_doc_comment: ignore
 
 linter:
   rules:

pkg/analysis_server_client/analysis_options.yaml

@@ -4,6 +4,8 @@ analyzer:
   errors:
     constant_identifier_names: ignore
     non_constant_identifier_names: ignore
+    # Existing violations (109)
+    unintended_html_in_doc_comment: ignore
 
 linter:
   rules:

pkg/analyzer/lib/dart/element/element.dart

@@ -2575,7 +2575,9 @@ abstract class TypeAliasElement
   /// Note that this always instantiates the typedef itself, so for a
   /// [TypeAliasElement] the returned [DartType] might still be a generic
   /// type, with type formals. For example, if the typedef is:
+  ///
   ///     typedef F<T> = void Function<U>(T, U);
+  ///
   /// then `F<int>` will produce `void Function<U>(int, U)`.
   DartType instantiate({
     required List<DartType> typeArguments,

pkg/analyzer/lib/dart/element/element2.dart

@@ -1800,7 +1800,9 @@ abstract class TypeAliasElement2
   /// Note that this always instantiates the typedef itself, so for a
   /// [TypeAliasElement2] the returned [DartType] might still be a generic
   /// type, with type formals. For example, if the typedef is:
+  ///
   ///     typedef F<T> = void Function<U>(T, U);
+  ///
   /// then `F<int>` will produce `void Function<U>(int, U)`.
   DartType instantiate({
     required List<DartType> typeArguments,

pkg/analyzer/lib/dart/element/type.dart

@@ -70,7 +70,7 @@ abstract class DartType implements SharedTypeStructure<DartType> {
   /// dart:async library.
   bool get isDartAsyncFuture;
 
-  /// Return `true` if this type represents the type 'FutureOr<T>' defined in
+  /// Return `true` if this type represents the type `FutureOr<T>` defined in
   /// the dart:async library.
   bool get isDartAsyncFutureOr;
 

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

@@ -29,7 +29,7 @@ class NormalizeHelper {
     return _normalize(T);
   }
 
-  /// NORM(R Function<X extends B>(S)) = R1 Function(X extends B1>(S1)
+  /// `NORM(R Function<X extends B>(S)) = R1 Function(X extends B1>(S1)`
   ///   * where R1 = NORM(R)
   ///   * and B1 = NORM(B)
   ///   * and S1 = NORM(S)
@@ -57,7 +57,7 @@ class NormalizeHelper {
     );
   }
 
-  /// NORM(FutureOr<T>)
+  /// `NORM(FutureOr<T>)`
   DartType _futureOr(InterfaceType T) {
     // * let S be NORM(T)
     var S = _normalize(T.typeArguments[0]);

pkg/analyzer/lib/src/summary2/data_reader.dart

@@ -217,10 +217,10 @@ class _StringTable {
   late final List<String?> _strings;
 
   /// The structure of the table:
-  ///   <bytes with encoded strings>
-  ///   <the length of the bytes> <-- [startOffset]
-  ///   <the number strings>
-  ///   <the array of lengths of individual strings>
+  ///   - `<bytes with encoded strings>`
+  ///   - `<the length of the bytes> <-- [startOffset]`
+  ///   - `<the number strings>`
+  ///   - `<the array of lengths of individual strings>`
   _StringTable({
     required Uint8List bytes,
     required int startOffset,

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

@@ -254,7 +254,7 @@ class NormalizeTypeTest extends AbstractTypeSystemTest with StringTypes {
     );
   }
 
-  /// NORM(FutureOr<T>)
+  /// `NORM(FutureOr<T>)`
   /// * let S be NORM(T)
   test_futureOr() {
     void check(DartType T, DartType expected) {

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

@@ -590,7 +590,7 @@ class TypeConstraintGathererTest extends AbstractTypeSystemTest {
     );
   }
 
-  /// If `P` is `C<M0, ..., Mk> and `Q` is `C<N0, ..., Nk>`, then the match
+  /// If `P` is `C<M0, ..., Mk>` and `Q` is `C<N0, ..., Nk>`, then the match
   /// holds under constraints `C0 + ... + Ck`:
   ///   If `Mi` is a subtype match for `Ni` with respect to L under
   ///   constraints `Ci`.

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

@@ -2635,8 +2635,8 @@ class UpperBoundTest extends _BoundsTestBase {
     );
   }
 
-  /// UP(Future<T1>, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
-  /// UP(FutureOr<T1>, Future<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
+  /// `UP(Future<T1>, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)`
+  /// `UP(FutureOr<T1>, Future<T2>) = FutureOr<T3> where T3 = UP(T1, T2)`
   test_futureOr_future() {
     void check(DartType T1, DartType T2, DartType expected) {
       _checkLeastUpperBound(
@@ -2650,7 +2650,7 @@ class UpperBoundTest extends _BoundsTestBase {
     check(intNone, stringNone, objectNone);
   }
 
-  /// UP(FutureOr<T1>, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
+  /// `UP(FutureOr<T1>, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)`
   test_futureOr_futureOr() {
     void check(DartType T1, DartType T2, DartType expected) {
       _checkLeastUpperBound(
@@ -2664,8 +2664,8 @@ class UpperBoundTest extends _BoundsTestBase {
     check(intNone, stringNone, objectNone);
   }
 
-  /// UP(T1, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)
-  /// UP(FutureOr<T1>, T2) = FutureOr<T3> where T3 = UP(T1, T2)
+  /// `UP(T1, FutureOr<T2>) = FutureOr<T3> where T3 = UP(T1, T2)`
+  /// `UP(FutureOr<T1>, T2) = FutureOr<T3> where T3 = UP(T1, T2)`
   test_futureOr_other() {
     void check(DartType T1, DartType T2, DartType expected) {
       _checkLeastUpperBound(

pkg/analyzer_plugin/analysis_options.yaml

@@ -11,6 +11,8 @@ analyzer:
     non_constant_identifier_names: ignore
     # Existing violations (3)
     library_private_types_in_public_api: ignore
+    # Existing violations (194)
+    unintended_html_in_doc_comment: ignore
 
 linter:
   rules:

pkg/dart2js_info/bin/src/to_devtools_format.dart

@@ -144,7 +144,7 @@ class ProgramInfoBuilder extends VMProgramInfoVisitor<vm.ProgramInfoNode?> {
   /// [PackageInfo] objects.
   final Map<String, PackageInfo> packageInfos = {};
 
-  /// Mapping between an <unnamed> [LibraryInfo] object and the name of the
+  /// Mapping between an `<unnamed>` [LibraryInfo] object and the name of the
   /// corresponding [vm.ProgramInfoNode] object.
   final Map<Info, String> unnamedLibraries = {};
 

pkg/dart2wasm/lib/await_transformer.dart

@@ -12,7 +12,7 @@ import 'state_machine.dart' as stateMachineCodeGen;
 /// This pass lifts `await` expressions to the top-level. After the pass, all
 /// `await` expressions will have the form:
 ///
-///   final $temp = await <simple expr>;
+///     final $temp = await <simple expr>;
 ///
 /// where `<simple expr>` is an expression without `await`.
 ///

pkg/dart2wasm/lib/ffi_native_transformer.dart

@@ -23,15 +23,15 @@ import 'abi.dart' show kWasmAbiEnumIndex;
 ///
 /// Example:
 ///
-///   @Native<Int8 Function(Int8, Int8)>(symbol: "addInt8")
-///   external int addInt8(int a, int b);
+///     @Native<Int8 Function(Int8, Int8)>(symbol: "addInt8")
+///     external int addInt8(int a, int b);
 ///
 /// Converted to:
 ///
-///   external static wasm::WasmI32 addInt8_$import(wasm::WasmI32 a, wasm::WasmI32 b);
+///     external static wasm::WasmI32 addInt8_$import(wasm::WasmI32 a, wasm::WasmI32 b);
 ///
-///   static int addInt8(int a, int b) =>
-///     addInt8_$import(WasmI32::int8FromInt(a), WasmI32::int8FromInt(b)).toIntSigned();
+///     static int addInt8(int a, int b) =>
+///       addInt8_$import(WasmI32::int8FromInt(a), WasmI32::int8FromInt(b)).toIntSigned();
 ///
 void transformLibraries(
     Component component,

pkg/dart2wasm/lib/js/callback_specializer.dart

@@ -254,10 +254,10 @@ class CallbackSpecializer {
 
   /// Lowers an invocation of `allowInterop<type>(foo)` to:
   ///
-  ///   let #var = foo in
-  ///     _isDartFunctionWrapped<type>(#var) ?
-  ///       #var :
-  ///       _wrapDartFunction<type>(#var, jsWrapperFunction(#var));
+  ///     let #var = foo in
+  ///       _isDartFunctionWrapped<type>(#var) ?
+  ///         #var :
+  ///         _wrapDartFunction<type>(#var, jsWrapperFunction(#var));
   ///
   /// The use of two functions here is necessary because we do not allow
   /// `WasmExternRef` to be an argument or return type for a tear off.
@@ -346,11 +346,11 @@ class CallbackSpecializer {
   /// Given an invocation of `Function.toJS`, returns an [Expression]
   /// representing:
   ///
-  ///   JSValue(jsWrapperFunction(<Function>))
+  ///     JSValue(jsWrapperFunction(<Function>))
   ///
   /// or if a cast closure is needed:
   ///
-  ///   JSValue(jsWrapperFunction(<Function>, <CastClosure>))
+  ///     JSValue(jsWrapperFunction(<Function>, <CastClosure>))
   ///
   /// If [captureThis] is true, this is assumed to be an invocation of
   /// `Function.toJSCaptureThis`.

pkg/dart2wasm/lib/transformers.dart

@@ -781,21 +781,21 @@ class _AsyncStarFrame {
 
 /// Converts `pushWasmArray<T>(array, length, elem, nextCapacity)` to:
 ///
-///   if (array.length == length) {
-///     final newArray = WasmArray<T>(nextCapacity);
-///     newArray.copy(0, array, 0, length);
-///     array = newArray;
-///   }
-///   array[length] = elem;
-///   length += 1;
+///     if (array.length == length) {
+///       final newArray = WasmArray<T>(nextCapacity);
+///       newArray.copy(0, array, 0, length);
+///       array = newArray;
+///     }
+///     array[length] = elem;
+///     length += 1;
 ///
 /// and `popWasmArray<T>(array, length)` to block expression:
 ///
-///   {
-///     length -= 1;
-///     final T _value = array[length];
-///     array[length] = null;
-///   } => _value
+///     {
+///       length -= 1;
+///       final T _value = array[length];
+///       array[length] = null;
+///     } => _value
 ///
 /// This allows unboxing growable list in class fields.
 ///

pkg/dart2wasm/lib/translator.dart

@@ -1251,7 +1251,7 @@ class Translator with KernelNodes {
     b.i32_wrap_i64();
   }
 
-  /// Get the WasmListBase._data field of type WasmArray<Object?>.
+  /// Get the `WasmListBase._data` field of type `WasmArray<Object?>`.
   void getListBaseArray(w.InstructionsBuilder b) {
     ClassInfo info = classInfo[listBaseClass]!;
     b.struct_get(info.struct, FieldIndex.listArray);

pkg/dev_compiler/lib/src/compiler/rewrite_async.dart

@@ -391,8 +391,10 @@ abstract class AsyncRewriterBase extends js_ast.NodeVisitor<Object?> {
   /// body.
   ///
   /// We cannot simply rewrite `<receiver>.m()` to:
+  ///
   ///     temp = <receiver>.m;
   ///     temp();
+  ///
   /// Because this leaves `this` unbound in the call. To solve this we `bind`
   /// the receiver to the tear-off to re-establish the `this` context.
   ///

pkg/dev_compiler/lib/src/kernel/module_symbols.dart

@@ -195,7 +195,7 @@ class Symbol implements SymbolTableElement {
 
   /// Unique Id, shared with JS representation (if any).
   ///
-  /// '<scope id>|<js name>'
+  /// `'<scope id>|<js name>'`
   ///
   /// Where scope refers to a Library, Class, Function, or Scope.
   String get id => scopeId == null ? localId : '$scopeId|$localId';
@@ -433,7 +433,8 @@ class FunctionSymbol extends ScopeSymbol {
   /// Unique Id, shared with JS representation (if any).
   ///
   /// Format:
-  ///   '<scope id>|<js name>'
+  ///
+  ///     '<scope id>|<js name>'
   ///
   /// Where scope refers to a Library, Class, Function, or Scope.
   /// String id;

pkg/dev_compiler/lib/src/kernel/type_environment.dart

@@ -27,11 +27,14 @@ abstract class DDCTypeEnvironment {
   /// Returns all class type parameters in this type environment.
   ///
   /// For the example:
+  ///
+  /// ```
   /// Class Foo<T> {
   ///   method<U> {
   ///     ... // this
   ///   }
   /// }
+  /// ```
   ///
   /// classTypeParameters in this would return ['T'].
   List<TypeParameter> get classTypeParameters;
@@ -39,11 +42,14 @@ abstract class DDCTypeEnvironment {
   /// Returns all class type parameters in this type environment.
   ///
   /// For the example:
+  ///
+  /// ```
   /// Class Foo<T> {
   ///   method<U> {
   ///     ... // this
   ///   }
   /// }
+  /// ```
   ///
   /// functionTypeParameters this would return ['U'].
   List<TypeParameter> get functionTypeParameters;

pkg/native_stack_traces/lib/src/convert.dart

@@ -385,8 +385,8 @@ class StackTraceHeader {
   return null;
 }
 
-/// Parses strings of the format <static symbol>+<integer offset>, where
-/// <static symbol> is one of the static symbols used for Dart instruction
+/// Parses strings of the format `<static symbol>+<integer offset>`, where
+/// `<static symbol>` is one of the static symbols used for Dart instruction
 /// sections.
 ///
 /// Unless forceHexadecimal is true, an integer offset without a "0x" prefix or
@@ -418,7 +418,7 @@ PCOffset? tryParseSymbolOffset(String s,
 ///   - The location of the virtual address, which is one of the following:
 ///     - A dynamic symbol name, a plus sign, and an integer offset.
 ///     - The path to the snapshot, if it was loaded as a dynamic library,
-///       otherwise the string "<unknown>".
+///       otherwise the string `"<unknown>"`.
 const _symbolOffsetREString = r'(?<symbol>' +
     constants.vmSymbolName +
     r'|' +

pkg/reload_test/lib/frontend_server_controller.dart

@@ -48,6 +48,8 @@ enum FrontendServerState {
 /// Controls and synchronizes the Frontend Server during hot reloaad tests.
 ///
 /// The Frontend Server accepts the following instructions:
+///
+/// ```
 /// > compile <input.dart>
 ///
 /// > recompile [<input.dart>] <boundary-key>
@@ -65,6 +67,7 @@ enum FrontendServerState {
 ///   <boundary-key>
 ///   [<error text or modified files prefixed by '-' or '+'>]
 ///   <boundary-key> [<output.dill>] <error-count>
+/// ```
 class HotReloadFrontendServerController {
   final List<String> frontendServerArgs;
 

pkg/telemetry/lib/src/pii_regexp.dart

@@ -31,7 +31,7 @@ class _RegExpList {
 }
 
 /// An ordered list of regular expressions to be substituted out and replaced
-/// with a generic '<path>' string. To be applied in sequence.
+/// with a generic `<path>` string. To be applied in sequence.
 /// The regular expressions here intentionally eat all characters after a
 /// path is identified, with the hope of catching all potential complex
 /// pathnames and assuming that most error messages will have any paths last.
@@ -54,7 +54,7 @@ final _piiPathRegexps = _RegExpList([
 ], '<path>');
 
 /// An ordered list of regular expressions to be substituted out and replaced
-/// with a generic '<filename>' string.  To be applied after
+/// with a generic `<filename>` string.  To be applied after
 /// all paths from [_piiPathRegexps] are applied.   This is somewhat less
 /// all-encompassing than the path finder, above, just to try and grab things
 /// that could be file names but without being quite so greedy or depending

pkg/vm/lib/modular/specializer/map_factory_specializer.dart

@@ -7,9 +7,10 @@ import 'package:kernel/core_types.dart';
 
 import 'factory_specializer.dart';
 
-/// Replaces invocation of Map factory constructors with
-/// factories of VM-specific classes.
-/// new LinkedHashMap<K, V>() => new _Map<K, V>()
+/// Replaces invocation of Map factory constructors with factories of
+/// VM-specific classes.
+///
+///     new LinkedHashMap<K, V>() => new _Map<K, V>()
 class MapFactorySpecializer extends BaseSpecializer {
   final Procedure _linkedHashMapDefaultFactory;
   final Constructor _internalLinkedHashMapConstructor;

pkg/vm/lib/modular/specializer/set_factory_specializer.dart

@@ -8,9 +8,10 @@ import 'package:kernel/core_types.dart';
 
 import 'factory_specializer.dart';
 
-/// Replaces invocation of Set factory constructors with
-/// factories of VM-specific classes.
-/// new LinkedHashSet<E>() => new _Set<E>()
+/// Replaces invocation of Set factory constructors with factories of
+/// VM-specific classes.
+///
+///     new LinkedHashSet<E>() => new _Set<E>()
 class SetFactorySpecializer extends BaseSpecializer {
   final Procedure _linkedHashSetDefaultFactory;
   final Constructor _internalLinkedHashSetConstructor;

pkg/vm/lib/modular/transformations/ffi/common.dart

@@ -689,6 +689,7 @@ class FfiTransformer extends Transformer {
   /// Computes the Dart type corresponding to a ffi.[NativeType], returns null
   /// if it is not a valid NativeType.
   ///
+  /// ```
   /// [Int8]                               -> [int]
   /// [Int16]                              -> [int]
   /// [Int32]                              -> [int]
@@ -709,6 +710,7 @@ class FfiTransformer extends Transformer {
   /// [Handle]                             -> [Object]
   /// [NativeFunction]<T1 Function(T2, T3) -> S1 Function(S2, S3)
   ///    where DartRepresentationOf(Tn) -> Sn
+  /// ```
   DartType? convertNativeTypeToDartType(
     DartType nativeType, {
     bool allowStructAndUnion = false,

pkg/vm/lib/modular/transformations/ffi/definitions.dart

@@ -36,6 +36,8 @@ import 'native_type_cfe.dart';
 /// Checks and elaborates the dart:ffi compounds and their fields.
 ///
 /// Input:
+///
+/// ```
 /// final class Coord extends Struct {
 ///   @Double()
 ///   double x;
@@ -45,8 +47,11 @@ import 'native_type_cfe.dart';
 ///
 ///   Pointer<Coord> next;
 /// }
+/// ```
 ///
 /// Output:
+///
+/// ```
 /// final class Coord extends Struct {
 ///   Coord.#fromTypedDataBase(Pointer<Coord> coord) : super._(coord);
 ///
@@ -61,6 +66,7 @@ import 'native_type_cfe.dart';
 ///
 ///   static int get #sizeOf => (const [24, 20, 24])[_abi()];
 /// }
+/// ```
 void transformLibraries(
   Component component,
   CoreTypes coreTypes,

pkg/vm/lib/modular/transformations/ffi/native_type_cfe.dart

@@ -142,8 +142,9 @@ sealed class NativeTypeCfe {
   /// the type will be loaded from that buffer, starting at [offsetInBytes].
   ///
   /// For example, loading a `Pointer` from memory (via [PointerNativeTypeCfe])
-  /// would build an expression like `ffi._loadPointer<T>
-  /// (#typedDataBase, #offsetInBytes)`, where `Pointer<T> == dartType`.
+  /// would build an expression like
+  /// `ffi._loadPointer<T>(#typedDataBase, #offsetInBytes)`, where
+  /// `Pointer<T> == dartType`.
   ///
   /// For struct fields, [generateGetterStatement] fills in values for
   /// [offsetInBytes] and [unaligned] based on the ABI of the struct. It also

third_party/pkg/language_server_protocol/analysis_options.yaml

@@ -1 +1,6 @@
 include: package:lints/recommended.yaml
+
+analyzer:
+  errors:
+    # Existing violations (1)
+    unintended_html_in_doc_comment: ignore

tools/addlatexhash.dart

@@ -488,12 +488,11 @@ String computeHashString(
         List<String> lines, int startIndex, int nextIndex, IOSink listSink) =>
     hex.encode(computeHashValue(lines, startIndex, nextIndex, listSink));
 
-/// Computes and adds hashes to \LMHash{} lines in [lines] (which
-/// must be on the line numbers specified in [hashEvents]), and emits
-/// sectioning markers and hash values to [listSink], along with
-/// "comments" containing the simplified text (using the format
-/// '  % <text>', where the text is one, long line, for easy grepping
-/// etc.).
+/// Computes and adds hashes to \LMHash{} lines in [lines] (which must be on the
+/// line numbers specified in [hashEvents]), and emits sectioning markers and
+/// hash values to [listSink], along with "comments" containing the simplified
+/// text (using the format `'  % <text>'`, where the text is one, long line, for
+/// easy grepping etc.).
 void addHashMarks(
     List<String> lines, List<HashEvent> hashEvents, IOSink listSink) {
   for (var hashEvent in hashEvents) {

tools/manage_deps.dart

@@ -6,7 +6,11 @@
 /// Helps rolling dependency to the newest version available
 /// (or a target version).
 ///
-/// Usage: ./tools/manage_deps.dart bump <dependency> [--branch <branch>] [--target <ref>]
+/// Usage:
+///
+/// ```bash
+/// ./tools/manage_deps.dart bump <dependency> [--branch <branch>] [--target <ref>]
+/// ```
 ///
 /// This will:
 /// 0. Check that git is clean