chrome-devtools-frontend 1.0.951864 → 1.0.952784

package/front_end/entrypoints/formatter_worker/JavaScriptFormatter.ts

@@ -36,30 +36,30 @@ import {ESTreeWalker} from './ESTreeWalker.js';
 import type {FormattedContentBuilder} from './FormattedContentBuilder.js';
 
 export class JavaScriptFormatter {
-  private readonly builder: FormattedContentBuilder;
-  private tokenizer!: AcornTokenizer;
-  private content!: string;
-  private fromOffset!: number;
-  private lastLineNumber!: number;
-  private toOffset?: number;
+  readonly #builder: FormattedContentBuilder;
+  #tokenizer!: AcornTokenizer;
+  #content!: string;
+  #fromOffset!: number;
+  #lastLineNumber!: number;
+  #toOffset?: number;
   constructor(builder: FormattedContentBuilder) {
-    this.builder = builder;
+    this.#builder = builder;
   }
 
   format(text: string, lineEndings: number[], fromOffset: number, toOffset: number): void {
-    this.fromOffset = fromOffset;
-    this.toOffset = toOffset;
-    this.content = text.substring(this.fromOffset, this.toOffset);
-    this.lastLineNumber = 0;
-    this.tokenizer = new AcornTokenizer(this.content);
-    const ast = Acorn.parse(this.content, {
+    this.#fromOffset = fromOffset;
+    this.#toOffset = toOffset;
+    this.#content = text.substring(this.#fromOffset, this.#toOffset);
+    this.#lastLineNumber = 0;
+    this.#tokenizer = new AcornTokenizer(this.#content);
+    const ast = Acorn.parse(this.#content, {
       ranges: false,
       preserveParens: true,
       allowImportExportEverywhere: true,
       ecmaVersion: ECMA_VERSION,
       allowHashBang: true,
     });
-    const walker = new ESTreeWalker(this.beforeVisit.bind(this), this.afterVisit.bind(this));
+    const walker = new ESTreeWalker(this.#beforeVisit.bind(this), this.#afterVisit.bind(this));
     // @ts-ignore Technically, the acorn Node type is a subclass of Acorn.ESTree.Node.
     // However, the acorn package currently exports its type without specifying
     // this relationship. So while this is allowed on runtime, we can't properly
@@ -67,55 +67,55 @@ export class JavaScriptFormatter {
     walker.walk(ast);
   }
 
-  private push(token: Acorn.Token|Acorn.Comment|null, format: string): void {
+  #push(token: Acorn.Token|Acorn.Comment|null, format: string): void {
     for (let i = 0; i < format.length; ++i) {
       if (format[i] === 's') {
-        this.builder.addSoftSpace();
+        this.#builder.addSoftSpace();
       } else if (format[i] === 'S') {
-        this.builder.addHardSpace();
+        this.#builder.addHardSpace();
       } else if (format[i] === 'n') {
-        this.builder.addNewLine();
+        this.#builder.addNewLine();
       } else if (format[i] === '>') {
-        this.builder.increaseNestingLevel();
+        this.#builder.increaseNestingLevel();
       } else if (format[i] === '<') {
-        this.builder.decreaseNestingLevel();
+        this.#builder.decreaseNestingLevel();
       } else if (format[i] === 't') {
-        if (this.tokenizer.tokenLineStart() - this.lastLineNumber > 1) {
-          this.builder.addNewLine(true);
+        if (this.#tokenizer.tokenLineStart() - this.#lastLineNumber > 1) {
+          this.#builder.addNewLine(true);
         }
-        this.lastLineNumber = this.tokenizer.tokenLineEnd();
+        this.#lastLineNumber = this.#tokenizer.tokenLineEnd();
         if (token) {
-          this.builder.addToken(this.content.substring(token.start, token.end), this.fromOffset + token.start);
+          this.#builder.addToken(this.#content.substring(token.start, token.end), this.#fromOffset + token.start);
         }
       }
     }
   }
 
-  private beforeVisit(node: Acorn.ESTree.Node): undefined {
+  #beforeVisit(node: Acorn.ESTree.Node): undefined {
     if (!node.parent) {
       return;
     }
     let token;
-    while ((token = this.tokenizer.peekToken()) && token.start < node.start) {
-      const token = (this.tokenizer.nextToken() as TokenOrComment);
+    while ((token = this.#tokenizer.peekToken()) && token.start < node.start) {
+      const token = (this.#tokenizer.nextToken() as TokenOrComment);
       // @ts-ignore Same reason as above about Acorn types and ESTree types
-      const format = this.formatToken(node.parent, token);
-      this.push(token, format);
+      const format = this.#formatToken(node.parent, token);
+      this.#push(token, format);
     }
     return;
   }
 
-  private afterVisit(node: Acorn.ESTree.Node): void {
+  #afterVisit(node: Acorn.ESTree.Node): void {
     let token;
-    while ((token = this.tokenizer.peekToken()) && token.start < node.end) {
-      const token = (this.tokenizer.nextToken() as TokenOrComment);
-      const format = this.formatToken(node, token);
-      this.push(token, format);
+    while ((token = this.#tokenizer.peekToken()) && token.start < node.end) {
+      const token = (this.#tokenizer.nextToken() as TokenOrComment);
+      const format = this.#formatToken(node, token);
+      this.#push(token, format);
     }
-    this.push(null, this.finishNode(node));
+    this.#push(null, this.#finishNode(node));
   }
 
-  private inForLoopHeader(node: Acorn.ESTree.Node): boolean {
+  #inForLoopHeader(node: Acorn.ESTree.Node): boolean {
     const parent = node.parent;
     if (!parent) {
       return false;
@@ -131,7 +131,7 @@ export class JavaScriptFormatter {
     return false;
   }
 
-  private formatToken(node: Acorn.ESTree.Node, tokenOrComment: TokenOrComment): string {
+  #formatToken(node: Acorn.ESTree.Node, tokenOrComment: TokenOrComment): string {
     const AT = AcornTokenizer;
     if (AT.lineComment(tokenOrComment)) {
       return 'tn';
@@ -241,7 +241,7 @@ export class JavaScriptFormatter {
           // it exists. We can't fix that, unless we use proper typechecking
           allVariablesInitialized = allVariablesInitialized && Boolean(declarations[i].init);
         }
-        return !this.inForLoopHeader(node) && allVariablesInitialized ? 'nSSts' : 'ts';
+        return !this.#inForLoopHeader(node) && allVariablesInitialized ? 'nSSts' : 'ts';
       }
     } else if (node.type === 'PropertyDefinition') {
       if (AT.punctuator(token, '=')) {
@@ -356,13 +356,13 @@ export class JavaScriptFormatter {
     return AT.keyword(token) && !AT.keyword(token, 'this') ? 'ts' : 't';
   }
 
-  private finishNode(node: Acorn.ESTree.Node): string {
+  #finishNode(node: Acorn.ESTree.Node): string {
     if (node.type === 'WithStatement') {
       if (node.body && node.body.type !== 'BlockStatement') {
         return 'n<';
       }
     } else if (node.type === 'VariableDeclaration') {
-      if (!this.inForLoopHeader(node)) {
+      if (!this.#inForLoopHeader(node)) {
         return 'n';
       }
     } else if (node.type === 'ForStatement' || node.type === 'ForOfStatement' || node.type === 'ForInStatement') {

package/front_end/entrypoints/heap_snapshot_worker/AllocationProfile.ts

@@ -33,43 +33,38 @@ import * as HeapSnapshotModel from '../../models/heap_snapshot_model/heap_snapsh
 export class AllocationProfile {
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly strings: any;
-  // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private readonly liveObjectStats: any;
-  private nextNodeId: number;
-  private functionInfos: FunctionAllocationInfo[];
-  private idToNode: {[x: number]: BottomUpAllocationNode|null};
-  private readonly idToTopDownNode: {[x: number]: TopDownAllocationNode};
-  private collapsedTopNodeIdToFunctionInfo: {[x: number]: FunctionAllocationInfo};
-  private traceTops: HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[]|null;
-  private readonly traceTree: TopDownAllocationNode;
+  readonly #strings: any;
+  #nextNodeId: number;
+  #functionInfos: FunctionAllocationInfo[];
+  #idToNode: {[x: number]: BottomUpAllocationNode|null};
+  readonly #idToTopDownNode: {[x: number]: TopDownAllocationNode};
+  #collapsedTopNodeIdToFunctionInfo: {[x: number]: FunctionAllocationInfo};
+  #traceTops: HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[]|null;
 
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   constructor(profile: any, liveObjectStats: any) {
-    this.strings = profile.strings;
-    this.liveObjectStats = liveObjectStats;
+    this.#strings = profile.strings;
 
-    this.nextNodeId = 1;
-    this.functionInfos = [];
+    this.#nextNodeId = 1;
+    this.#functionInfos = [];
 
-    this.idToNode = {};
+    this.#idToNode = {};
 
-    this.idToTopDownNode = {};
+    this.#idToTopDownNode = {};
 
-    this.collapsedTopNodeIdToFunctionInfo = {};
+    this.#collapsedTopNodeIdToFunctionInfo = {};
 
-    this.traceTops = null;
+    this.#traceTops = null;
 
-    this.buildFunctionAllocationInfos(profile);
-    this.traceTree = this.buildAllocationTree(profile, liveObjectStats);
+    this.#buildFunctionAllocationInfos(profile);
+    this.#buildAllocationTree(profile, liveObjectStats);
   }
 
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private buildFunctionAllocationInfos(profile: any): void {
-    const strings = this.strings;
+  #buildFunctionAllocationInfos(profile: any): void {
+    const strings = this.#strings;
 
     const functionInfoFields = profile.snapshot.meta.trace_function_info_fields;
     const functionNameOffset = functionInfoFields.indexOf('name');
@@ -81,7 +76,7 @@ export class AllocationProfile {
 
     const rawInfos = profile.trace_function_infos;
     const infoLength = rawInfos.length;
-    const functionInfos = this.functionInfos = new Array(infoLength / functionInfoFieldCount);
+    const functionInfos = this.#functionInfos = new Array(infoLength / functionInfoFieldCount);
     let index = 0;
     for (let i = 0; i < infoLength; i += functionInfoFieldCount) {
       functionInfos[index++] = new FunctionAllocationInfo(
@@ -92,10 +87,10 @@ export class AllocationProfile {
 
   // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  private buildAllocationTree(profile: any, liveObjectStats: any): TopDownAllocationNode {
+  #buildAllocationTree(profile: any, liveObjectStats: any): TopDownAllocationNode {
     const traceTreeRaw = profile.trace_tree;
-    const functionInfos = this.functionInfos;
-    const idToTopDownNode = this.idToTopDownNode;
+    const functionInfos = this.#functionInfos;
+    const idToTopDownNode = this.#idToTopDownNode;
 
     const traceNodeFields = profile.snapshot.meta.trace_node_fields;
     const nodeIdOffset = traceNodeFields.indexOf('id');
@@ -132,22 +127,22 @@ export class AllocationProfile {
   }
 
   serializeTraceTops(): HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[] {
-    if (this.traceTops) {
-      return this.traceTops;
+    if (this.#traceTops) {
+      return this.#traceTops;
     }
 
-    const result: HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[] = this.traceTops = [];
-    const functionInfos = this.functionInfos;
+    const result: HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[] = this.#traceTops = [];
+    const functionInfos = this.#functionInfos;
     for (let i = 0; i < functionInfos.length; i++) {
       const info = functionInfos[i];
       if (info.totalCount === 0) {
         continue;
       }
-      const nodeId = this.nextNodeId++;
+      const nodeId = this.#nextNodeId++;
       const isRoot = i === 0;
-      result.push(this.serializeNode(
+      result.push(this.#serializeNode(
           nodeId, info, info.totalCount, info.totalSize, info.totalLiveCount, info.totalLiveSize, !isRoot));
-      this.collapsedTopNodeIdToFunctionInfo[nodeId] = info;
+      this.#collapsedTopNodeIdToFunctionInfo[nodeId] = info;
     }
     result.sort(function(a, b) {
       return b.size - a.size;
@@ -156,24 +151,24 @@ export class AllocationProfile {
   }
 
   serializeCallers(nodeId: number): HeapSnapshotModel.HeapSnapshotModel.AllocationNodeCallers {
-    let node = this.ensureBottomUpNode(nodeId);
+    let node = this.#ensureBottomUpNode(nodeId);
     const nodesWithSingleCaller = [];
     while (node.callers().length === 1) {
       node = node.callers()[0];
-      nodesWithSingleCaller.push(this.serializeCaller(node));
+      nodesWithSingleCaller.push(this.#serializeCaller(node));
     }
 
     const branchingCallers = [];
     const callers = node.callers();
     for (let i = 0; i < callers.length; i++) {
-      branchingCallers.push(this.serializeCaller(callers[i]));
+      branchingCallers.push(this.#serializeCaller(callers[i]));
     }
 
     return new HeapSnapshotModel.HeapSnapshotModel.AllocationNodeCallers(nodesWithSingleCaller, branchingCallers);
   }
 
   serializeAllocationStack(traceNodeId: number): HeapSnapshotModel.HeapSnapshotModel.AllocationStackFrame[] {
-    let node: (TopDownAllocationNode|null)|TopDownAllocationNode = this.idToTopDownNode[traceNodeId];
+    let node: (TopDownAllocationNode|null)|TopDownAllocationNode = this.#idToTopDownNode[traceNodeId];
     const result = [];
     while (node) {
       const functionInfo = node.functionInfo;
@@ -186,29 +181,29 @@ export class AllocationProfile {
   }
 
   traceIds(allocationNodeId: number): number[] {
-    return this.ensureBottomUpNode(allocationNodeId).traceTopIds;
+    return this.#ensureBottomUpNode(allocationNodeId).traceTopIds;
   }
 
-  private ensureBottomUpNode(nodeId: number): BottomUpAllocationNode {
-    let node = this.idToNode[nodeId];
+  #ensureBottomUpNode(nodeId: number): BottomUpAllocationNode {
+    let node = this.#idToNode[nodeId];
     if (!node) {
-      const functionInfo = this.collapsedTopNodeIdToFunctionInfo[nodeId];
+      const functionInfo = this.#collapsedTopNodeIdToFunctionInfo[nodeId];
       node = functionInfo.bottomUpRoot();
-      delete this.collapsedTopNodeIdToFunctionInfo[nodeId];
-      this.idToNode[nodeId] = node;
+      delete this.#collapsedTopNodeIdToFunctionInfo[nodeId];
+      this.#idToNode[nodeId] = node;
     }
     return node as BottomUpAllocationNode;
   }
 
-  private serializeCaller(node: BottomUpAllocationNode): HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode {
-    const callerId = this.nextNodeId++;
-    this.idToNode[callerId] = node;
-    return this.serializeNode(
+  #serializeCaller(node: BottomUpAllocationNode): HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode {
+    const callerId = this.#nextNodeId++;
+    this.#idToNode[callerId] = node;
+    return this.#serializeNode(
         callerId, node.functionInfo, node.allocationCount, node.allocationSize, node.liveCount, node.liveSize,
         node.hasCallers());
   }
 
-  private serializeNode(
+  #serializeNode(
       nodeId: number, functionInfo: FunctionAllocationInfo, count: number, size: number, liveCount: number,
       liveSize: number, hasChildren: boolean): HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode {
     return new HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode(
@@ -248,7 +243,7 @@ export class BottomUpAllocationNode {
   liveCount: number;
   liveSize: number;
   traceTopIds: number[];
-  private readonly callersInternal: BottomUpAllocationNode[];
+  readonly #callersInternal: BottomUpAllocationNode[];
   constructor(functionInfo: FunctionAllocationInfo) {
     this.functionInfo = functionInfo;
     this.allocationCount = 0;
@@ -258,14 +253,14 @@ export class BottomUpAllocationNode {
 
     this.traceTopIds = [];
 
-    this.callersInternal = [];
+    this.#callersInternal = [];
   }
 
   addCaller(traceNode: TopDownAllocationNode): BottomUpAllocationNode {
     const functionInfo = traceNode.functionInfo;
     let result;
-    for (let i = 0; i < this.callersInternal.length; i++) {
-      const caller = this.callersInternal[i];
+    for (let i = 0; i < this.#callersInternal.length; i++) {
+      const caller = this.#callersInternal[i];
       if (caller.functionInfo === functionInfo) {
         result = caller;
         break;
@@ -273,17 +268,17 @@ export class BottomUpAllocationNode {
     }
     if (!result) {
       result = new BottomUpAllocationNode(functionInfo);
-      this.callersInternal.push(result);
+      this.#callersInternal.push(result);
     }
     return result;
   }
 
   callers(): BottomUpAllocationNode[] {
-    return this.callersInternal;
+    return this.#callersInternal;
   }
 
   hasCallers(): boolean {
-    return this.callersInternal.length > 0;
+    return this.#callersInternal.length > 0;
   }
 }
 
@@ -297,8 +292,8 @@ export class FunctionAllocationInfo {
   totalSize: number;
   totalLiveCount: number;
   totalLiveSize: number;
-  private traceTops: TopDownAllocationNode[];
-  private bottomUpTree?: BottomUpAllocationNode;
+  #traceTops: TopDownAllocationNode[];
+  #bottomUpTree?: BottomUpAllocationNode;
   constructor(functionName: string, scriptName: string, scriptId: number, line: number, column: number) {
     this.functionName = functionName;
     this.scriptName = scriptName;
@@ -310,14 +305,14 @@ export class FunctionAllocationInfo {
     this.totalLiveCount = 0;
     this.totalLiveSize = 0;
 
-    this.traceTops = [];
+    this.#traceTops = [];
   }
 
   addTraceTopNode(node: TopDownAllocationNode): void {
     if (node.allocationCount === 0) {
       return;
     }
-    this.traceTops.push(node);
+    this.#traceTops.push(node);
     this.totalCount += node.allocationCount;
     this.totalSize += node.allocationSize;
     this.totalLiveCount += node.liveCount;
@@ -325,21 +320,21 @@ export class FunctionAllocationInfo {
   }
 
   bottomUpRoot(): BottomUpAllocationNode|null {
-    if (!this.traceTops.length) {
+    if (!this.#traceTops.length) {
       return null;
     }
-    if (!this.bottomUpTree) {
-      this.buildAllocationTraceTree();
+    if (!this.#bottomUpTree) {
+      this.#buildAllocationTraceTree();
     }
-    return this.bottomUpTree as BottomUpAllocationNode;
+    return this.#bottomUpTree as BottomUpAllocationNode;
   }
 
-  private buildAllocationTraceTree(): void {
-    this.bottomUpTree = new BottomUpAllocationNode(this);
+  #buildAllocationTraceTree(): void {
+    this.#bottomUpTree = new BottomUpAllocationNode(this);
 
-    for (let i = 0; i < this.traceTops.length; i++) {
-      let node: (TopDownAllocationNode|null)|TopDownAllocationNode = this.traceTops[i];
-      let bottomUpNode: BottomUpAllocationNode = this.bottomUpTree;
+    for (let i = 0; i < this.#traceTops.length; i++) {
+      let node: (TopDownAllocationNode|null)|TopDownAllocationNode = this.#traceTops[i];
+      let bottomUpNode: BottomUpAllocationNode = this.#bottomUpTree;
       const count = node.allocationCount;
       const size = node.allocationSize;
       const liveCount = node.liveCount;