[eslint] Replace prefer-readonly-keyword with @typescript-eslint/array-type.

We had our own homegrown ESLint rule that was trying to enforce some
consistency around `ReadonlyArray<T>` vs. `readonly T[]`, but that was
fairly limited and still allowed for `Array<T>` vs `T[]` with no shared
discipline.

We now use the `@typescript-eslint/array-type` rule instead and enforce
that for simple types the `T[]` (and `readonly T[]`) syntax is used,
while for complex types the `Array<A & B>` (and `ReadonlyArray<A & B>`)
syntax is used.

Bug: none
Change-Id: I8933869f98577d4afc4141c5736fccb2159924a6
Reviewed-on: https://chromium-review.googlesource.com/c/devtools/devtools-frontend/+/6257990
Commit-Queue: Benedikt Meurer <[email protected]>
Auto-Submit: Benedikt Meurer <[email protected]>
Reviewed-by: Nikolay Vitkov <[email protected]>
Commit-Queue: Nikolay Vitkov <[email protected]>

Author: bmeurer

eslint.config.mjs

@@ -12,13 +12,13 @@ import jsdocPlugin from 'eslint-plugin-jsdoc';
 import mochaPlugin from 'eslint-plugin-mocha';
 import rulesdirPlugin from 'eslint-plugin-rulesdir';
 import globals from 'globals';
-import { join } from 'path';
+import {join} from 'path';
 
 rulesdirPlugin.RULES_DIR = join(
-  import.meta.dirname,
-  'scripts',
-  'eslint_rules',
-  'lib',
+    import.meta.dirname,
+    'scripts',
+    'eslint_rules',
+    'lib',
 );
 
 /**
@@ -302,15 +302,21 @@ export default [
       parserOptions: {
         allowAutomaticSingleRunInference: true,
         project: join(
-          import.meta.dirname,
-          'config',
-          'typescript',
-          'tsconfig.eslint.json',
-        ),
+            import.meta.dirname,
+            'config',
+            'typescript',
+            'tsconfig.eslint.json',
+            ),
       },
     },
 
     rules: {
+      '@typescript-eslint/array-type': [
+        'error',
+        {
+          default: 'array-simple',
+        },
+      ],
       '@typescript-eslint/no-explicit-any': [
         'error',
         {
@@ -487,20 +493,19 @@ export default [
       '@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
 
       'rulesdir/no-underscored-properties': 'error',
-      'rulesdir/prefer-readonly-keyword': 'error',
       'rulesdir/inline-type-imports': 'error',
 
       'rulesdir/enforce-default-import-name': [
         'error',
         {
           // Enforce that any import of models/trace/trace.js names the import Trace.
           modulePath: join(
-            import.meta.dirname,
-            'front_end',
-            'models',
-            'trace',
-            'trace.js',
-          ),
+              import.meta.dirname,
+              'front_end',
+              'models',
+              'trace',
+              'trace.js',
+              ),
           importName: 'Trace',
         },
       ],

extensions/cxx_debugging/src/CustomFormatters.ts

@@ -325,7 +325,7 @@ export class CXXValue implements Value, LazyObject {
         this.typeMap, data);
   }
 
-  async getProperties(): Promise<{name: string, property: LazyObject}[]> {
+  async getProperties(): Promise<Array<{name: string, property: LazyObject}>> {
     const properties = [];
     if (this.type.arraySize > 0) {
       for (let index = 0; index < this.type.arraySize; ++index) {
@@ -461,7 +461,7 @@ export class CXXValue implements Value, LazyObject {
 }
 
 export interface LazyObject {
-  getProperties(): Promise<{name: string, property: LazyObject}[]>;
+  getProperties(): Promise<Array<{name: string, property: LazyObject}>>;
   asRemoteObject(): Promise<Chrome.DevTools.RemoteObject|Chrome.DevTools.ForeignObject>;
 }
 
@@ -543,7 +543,7 @@ export class PrimitiveLazyObject<T> implements LazyObject {
     this.linearMemorySize = linearMemorySize;
   }
 
-  async getProperties(): Promise<{name: string, property: LazyObject}[]> {
+  async getProperties(): Promise<Array<{name: string, property: LazyObject}>> {
     return [];
   }
 
@@ -568,7 +568,7 @@ export class LocalLazyObject implements LazyObject {
     this.linearMemoryAddress = linearMemoryAddress;
   }
 
-  async getProperties(): Promise<{name: string, property: LazyObject}[]> {
+  async getProperties(): Promise<Array<{name: string, property: LazyObject}>> {
     return Object.entries(this.value).map(([name, value]) => {
       const property = lazyObjectFromAny(value, this.objectStore);
       return {name, property};
@@ -592,8 +592,8 @@ export class LocalLazyObject implements LazyObject {
 export type FormatterResult = number|string|boolean|bigint|undefined|CXXValue|object|(() => LazyObject);
 export type FormatterCallback = (wasm: WasmInterface, value: Value) => FormatterResult;
 export interface Formatter {
-  types: Array<string>|((t: TypeInfo) => boolean);
-  imports?: Array<FormatterCallback>;
+  types: string[]|((t: TypeInfo) => boolean);
+  imports?: FormatterCallback[];
   format: FormatterCallback;
 }
 

extensions/cxx_debugging/src/Formatters.ts

@@ -269,7 +269,7 @@ CustomFormatters.addFormatter({types: ['__int128'], format: formatInt128});
 
 export function formatExternRef(wasm: WasmInterface, value: Value): () => LazyObject {
   const obj = {
-    async getProperties(): Promise<{name: string, property: LazyObject}[]> {
+    async getProperties(): Promise<Array<{name: string, property: LazyObject}>> {
       return [];
     },
     async asRemoteObject(): Promise<ForeignObject> {

extensions/cxx_debugging/tests/RealBackend.ts

@@ -60,7 +60,7 @@ export class Debugger {
   private readonly scripts: Map<string, Protocol.Debugger.ScriptParsedEvent> = new Map();
   private readonly scriptsById: Map<string, Protocol.Debugger.ScriptParsedEvent> = new Map();
   private nextStopId = 0n;
-  private waitForPauseQueue: {resolve: (pauseLocation: PauseLocation) => void}[] = [];
+  private waitForPauseQueue: Array<{resolve: (pauseLocation: PauseLocation) => void}> = [];
   private pauseLocation?: PauseLocation;
   private readonly callFrameToStopId = new Map<string, bigint>();
   private readonly stopIdToCallFrame = new Map<bigint, string>();
@@ -347,7 +347,7 @@ export class Debugger {
 
   async setBreakpointsOnSourceLines(
       sourceLines: Array<string|RegExp>, sourceFileURL: URL, plugin: Chrome.DevTools.LanguageExtensionPlugin,
-      rawModuleId: string): Promise<Array<BreakLocation>> {
+      rawModuleId: string): Promise<BreakLocation[]> {
     if (sourceFileURL.protocol !== 'file:') {
       throw new Error('Not a file URL');
     }

front_end/core/common/JavaScriptMetaData.ts

@@ -5,16 +5,16 @@
 export interface DOMPinnedWebIDLProp {
   global?: boolean;
   specs?: number;
-  rules?: Array<DOMPinnedWebIDLRule>;
+  rules?: DOMPinnedWebIDLRule[];
 }
 
 export interface DOMPinnedWebIDLType {
   inheritance?: string;
-  includes?: Array<string>;
+  includes?: string[];
   props?: {
     [PropName: string]: DOMPinnedWebIDLProp,
   };
-  rules?: Array<DOMPinnedWebIDLRule>;
+  rules?: DOMPinnedWebIDLRule[];
 }
 
 export interface DOMPinnedWebIDLRule {

front_end/core/common/Linkifier.ts

@@ -48,5 +48,5 @@ export function getApplicableRegisteredlinkifiers(object: Object): LinkifierRegi
 }
 export interface LinkifierRegistration {
   loadLinkifier: () => Promise<Linkifier>;
-  contextTypes?: (() => Array<Function>);
+  contextTypes?: (() => Function[]);
 }

front_end/core/common/Revealer.ts

@@ -78,7 +78,7 @@ let revealerRegistry: RevealerRegistry|undefined;
  * @see Revealer
  */
 export class RevealerRegistry {
-  private readonly registeredRevealers: RevealerRegistration<unknown>[] = [];
+  private readonly registeredRevealers: Array<RevealerRegistration<unknown>> = [];
 
   /**
    * Yields the singleton instance, creating it on-demand when necessary.
@@ -126,7 +126,7 @@ export class RevealerRegistry {
     return await revealers[0].reveal(revealable, omitFocus);
   }
 
-  getApplicableRegisteredRevealers(revealable: unknown): RevealerRegistration<unknown>[] {
+  getApplicableRegisteredRevealers(revealable: unknown): Array<RevealerRegistration<unknown>> {
     return this.registeredRevealers.filter(registration => {
       for (const contextType of registration.contextTypes()) {
         if (revealable instanceof contextType) {

front_end/core/common/Runnable.ts

@@ -26,16 +26,16 @@ export function maybeRemoveLateInitializationRunnable(runnableId: string): boole
   return registeredLateInitializationRunnables.delete(runnableId);
 }
 
-export function lateInitializationRunnables(): Array<LateInitializationLoader> {
+export function lateInitializationRunnables(): LateInitializationLoader[] {
   return [...registeredLateInitializationRunnables.values()];
 }
 
-const registeredEarlyInitializationRunnables: (() => Runnable)[] = [];
+const registeredEarlyInitializationRunnables: Array<() => Runnable> = [];
 
 export function registerEarlyInitializationRunnable(runnable: () => Runnable): void {
   registeredEarlyInitializationRunnables.push(runnable);
 }
 
-export function earlyInitializationRunnables(): (() => Runnable)[] {
+export function earlyInitializationRunnables(): Array<() => Runnable> {
   return registeredEarlyInitializationRunnables;
 }

front_end/core/common/SegmentedRange.ts

@@ -24,7 +24,7 @@ export class Segment<T> {
 }
 
 export class SegmentedRange<T> {
-  #segmentsInternal: Segment<T>[];
+  #segmentsInternal: Array<Segment<T>>;
   readonly #mergeCallback: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)|undefined;
 
   constructor(mergeCallback?: ((arg0: Segment<T>, arg1: Segment<T>) => Segment<T>| null)) {
@@ -76,7 +76,7 @@ export class SegmentedRange<T> {
     that.segments().forEach(segment => this.append(segment));
   }
 
-  segments(): Segment<T>[] {
+  segments(): Array<Segment<T>> {
     return this.#segmentsInternal;
   }
 

front_end/core/common/SettingRegistration.ts

@@ -81,7 +81,7 @@ const UIStrings = {
 };
 const str_ = i18n.i18n.registerUIStrings('core/common/SettingRegistration.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-let registeredSettings: Array<SettingRegistration> = [];
+let registeredSettings: SettingRegistration[] = [];
 const settingNameSet = new Set<string>();
 
 export function registerSettingExtension(registration: SettingRegistration): void {
@@ -93,11 +93,11 @@ export function registerSettingExtension(registration: SettingRegistration): voi
   registeredSettings.push(registration);
 }
 
-export function getRegisteredSettings(): Array<SettingRegistration> {
+export function getRegisteredSettings(): SettingRegistration[] {
   return registeredSettings.filter(setting => Root.Runtime.Runtime.isDescriptorEnabled(setting));
 }
 
-export function registerSettingsForTest(settings: Array<SettingRegistration>, forceReset: boolean = false): void {
+export function registerSettingsForTest(settings: SettingRegistration[], forceReset: boolean = false): void {
   if (registeredSettings.length === 0 || forceReset) {
     registeredSettings = settings;
     settingNameSet.clear();
@@ -252,7 +252,7 @@ export interface SettingRegistration {
   /**
    * The possible values the setting can have, each with a description composed of a title and an optional text.
    */
-  options?: Array<SettingExtensionOption>;
+  options?: SettingExtensionOption[];
   /**
    * Whether DevTools must be reloaded for a change in the setting to take effect.
    */