[eslint] Enable @typescript-eslint/consistent-generic-constructors

Bug: 397260638
Change-Id: Id9eb30ea776f9b4bb05dc6a095ff24d1c742b89c
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6279125
Commit-Queue: Nikolay Vitkov <[email protected]>
Reviewed-by: Benedikt Meurer <[email protected]>

Author: Lightning00Blade

eslint.config.mjs

@@ -502,6 +502,11 @@ export default [
       // certain TypeScript compilation errors after fixes
       '@typescript-eslint/no-unnecessary-type-assertion': 'off',
 
+      '@typescript-eslint/consistent-generic-constructors': [
+        'error',
+        'constructor',
+      ],
+
       'rulesdir/no-underscored-properties': 'error',
       'rulesdir/inline-type-imports': 'error',
 

extensions/cxx_debugging/src/CustomFormatters.ts

@@ -506,7 +506,7 @@ function lazyObjectFromAny(
 
 export class LazyObjectStore {
   private nextObjectId: number = 0;
-  private objects: Map<string, LazyObject> = new Map();
+  private objects = new Map<string, LazyObject>();
 
   store(lazyObject: LazyObject): string {
     const objectId = `${this.nextObjectId++}`;
@@ -646,7 +646,7 @@ export class DebuggerProxy {
 }
 
 export class CustomFormatters {
-  private static formatters: Map<string, Formatter> = new Map();
+  private static formatters = new Map<string, Formatter>();
   private static genericFormatters: Formatter[] = [];
 
   static addFormatter(formatter: Formatter): void {

extensions/cxx_debugging/src/WorkerRPC.ts

@@ -79,8 +79,7 @@ export class WorkerRPC<LocalInterface extends Record<string, any>, RemoteInterfa
   private nextRequestId = 0;
   private readonly channel: Channel<LocalInterface, RemoteInterface>;
   private readonly localHandler: LocalInterface;
-  private readonly requests: Map<number, {resolve: (params: unknown) => void, reject: (message: Error) => void}> =
-      new Map();
+  private readonly requests = new Map<number, {resolve: (params: unknown) => void, reject: (message: Error) => void}>();
   private readonly semaphore: Int32Array;
 
   constructor(channel: Channel<LocalInterface, RemoteInterface>, localHandler: LocalInterface) {

extensions/cxx_debugging/tests/RealBackend.ts

@@ -49,16 +49,16 @@ export class Debugger {
   private readonly targetId: string;
   private connected: boolean;
   private readonly queue: string[];
-  private readonly callbacks: Map<number, {
+  private readonly callbacks = new Map<number, {
     method: string,
     resolve: (r: ProtocolMapping.Commands[keyof ProtocolMapping.Commands]['returnType']) => unknown,
     reject: (r: unknown) => unknown,
-  }> = new Map();
+  }>();
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly eventHandlers: Map<string, Set<Handler<any>>> = new Map();
+  private readonly eventHandlers = new Map<string, Set<Handler<any>>>();
   private nextMessageId = 0;
-  private readonly scripts: Map<string, Protocol.Debugger.ScriptParsedEvent> = new Map();
-  private readonly scriptsById: Map<string, Protocol.Debugger.ScriptParsedEvent> = new Map();
+  private readonly scripts = new Map<string, Protocol.Debugger.ScriptParsedEvent>();
+  private readonly scriptsById = new Map<string, Protocol.Debugger.ScriptParsedEvent>();
   private nextStopId = 0n;
   private waitForPauseQueue: Array<{resolve: (pauseLocation: PauseLocation) => void}> = [];
   private pauseLocation?: PauseLocation;

front_end/core/common/ResolverBase.ts

@@ -16,7 +16,7 @@ interface PromiseInfo<T> {
  * promises by using the `clear` method on this class.
  */
 export abstract class ResolverBase<Id, T> {
-  #unresolvedIds: Map<Id, PromiseInfo<T>> = new Map();
+  #unresolvedIds = new Map<Id, PromiseInfo<T>>();
 
   protected abstract getForId(id: Id): T|null;
   protected abstract startListening(): void;

front_end/core/protocol_client/InspectorBackend.ts

@@ -100,7 +100,7 @@ interface CallbackWithDebugInfo {
 }
 
 export class InspectorBackend {
-  readonly agentPrototypes: Map<ProtocolDomainName, AgentPrototype> = new Map();
+  readonly agentPrototypes = new Map<ProtocolDomainName, AgentPrototype>();
   #initialized: boolean = false;
   #eventParameterNamesForDomain = new Map<ProtocolDomainName, EventParameterNames>();
   readonly typeMap = new Map<QualifiedName, CommandParameter[]>();

front_end/core/sdk/CSSPropertyParserMatchers.ts

@@ -452,7 +452,7 @@ export class LinkableNameMatcher extends matcherBase(LinkableNameMatch) {
     return names.includes(propertyName);
   }
 
-  static readonly identifierAnimationLonghandMap: Map<string, AnimationLonghandPart> = new Map(
+  static readonly identifierAnimationLonghandMap = new Map<string, AnimationLonghandPart>(
       Object.entries({
         normal: AnimationLonghandPart.DIRECTION,
         alternate: AnimationLonghandPart.DIRECTION,

front_end/core/sdk/ChildTargetManager.ts

@@ -31,10 +31,10 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   readonly #targetManager: TargetManager;
   #parentTarget: Target;
   readonly #targetAgent: ProtocolProxyApi.TargetApi;
-  readonly #targetInfosInternal: Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo> = new Map();
-  readonly #childTargetsBySessionId: Map<Protocol.Target.SessionID, Target> = new Map();
-  readonly #childTargetsById: Map<Protocol.Target.TargetID|'main', Target> = new Map();
-  readonly #parallelConnections: Map<string, ProtocolClient.InspectorBackend.Connection> = new Map();
+  readonly #targetInfosInternal = new Map<Protocol.Target.TargetID, Protocol.Target.TargetInfo>();
+  readonly #childTargetsBySessionId = new Map<Protocol.Target.SessionID, Target>();
+  readonly #childTargetsById = new Map<Protocol.Target.TargetID|'main', Target>();
+  readonly #parallelConnections = new Map<string, ProtocolClient.InspectorBackend.Connection>();
   #parentTargetId: Protocol.Target.TargetID|null = null;
 
   constructor(parentTarget: Target) {

front_end/core/sdk/DOMModel.ts

@@ -1134,7 +1134,7 @@ export class DOMDocument extends DOMNode {
 
 export class DOMModel extends SDKModel<EventTypes> {
   agent: ProtocolProxyApi.DOMApi;
-  idToDOMNode: Map<Protocol.DOM.NodeId, DOMNode> = new Map();
+  idToDOMNode = new Map<Protocol.DOM.NodeId, DOMNode>();
   #document: DOMDocument|null;
   readonly #attributeLoadNodeIds: Set<Protocol.DOM.NodeId>;
   readonly runtimeModelInternal: RuntimeModel;

front_end/core/sdk/FrameManager.ts

@@ -35,7 +35,7 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
     creationStackTrace?: Protocol.Runtime.StackTrace,
     creationStackTraceTarget?: Target,
   }>();
-  #awaitedFrames: Map<string, Array<{notInTarget?: Target, resolve: (frame: ResourceTreeFrame) => void}>> = new Map();
+  #awaitedFrames = new Map<string, Array<{notInTarget?: Target, resolve: (frame: ResourceTreeFrame) => void}>>();
 
   constructor() {
     super();