chrome-devtools-frontend 1.0.930109 → 1.0.930993

package/front_end/models/bindings/DebuggerLanguagePlugins.ts

@@ -16,7 +16,7 @@ import {NetworkProject} from './NetworkProject.js';
 
 const UIStrings = {
   /**
-  *@description Error message that is displayed in the Console when language plugins report errors
+  *@description Error message that is displayed in the Console when language #plugins report errors
   *@example {File not found} PH1
   */
   errorInDebuggerLanguagePlugin: 'Error in debugger language plugin: {PH1}',
@@ -115,7 +115,7 @@ class SourceType {
 /**
  * Generates the raw module ID for a script, which is used
  * to uniquely identify the debugging data for a script on
- * the responsible language plugin.
+ * the responsible language #plugin.
  *
  * @param script the unique raw module ID for the script.
  */
@@ -169,7 +169,7 @@ export class ValueNode extends SDK.RemoteObject.RemoteObjectImpl {
   }
 }
 
-// Debugger language plugins present source-language values as trees with mixed dynamic and static structural
+// Debugger language #plugins present source-language values as trees with mixed dynamic and static structural
 // information. The static structure is defined by the variable's static type in the source language. Formatters are
 // able to present source-language values in an arbitrary user-friendly way, which contributes the dynamic structural
 // information. The classes StaticallyTypedValue and FormatedValueNode respectively implement the static and dynamic
@@ -234,7 +234,7 @@ async function getValueTreeForExpression(
   return new StaticallyTypedValueNode(callFrame, plugin, sourceType, base, [], evalOptions, address);
 }
 
-/** Run the formatter for the value defined by the pair of base and fieldChain.
+/** Run the formatter for the value defined by the pair of #base and #fieldChain.
  */
 async function formatSourceValue(
     callFrame: SDK.DebuggerModel.CallFrame, plugin: DebuggerLanguagePlugin, sourceType: SourceType,
@@ -318,13 +318,13 @@ async function formatSourceValue(
 // StaticallyTypedValueNodes. The class hooks into the creation of RemoteObjects for properties to check whether a
 // property is a marker.
 class FormattedValueNode extends ValueNode {
-  private readonly plugin: DebuggerLanguagePlugin;
-  private readonly sourceType: SourceType;
+  readonly #plugin: DebuggerLanguagePlugin;
+  readonly #sourceType: SourceType;
   formatterTag: {
     className: string,
     symbol: string,
   }|null;
-  private readonly evalOptions: SDK.RuntimeModel.EvaluationOptions;
+  readonly #evalOptions: SDK.RuntimeModel.EvaluationOptions;
   constructor(
       callFrame: SDK.DebuggerModel.CallFrame, sourceType: SourceType, plugin: DebuggerLanguagePlugin,
       object: Protocol.Runtime.RemoteObject, formatterTag: {
@@ -336,13 +336,13 @@ class FormattedValueNode extends ValueNode {
         callFrame, object.objectId, object.type, object.subtype, object.value, inspectableAddress,
         object.unserializableValue, object.description, object.preview, object.customPreview, object.className);
 
-    this.plugin = plugin;
-    this.sourceType = sourceType;
+    this.#plugin = plugin;
+    this.#sourceType = sourceType;
 
     // The tag describes how to identify a marker by its className and its identifier symbol's object id.
     this.formatterTag = formatterTag;
 
-    this.evalOptions = evalOptions;
+    this.#evalOptions = evalOptions;
   }
 
   async findProperties(...properties: string[]): Promise<{
@@ -370,24 +370,24 @@ class FormattedValueNode extends ValueNode {
     const base = await this.getEvalBaseFromObject(newObject);
     if (!base) {
       return new FormattedValueNode(
-          this.callFrame, this.sourceType, this.plugin, newObject, this.formatterTag, this.evalOptions, undefined);
+          this.callFrame, this.#sourceType, this.#plugin, newObject, this.formatterTag, this.#evalOptions, undefined);
     }
 
     // Property is a marker, check if it's just static type information or if we need to run formatters for the value.
-    const newSourceType = this.sourceType.typeMap.get(base.rootType.typeId);
+    const newSourceType = this.#sourceType.typeMap.get(base.rootType.typeId);
     if (!newSourceType) {
       throw new Error('Unknown typeId in eval base');
     }
     // The marker refers to a value that needs to be formatted, so run the formatter.
     if (base.rootType.hasValue && !base.rootType.canExpand && base) {
-      return formatSourceValue(this.callFrame, this.plugin, newSourceType, base, [], this.evalOptions);
+      return formatSourceValue(this.callFrame, this.#plugin, newSourceType, base, [], this.#evalOptions);
     }
 
     // The marker is just static information, so start a new subtree with a static type info root.
     const address =
-        await StaticallyTypedValueNode.getInspectableAddress(this.callFrame, this.plugin, base, [], this.evalOptions);
+        await StaticallyTypedValueNode.getInspectableAddress(this.callFrame, this.#plugin, base, [], this.#evalOptions);
     return new StaticallyTypedValueNode(
-        this.callFrame, this.plugin, newSourceType, base, [], this.evalOptions, address);
+        this.callFrame, this.#plugin, newSourceType, base, [], this.#evalOptions, address);
   }
 
   /**
@@ -418,8 +418,8 @@ class FormattedValueNode extends ValueNode {
 
     // The object is a marker, so pull the static type information from its symbol property. The symbol property is not
     // a formatted value per se, but we wrap it as one to be able to call `findProperties`.
-    const baseObject =
-        new FormattedValueNode(this.callFrame, this.sourceType, this.plugin, result, null, this.evalOptions, undefined);
+    const baseObject = new FormattedValueNode(
+        this.callFrame, this.#sourceType, this.#plugin, result, null, this.#evalOptions, undefined);
     const {payload, rootType} = await baseObject.findProperties('payload', 'rootType');
     if (typeof payload === 'undefined' || typeof rootType === 'undefined') {
       return null;
@@ -430,7 +430,7 @@ class FormattedValueNode extends ValueNode {
       return null;
     }
 
-    const newSourceType = this.sourceType.typeMap.get(typeId.value);
+    const newSourceType = this.#sourceType.typeMap.get(typeId.value);
     if (!newSourceType) {
       return null;
     }
@@ -463,16 +463,16 @@ class FormattingError extends Error {
 }
 
 // This class implements a `RemoteObject` for source language value whose immediate properties are defined purely by
-// static type information. Static type information is expressed by an `EvalBase` together with a `fieldChain`. The
+// static type information. Static type information is expressed by an `EvalBase` together with a `#fieldChain`. The
 // latter is necessary to express navigating through type members. We don't know how to make sense of an `EvalBase`'s
-// payload here, which is why member navigation is relayed to the formatter via the `fieldChain`.
+// payload here, which is why member navigation is relayed to the formatter via the `#fieldChain`.
 class StaticallyTypedValueNode extends ValueNode {
-  private readonly variableType: string;
-  private readonly plugin: DebuggerLanguagePlugin;
-  private readonly sourceType: SourceType;
-  private readonly base: Chrome.DevTools.EvalBase|null;
-  private readonly fieldChain: Chrome.DevTools.FieldInfo[];
-  private readonly evalOptions: SDK.RuntimeModel.EvaluationOptions;
+  readonly #variableType: string;
+  readonly #plugin: DebuggerLanguagePlugin;
+  readonly #sourceType: SourceType;
+  readonly #base: Chrome.DevTools.EvalBase|null;
+  readonly #fieldChain: Chrome.DevTools.FieldInfo[];
+  readonly #evalOptions: SDK.RuntimeModel.EvaluationOptions;
 
   constructor(
       callFrame: SDK.DebuggerModel.CallFrame, plugin: DebuggerLanguagePlugin, sourceType: SourceType,
@@ -486,29 +486,29 @@ class StaticallyTypedValueNode extends ValueNode {
         /* type=*/ variableType,
         /* subtype=*/ undefined, /* value=*/ null, inspectableAddress, /* unserializableValue=*/ undefined,
         /* description=*/ typeName, /* preview=*/ undefined, /* customPreview=*/ undefined, /* className=*/ typeName);
-    this.variableType = variableType;
-    this.plugin = plugin;
-    this.sourceType = sourceType;
-    this.base = base;
-    this.fieldChain = fieldChain;
+    this.#variableType = variableType;
+    this.#plugin = plugin;
+    this.#sourceType = sourceType;
+    this.#base = base;
+    this.#fieldChain = fieldChain;
     this.hasChildrenInternal = true;
-    this.evalOptions = evalOptions;
+    this.#evalOptions = evalOptions;
   }
 
   get type(): string {
-    return this.variableType;
+    return this.#variableType;
   }
 
   private async expandMember(sourceType: SourceType, fieldInfo: Chrome.DevTools.FieldInfo):
       Promise<SDK.RemoteObject.RemoteObject> {
-    const fieldChain = this.fieldChain.concat(fieldInfo);
-    if (sourceType.typeInfo.hasValue && !sourceType.typeInfo.canExpand && this.base) {
-      return formatSourceValue(this.callFrame, this.plugin, sourceType, this.base, fieldChain, this.evalOptions);
+    const fieldChain = this.#fieldChain.concat(fieldInfo);
+    if (sourceType.typeInfo.hasValue && !sourceType.typeInfo.canExpand && this.#base) {
+      return formatSourceValue(this.callFrame, this.#plugin, sourceType, this.#base, fieldChain, this.#evalOptions);
     }
 
     const address = this.inspectableAddress !== undefined ? this.inspectableAddress + fieldInfo.offset : undefined;
     return new StaticallyTypedValueNode(
-        this.callFrame, this.plugin, sourceType, this.base, fieldChain, this.evalOptions, address);
+        this.callFrame, this.#plugin, sourceType, this.#base, fieldChain, this.#evalOptions, address);
   }
 
   static async getInspectableAddress(
@@ -555,7 +555,7 @@ class StaticallyTypedValueNode extends ValueNode {
 
   async doGetProperties(_ownProperties: boolean, accessorPropertiesOnly: boolean, _generatePreview: boolean):
       Promise<SDK.RemoteObject.GetPropertiesResult> {
-    const {typeInfo} = this.sourceType;
+    const {typeInfo} = this.#sourceType;
     if (accessorPropertiesOnly || !typeInfo.canExpand) {
       return {properties: [], internalProperties: []} as SDK.RemoteObject.GetPropertiesResult;
     }
@@ -563,9 +563,9 @@ class StaticallyTypedValueNode extends ValueNode {
     if (typeInfo.members.length > 0) {
       // This value doesn't have a formatter, but we can eagerly expand arrays in the frontend if the size is known.
       if (typeInfo.arraySize > 0) {
-        const {typeId} = this.sourceType.typeInfo.members[0];
+        const {typeId} = this.#sourceType.typeInfo.members[0];
         const properties: SDK.RemoteObject.RemoteObjectProperty[] = [];
-        const elementTypeInfo = this.sourceType.members[0];
+        const elementTypeInfo = this.#sourceType.members[0];
         for (let i = 0; i < typeInfo.arraySize; ++i) {
           const name = `${i}`;
           const elementField = {name, typeId, offset: elementTypeInfo.typeInfo.size * i};
@@ -579,8 +579,8 @@ class StaticallyTypedValueNode extends ValueNode {
       }
 
       // The node is expanded, just make remote objects for its members
-      const members = Promise.all(this.sourceType.members.map(async (memberTypeInfo, idx) => {
-        const fieldInfo = this.sourceType.typeInfo.members[idx];
+      const members = Promise.all(this.#sourceType.members.map(async (memberTypeInfo, idx) => {
+        const fieldInfo = this.#sourceType.typeInfo.members[idx];
         const propertyObject = await this.expandMember(memberTypeInfo, fieldInfo);
         const name = fieldInfo.name || '';
         return new SDK.RemoteObject.RemoteObjectProperty(
@@ -612,17 +612,17 @@ class NamespaceObject extends SDK.RemoteObject.LocalJSONObject {
 
 class SourceScopeRemoteObject extends SDK.RemoteObject.RemoteObjectImpl {
   variables: Chrome.DevTools.Variable[];
-  private callFrame: SDK.DebuggerModel.CallFrame;
-  private plugin: DebuggerLanguagePlugin;
-  private readonly location: Chrome.DevTools.RawLocation;
+  #callFrame: SDK.DebuggerModel.CallFrame;
+  #plugin: DebuggerLanguagePlugin;
+  readonly #location: Chrome.DevTools.RawLocation;
 
   constructor(
       callFrame: SDK.DebuggerModel.CallFrame, plugin: DebuggerLanguagePlugin, location: Chrome.DevTools.RawLocation) {
     super(callFrame.debuggerModel.runtimeModel(), undefined, 'object', undefined, null);
     this.variables = [];
-    this.callFrame = callFrame;
-    this.plugin = plugin;
-    this.location = location;
+    this.#callFrame = callFrame;
+    this.#plugin = plugin;
+    this.#location = location;
   }
 
   async doGetProperties(ownProperties: boolean, accessorPropertiesOnly: boolean, _generatePreview: boolean):
@@ -645,7 +645,7 @@ class SourceScopeRemoteObject extends SDK.RemoteObject.RemoteObjectImpl {
     for (const variable of this.variables) {
       let sourceVar;
       try {
-        sourceVar = await getValueTreeForExpression(this.callFrame, this.plugin, variable.name, ({
+        sourceVar = await getValueTreeForExpression(this.#callFrame, this.#plugin, variable.name, ({
                                                       generatePreview: false,
                                                       includeCommandLineAPI: true,
                                                       objectGroup: 'backtrace',
@@ -686,33 +686,33 @@ class SourceScopeRemoteObject extends SDK.RemoteObject.RemoteObjectImpl {
 }
 
 export class SourceScope implements SDK.DebuggerModel.ScopeChainEntry {
-  private readonly callFrameInternal: SDK.DebuggerModel.CallFrame;
-  private readonly typeInternal: string;
-  private readonly typeNameInternal: string;
-  private readonly iconInternal: string|undefined;
-  private readonly objectInternal: SourceScopeRemoteObject;
-  private readonly nameInternal: string;
-  private readonly startLocationInternal: SDK.DebuggerModel.Location|null;
-  private readonly endLocationInternal: SDK.DebuggerModel.Location|null;
+  readonly #callFrameInternal: SDK.DebuggerModel.CallFrame;
+  readonly #typeInternal: string;
+  readonly #typeNameInternal: string;
+  readonly #iconInternal: string|undefined;
+  readonly #objectInternal: SourceScopeRemoteObject;
+  readonly #nameInternal: string;
+  readonly #startLocationInternal: SDK.DebuggerModel.Location|null;
+  readonly #endLocationInternal: SDK.DebuggerModel.Location|null;
   constructor(
       callFrame: SDK.DebuggerModel.CallFrame, type: string, typeName: string, icon: string|undefined,
       plugin: DebuggerLanguagePlugin, location: Chrome.DevTools.RawLocation) {
-    this.callFrameInternal = callFrame;
-    this.typeInternal = type;
-    this.typeNameInternal = typeName;
-    this.iconInternal = icon;
-    this.objectInternal = new SourceScopeRemoteObject(callFrame, plugin, location);
-    this.nameInternal = type;
-    this.startLocationInternal = null;
-    this.endLocationInternal = null;
+    this.#callFrameInternal = callFrame;
+    this.#typeInternal = type;
+    this.#typeNameInternal = typeName;
+    this.#iconInternal = icon;
+    this.#objectInternal = new SourceScopeRemoteObject(callFrame, plugin, location);
+    this.#nameInternal = type;
+    this.#startLocationInternal = null;
+    this.#endLocationInternal = null;
   }
 
   async getVariableValue(name: string): Promise<SDK.RemoteObject.RemoteObject|null> {
-    for (let v = 0; v < this.objectInternal.variables.length; ++v) {
-      if (this.objectInternal.variables[v].name !== name) {
+    for (let v = 0; v < this.#objectInternal.variables.length; ++v) {
+      if (this.#objectInternal.variables[v].name !== name) {
         continue;
       }
-      const properties = await this.objectInternal.getAllProperties(false, false);
+      const properties = await this.#objectInternal.getAllProperties(false, false);
       if (!properties.properties) {
         continue;
       }
@@ -725,15 +725,15 @@ export class SourceScope implements SDK.DebuggerModel.ScopeChainEntry {
   }
 
   callFrame(): SDK.DebuggerModel.CallFrame {
-    return this.callFrameInternal;
+    return this.#callFrameInternal;
   }
 
   type(): string {
-    return this.typeInternal;
+    return this.#typeInternal;
   }
 
   typeName(): string {
-    return this.typeNameInternal;
+    return this.#typeNameInternal;
   }
 
   name(): string|undefined {
@@ -741,15 +741,15 @@ export class SourceScope implements SDK.DebuggerModel.ScopeChainEntry {
   }
 
   startLocation(): SDK.DebuggerModel.Location|null {
-    return this.startLocationInternal;
+    return this.#startLocationInternal;
   }
 
   endLocation(): SDK.DebuggerModel.Location|null {
-    return this.endLocationInternal;
+    return this.#endLocationInternal;
   }
 
   object(): SourceScopeRemoteObject {
-    return this.objectInternal;
+    return this.#objectInternal;
   }
 
   description(): string {
@@ -757,17 +757,17 @@ export class SourceScope implements SDK.DebuggerModel.ScopeChainEntry {
   }
 
   icon(): string|undefined {
-    return this.iconInternal;
+    return this.#iconInternal;
   }
 }
 
 export class DebuggerLanguagePluginManager implements
     SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
-  private readonly workspace: Workspace.Workspace.WorkspaceImpl;
-  private readonly debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
-  private plugins: DebuggerLanguagePlugin[];
-  private readonly debuggerModelToData: Map<SDK.DebuggerModel.DebuggerModel, ModelData>;
-  private readonly rawModuleHandles: Map<string, {
+  readonly #workspace: Workspace.Workspace.WorkspaceImpl;
+  readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
+  #plugins: DebuggerLanguagePlugin[];
+  readonly #debuggerModelToData: Map<SDK.DebuggerModel.DebuggerModel, ModelData>;
+  readonly #rawModuleHandles: Map<string, {
     rawModuleId: string,
     plugin: DebuggerLanguagePlugin,
     scripts: Array<SDK.Script.Script>,
@@ -777,15 +777,15 @@ export class DebuggerLanguagePluginManager implements
   constructor(
       targetManager: SDK.TargetManager.TargetManager, workspace: Workspace.Workspace.WorkspaceImpl,
       debuggerWorkspaceBinding: DebuggerWorkspaceBinding) {
-    this.workspace = workspace;
-    this.debuggerWorkspaceBinding = debuggerWorkspaceBinding;
+    this.#workspace = workspace;
+    this.#debuggerWorkspaceBinding = debuggerWorkspaceBinding;
 
-    this.plugins = [];
+    this.#plugins = [];
 
-    this.debuggerModelToData = new Map();
+    this.#debuggerModelToData = new Map();
     targetManager.observeModels(SDK.DebuggerModel.DebuggerModel, this);
 
-    this.rawModuleHandles = new Map();
+    this.#rawModuleHandles = new Map();
   }
 
   private async evaluateOnCallFrame(
@@ -842,7 +842,7 @@ export class DebuggerLanguagePluginManager implements
   }
 
   modelAdded(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
-    this.debuggerModelToData.set(debuggerModel, new ModelData(debuggerModel, this.workspace));
+    this.#debuggerModelToData.set(debuggerModel, new ModelData(debuggerModel, this.#workspace));
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.GlobalObjectCleared, this.globalObjectCleared, this);
     debuggerModel.addEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this);
     debuggerModel.setEvaluateOnCallFrameCallback(this.evaluateOnCallFrame.bind(this));
@@ -854,19 +854,19 @@ export class DebuggerLanguagePluginManager implements
     debuggerModel.removeEventListener(SDK.DebuggerModel.Events.ParsedScriptSource, this.parsedScriptSource, this);
     debuggerModel.setEvaluateOnCallFrameCallback(null);
     debuggerModel.setExpandCallFramesCallback(null);
-    const modelData = this.debuggerModelToData.get(debuggerModel);
+    const modelData = this.#debuggerModelToData.get(debuggerModel);
     if (modelData) {
       modelData.dispose();
-      this.debuggerModelToData.delete(debuggerModel);
+      this.#debuggerModelToData.delete(debuggerModel);
     }
-    this.rawModuleHandles.forEach((rawModuleHandle, rawModuleId) => {
+    this.#rawModuleHandles.forEach((rawModuleHandle, rawModuleId) => {
       const scripts = rawModuleHandle.scripts.filter(script => script.debuggerModel !== debuggerModel);
       if (scripts.length === 0) {
         rawModuleHandle.plugin.removeRawModule(rawModuleId).catch(error => {
           Common.Console.Console.instance().error(
               i18nString(UIStrings.errorInDebuggerLanguagePlugin, {PH1: error.message}));
         });
-        this.rawModuleHandles.delete(rawModuleId);
+        this.#rawModuleHandles.delete(rawModuleId);
       } else {
         rawModuleHandle.scripts = scripts;
       }
@@ -880,8 +880,8 @@ export class DebuggerLanguagePluginManager implements
   }
 
   addPlugin(plugin: DebuggerLanguagePlugin): void {
-    this.plugins.push(plugin);
-    for (const debuggerModel of this.debuggerModelToData.keys()) {
+    this.#plugins.push(plugin);
+    for (const debuggerModel of this.#debuggerModelToData.keys()) {
       for (const script of debuggerModel.scripts()) {
         if (this.hasPluginForScript(script)) {
           continue;
@@ -892,24 +892,24 @@ export class DebuggerLanguagePluginManager implements
   }
 
   removePlugin(plugin: DebuggerLanguagePlugin): void {
-    this.plugins = this.plugins.filter(p => p !== plugin);
+    this.#plugins = this.#plugins.filter(p => p !== plugin);
     const scripts = new Set<SDK.Script.Script>();
-    this.rawModuleHandles.forEach((rawModuleHandle, rawModuleId) => {
+    this.#rawModuleHandles.forEach((rawModuleHandle, rawModuleId) => {
       if (rawModuleHandle.plugin !== plugin) {
         return;
       }
       rawModuleHandle.scripts.forEach(script => scripts.add(script));
-      this.rawModuleHandles.delete(rawModuleId);
+      this.#rawModuleHandles.delete(rawModuleId);
     });
     for (const script of scripts) {
-      const modelData = (this.debuggerModelToData.get(script.debuggerModel) as ModelData);
+      const modelData = (this.#debuggerModelToData.get(script.debuggerModel) as ModelData);
       modelData.removeScript(script);
 
-      // Let's see if we have another plugin that's happy to
+      // Let's see if we have another #plugin that's happy to
       // take this orphaned script now. This is important to
-      // get right, since the same plugin might race during
+      // get right, since the same #plugin might race during
       // unregister/register and we might already have the
-      // new instance of the plugin added before we remove
+      // new instance of the #plugin added before we remove
       // the previous instance.
       this.parsedScriptSource({data: script});
     }
@@ -917,27 +917,27 @@ export class DebuggerLanguagePluginManager implements
 
   hasPluginForScript(script: SDK.Script.Script): boolean {
     const rawModuleId = rawModuleIdForScript(script);
-    const rawModuleHandle = this.rawModuleHandles.get(rawModuleId);
+    const rawModuleHandle = this.#rawModuleHandles.get(rawModuleId);
     return rawModuleHandle !== undefined && rawModuleHandle.scripts.includes(script);
   }
 
   /**
-   * Returns the responsible language plugin and the raw module ID for a script.
+   * Returns the responsible language #plugin and the raw module ID for a script.
    *
    * This ensures that the `addRawModule` call finishes first such that the
-   * caller can immediately issue calls to the returned plugin without the
-   * risk of racing with the `addRawModule` call. The returned plugin will be
-   * set to undefined to indicate that there's no plugin for the script.
+   * caller can immediately issue calls to the returned #plugin without the
+   * risk of racing with the `addRawModule` call. The returned #plugin will be
+   * set to undefined to indicate that there's no #plugin for the script.
    */
   private async rawModuleIdAndPluginForScript(script: SDK.Script.Script): Promise<{
     rawModuleId: string,
     plugin: DebuggerLanguagePlugin|null,
   }> {
     const rawModuleId = rawModuleIdForScript(script);
-    const rawModuleHandle = this.rawModuleHandles.get(rawModuleId);
+    const rawModuleHandle = this.#rawModuleHandles.get(rawModuleId);
     if (rawModuleHandle) {
       await rawModuleHandle.addRawModulePromise;
-      if (rawModuleHandle === this.rawModuleHandles.get(rawModuleId)) {
+      if (rawModuleHandle === this.#rawModuleHandles.get(rawModuleId)) {
         return {rawModuleId, plugin: rawModuleHandle.plugin};
       }
     }
@@ -946,7 +946,7 @@ export class DebuggerLanguagePluginManager implements
 
   uiSourceCodeForURL(debuggerModel: SDK.DebuggerModel.DebuggerModel, url: string): Workspace.UISourceCode.UISourceCode
       |null {
-    const modelData = this.debuggerModelToData.get(debuggerModel);
+    const modelData = this.#debuggerModelToData.get(debuggerModel);
     if (modelData) {
       return modelData.getProject().uiSourceCodeForURL(url);
     }
@@ -966,7 +966,7 @@ export class DebuggerLanguagePluginManager implements
 
     const pluginLocation = {
       rawModuleId,
-      // RawLocation.columnNumber is the byte offset in the full raw wasm module. Plugins expect the offset in the code
+      // RawLocation.#columnNumber is the byte offset in the full raw wasm module. Plugins expect the offset in the code
       // section, so subtract the offset of the code section in the module here.
       codeOffset: rawLocation.columnNumber - (script.codeOffset() || 0),
       inlineFrameIndex: rawLocation.inlineFrameIndex,
@@ -979,7 +979,7 @@ export class DebuggerLanguagePluginManager implements
         if (!uiSourceCode) {
           continue;
         }
-        // Absence of column information is indicated by the value `-1` in talking to language plugins.
+        // Absence of column information is indicated by the value `-1` in talking to language #plugins.
         return uiSourceCode.uiLocation(
             sourceLocation.lineNumber, sourceLocation.columnNumber >= 0 ? sourceLocation.columnNumber : undefined);
       }
@@ -1002,7 +1002,7 @@ export class DebuggerLanguagePluginManager implements
     }[]>[] = [];
     this.scriptsForUISourceCode(uiSourceCode).forEach(script => {
       const rawModuleId = rawModuleIdForScript(script);
-      const rawModuleHandle = this.rawModuleHandles.get(rawModuleId);
+      const rawModuleHandle = this.#rawModuleHandles.get(rawModuleId);
       if (!rawModuleHandle) {
         return;
       }
@@ -1051,7 +1051,7 @@ export class DebuggerLanguagePluginManager implements
   }
 
   scriptsForUISourceCode(uiSourceCode: Workspace.UISourceCode.UISourceCode): SDK.Script.Script[] {
-    for (const modelData of this.debuggerModelToData.values()) {
+    for (const modelData of this.#debuggerModelToData.values()) {
       const scripts = modelData.uiSourceCodeToScripts.get(uiSourceCode);
       if (scripts) {
         return scripts;
@@ -1066,12 +1066,12 @@ export class DebuggerLanguagePluginManager implements
       return;
     }
 
-    for (const plugin of this.plugins) {
+    for (const plugin of this.#plugins) {
       if (!plugin.handleScript(script)) {
         return;
       }
       const rawModuleId = rawModuleIdForScript(script);
-      let rawModuleHandle = this.rawModuleHandles.get(rawModuleId);
+      let rawModuleHandle = this.#rawModuleHandles.get(rawModuleId);
       if (!rawModuleHandle) {
         const sourceFileURLsPromise = (async(): Promise<string[]> => {
           const console = Common.Console.Console.instance();
@@ -1089,7 +1089,7 @@ export class DebuggerLanguagePluginManager implements
             // `rawModuleHandle` below will run before this code because of the `await` in the preceding
             // line. This is primarily to avoid logging the message below, which would give the developer
             // the misleading information that we're done, while in reality it was a stale call that finished.
-            if (rawModuleHandle !== this.rawModuleHandles.get(rawModuleId)) {
+            if (rawModuleHandle !== this.#rawModuleHandles.get(rawModuleId)) {
               return [];
             }
             if (sourceFileURLs.length === 0) {
@@ -1102,27 +1102,27 @@ export class DebuggerLanguagePluginManager implements
           } catch (error) {
             console.error(
                 i18nString(UIStrings.failedToLoadDebugSymbolsFor, {PH1: plugin.name, PH2: url, PH3: error.message}));
-            this.rawModuleHandles.delete(rawModuleId);
+            this.#rawModuleHandles.delete(rawModuleId);
             return [];
           }
         })();
         rawModuleHandle = {rawModuleId, plugin, scripts: [script], addRawModulePromise: sourceFileURLsPromise};
-        this.rawModuleHandles.set(rawModuleId, rawModuleHandle);
+        this.#rawModuleHandles.set(rawModuleId, rawModuleHandle);
       } else {
         rawModuleHandle.scripts.push(script);
       }
 
       // Wait for the addRawModule call to finish and
-      // update the project. It's important to check
+      // update the #project. It's important to check
       // for the DebuggerModel again, which may disappear
       // in the meantime...
       rawModuleHandle.addRawModulePromise.then(sourceFileURLs => {
         // The script might have disappeared meanwhile...
         if (script.debuggerModel.scriptForId(script.scriptId) === script) {
-          const modelData = this.debuggerModelToData.get(script.debuggerModel);
+          const modelData = this.#debuggerModelToData.get(script.debuggerModel);
           if (modelData) {  // The DebuggerModel could have disappeared meanwhile...
             modelData.addSourceFiles(script, sourceFileURLs);
-            this.debuggerWorkspaceBinding.updateLocations(script);
+            this.#debuggerWorkspaceBinding.updateLocations(script);
           }
         }
       });
@@ -1205,7 +1205,7 @@ export class DebuggerLanguagePluginManager implements
 
     const pluginLocation = {
       rawModuleId,
-      // RawLocation.columnNumber is the byte offset in the full raw wasm module. Plugins expect the offset in the code
+      // RawLocation.#columnNumber is the byte offset in the full raw wasm module. Plugins expect the offset in the code
       // section, so subtract the offset of the code section in the module here.
       codeOffset: rawLocation.columnNumber - (script.codeOffset() || 0),
     };
@@ -1242,7 +1242,7 @@ export class DebuggerLanguagePluginManager implements
 
     const pluginLocation = {
       rawModuleId,
-      // RawLocation.columnNumber is the byte offset in the full raw wasm module. Plugins expect the offset in the code
+      // RawLocation.#columnNumber is the byte offset in the full raw wasm module. Plugins expect the offset in the code
       // section, so subtract the offset of the code section in the module here.
       codeOffset: rawLocation.columnNumber - (script.codeOffset() || 0),
     };
@@ -1292,11 +1292,11 @@ export class DebuggerLanguagePluginManager implements
 }
 
 class ModelData {
-  private readonly debuggerModel: SDK.DebuggerModel.DebuggerModel;
+  readonly #debuggerModel: SDK.DebuggerModel.DebuggerModel;
   project: ContentProviderBasedProject;
   readonly uiSourceCodeToScripts: Map<Workspace.UISourceCode.UISourceCode, SDK.Script.Script[]>;
   constructor(debuggerModel: SDK.DebuggerModel.DebuggerModel, workspace: Workspace.Workspace.WorkspaceImpl) {
-    this.debuggerModel = debuggerModel;
+    this.#debuggerModel = debuggerModel;
     this.project = new ContentProviderBasedProject(
         workspace, 'language_plugins::' + debuggerModel.target().id(), Workspace.Workspace.projectTypes.Network, '',
         false /* isServiceProject */);
@@ -1314,7 +1314,7 @@ class ModelData {
         NetworkProject.setInitialFrameAttribution(uiSourceCode, script.frameId);
 
         // Bind the uiSourceCode to the script first before we add the
-        // uiSourceCode to the project and thereby notify the rest of
+        // uiSourceCode to the #project and thereby notify the rest of
         // the system about the new source file.
         // https://crbug.com/1150295 is an example where the breakpoint
         // resolution logic kicks in right after adding the uiSourceCode
@@ -1371,21 +1371,21 @@ export class DebuggerLanguagePlugin {
   dispose(): void {
   }
 
-  /** Notify the plugin about a new script
+  /** Notify the #plugin about a new script
     */
   async addRawModule(_rawModuleId: string, _symbolsURL: string, _rawModule: Chrome.DevTools.RawModule):
       Promise<string[]> {
     throw new Error('Not implemented yet');
   }
 
-  /** Find locations in raw modules from a location in a source file
+  /** Find #locations in raw modules from a #location in a source file
     */
   async sourceLocationToRawLocation(_sourceLocation: Chrome.DevTools.SourceLocation):
       Promise<Chrome.DevTools.RawLocationRange[]> {
     throw new Error('Not implemented yet');
   }
 
-  /** Find locations in source files from a location in a raw module
+  /** Find #locations in source files from a #location in a raw module
     */
   async rawLocationToSourceLocation(_rawLocation: Chrome.DevTools.RawLocation):
       Promise<Chrome.DevTools.SourceLocation[]> {
@@ -1398,14 +1398,14 @@ export class DebuggerLanguagePlugin {
     throw new Error('Not implemented yet');
   }
 
-  /** List all variables in lexical scope at a given location in a raw module
+  /** List all variables in lexical scope at a given #location in a raw module
     */
   async listVariablesInScope(_rawLocation: Chrome.DevTools.RawLocation): Promise<Chrome.DevTools.Variable[]> {
     throw new Error('Not implemented yet');
   }
 
   /**
-   * Notifies the plugin that a script is removed.
+   * Notifies the #plugin that a script is removed.
    */
   removeRawModule(_rawModuleId: string): Promise<void> {
     throw new Error('Not implemented yet');
@@ -1439,7 +1439,7 @@ export class DebuggerLanguagePlugin {
   }
 
   /**
-   * Find locations in source files from a location in a raw module
+   * Find #locations in source files from a #location in a raw module
    */
   async getFunctionInfo(_rawLocation: Chrome.DevTools.RawLocation): Promise<{
     frames: Array<Chrome.DevTools.FunctionInfo>,
@@ -1449,7 +1449,7 @@ export class DebuggerLanguagePlugin {
   }
 
   /**
-   * Find locations in raw modules corresponding to the inline function
+   * Find #locations in raw modules corresponding to the inline function
    * that rawLocation is in. Used for stepping out of an inline function.
    */
   async getInlinedFunctionRanges(_rawLocation: Chrome.DevTools.RawLocation):
@@ -1458,7 +1458,7 @@ export class DebuggerLanguagePlugin {
   }
 
   /**
-   * Find locations in raw modules corresponding to inline functions
+   * Find #locations in raw modules corresponding to inline functions
    * called by the function or inline frame that rawLocation is in.
    * Used for stepping over inline functions.
    */