chrome-devtools-frontend 1.0.1015822 → 1.0.1016075

package/front_end/core/sdk/DebuggerModel.ts

@@ -314,7 +314,7 @@ export class DebuggerModel extends SDKModel<EventTypes> {
     await this.agent.invoke_disable();
     this.#isPausingInternal = false;
     this.globalObjectCleared();
-    this.dispatchEventToListeners(Events.DebuggerWasDisabled);
+    this.dispatchEventToListeners(Events.DebuggerWasDisabled, this);
     if (typeof this.#debuggerId === 'string') {
       _debuggerIdToModel.delete(this.#debuggerId);
     }
@@ -973,7 +973,7 @@ export enum Events {
 
 export type EventTypes = {
   [Events.DebuggerWasEnabled]: DebuggerModel,
-  [Events.DebuggerWasDisabled]: void,
+  [Events.DebuggerWasDisabled]: DebuggerModel,
   [Events.DebuggerPaused]: DebuggerModel,
   [Events.DebuggerResumed]: DebuggerModel,
   [Events.ParsedScriptSource]: Script,

package/front_end/core/sdk/Script.ts

@@ -257,28 +257,29 @@ export class Script implements TextUtils.ContentProvider.ContentProvider, FrameA
     return source + '\n //# sourceURL=' + this.sourceURL;
   }
 
-  async editSource(newSource: string):
-      Promise<{error: string | null, exceptionDetails?: Protocol.Runtime.ExceptionDetails}> {
+  async editSource(newSource: string): Promise<
+      {status: Protocol.Debugger.SetScriptSourceResponseStatus, exceptionDetails?: Protocol.Runtime.ExceptionDetails}> {
     newSource = Script.trimSourceURLComment(newSource);
     // We append correct #sourceURL to script for consistency only. It's not actually needed for things to work correctly.
     newSource = this.appendSourceURLCommentIfNeeded(newSource);
 
-    if (!this.scriptId) {
-      return {error: 'Script failed to parse'};
-    }
-
     const {content: oldSource} = await this.requestContent();
     if (oldSource === newSource) {
-      return {error: null};
+      return {status: Protocol.Debugger.SetScriptSourceResponseStatus.Ok};
     }
     const response = await this.debuggerModel.target().debuggerAgent().invoke_setScriptSource(
         {scriptId: this.scriptId, scriptSource: newSource});
+    if (response.getError()) {
+      // Something went seriously wrong, like the V8 inspector no longer knowing about this script without
+      // shutting down the Debugger agent etc.
+      throw new Error(`Script#editSource failed for script with id ${this.scriptId}: ${response.getError()}`);
+    }
 
-    if (!response.getError() && !response.exceptionDetails) {
+    if (!response.getError() && response.status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
       this.#contentPromise = Promise.resolve({content: newSource, isEncoded: false});
     }
 
-    return {error: response.getError() || null, exceptionDetails: response.exceptionDetails};
+    return {status: response.status, exceptionDetails: response.exceptionDetails};
   }
 
   rawLocation(lineNumber: number, columnNumber: number): Location|null {

package/front_end/models/bindings/BreakpointManager.ts

@@ -409,6 +409,18 @@ export type EventTypes = {
   [Events.BreakpointRemoved]: BreakpointLocation,
 };
 
+const enum DebuggerUpdateResult {
+  OK = 'OK',
+  ERROR = 'ERROR',
+  // PENDING implies that the current update requires another re-run.
+  PENDING = 'PENDING',
+}
+
+const enum ResolveLocationResult {
+  OK = 'OK',
+  ERROR = 'ERROR',
+}
+
 export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.DebuggerModel.DebuggerModel> {
   readonly breakpointManager: BreakpointManager;
   urlInternal: Platform.DevToolsPath.UrlString;
@@ -444,25 +456,49 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
 
   async refreshInDebugger(): Promise<void> {
     if (!this.isRemoved) {
-      const breakpoints = Array.from(this.#modelBreakpoints.values());
-      await Promise.all(breakpoints.map(breakpoint => breakpoint.refreshBreakpoint()));
+      const modelBreakpoints = Array.from(this.#modelBreakpoints.values());
+      await Promise.all(modelBreakpoints.map(async modelBreakpoint => {
+        await modelBreakpoint.resetBreakpoint();
+        return this.#updateModel(modelBreakpoint);
+      }));
     }
   }
 
   modelAdded(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
     const debuggerWorkspaceBinding = this.breakpointManager.debuggerWorkspaceBinding;
-    this.#modelBreakpoints.set(debuggerModel, new ModelBreakpoint(debuggerModel, this, debuggerWorkspaceBinding));
+    const modelBreakpoint = new ModelBreakpoint(debuggerModel, this, debuggerWorkspaceBinding);
+    this.#modelBreakpoints.set(debuggerModel, modelBreakpoint);
+    void this.#updateModel(modelBreakpoint);
+
+    debuggerModel.addEventListener(SDK.DebuggerModel.Events.DebuggerWasEnabled, this.#onDebuggerEnabled, this);
+    debuggerModel.addEventListener(SDK.DebuggerModel.Events.DebuggerWasDisabled, this.#onDebuggerDisabled, this);
   }
 
   modelRemoved(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
     const modelBreakpoint = this.#modelBreakpoints.get(debuggerModel);
+    modelBreakpoint?.cleanUpAfterDebuggerIsGone();
     this.#modelBreakpoints.delete(debuggerModel);
 
-    if (!modelBreakpoint) {
-      return;
+    this.#removeDebuggerModelListeners(debuggerModel);
+  }
+
+  #removeDebuggerModelListeners(debuggerModel: SDK.DebuggerModel.DebuggerModel): void {
+    debuggerModel.removeEventListener(SDK.DebuggerModel.Events.DebuggerWasEnabled, this.#onDebuggerEnabled, this);
+    debuggerModel.removeEventListener(SDK.DebuggerModel.Events.DebuggerWasDisabled, this.#onDebuggerDisabled, this);
+  }
+
+  #onDebuggerEnabled(event: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.DebuggerModel>): void {
+    const debuggerModel = event.data;
+    const model = this.#modelBreakpoints.get(debuggerModel);
+    if (model) {
+      void this.#updateModel(model);
     }
-    modelBreakpoint.cleanUpAfterDebuggerIsGone();
-    modelBreakpoint.removeEventListeners();
+  }
+
+  #onDebuggerDisabled(event: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.DebuggerModel>): void {
+    const debuggerModel = event.data;
+    const model = this.#modelBreakpoints.get(debuggerModel);
+    model?.cleanUpAfterDebuggerIsGone();
   }
 
   modelBreakpoint(debuggerModel: SDK.DebuggerModel.DebuggerModel): ModelBreakpoint|undefined {
@@ -589,21 +625,17 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
         this.addAllUnboundLocations();
       }
     }
-    await Promise.all(
-        Array.from(this.#modelBreakpoints.values()).map(modelBreakpoint => modelBreakpoint.scheduleUpdateInDebugger()));
+    return this.#updateModels();
   }
 
   async remove(keepInStorage: boolean): Promise<void> {
     this.isRemoved = true;
     const removeFromStorage = !keepInStorage;
 
-    // Await removing for all targets.
-    const updatePromises: Promise<void>[] = [];
-    for (const modelBreakpoint of this.#modelBreakpoints.values()) {
-      modelBreakpoint.removeEventListeners();
-      updatePromises.push(modelBreakpoint.scheduleUpdateInDebugger());
+    for (const debuggerModel of this.#modelBreakpoints.keys()) {
+      this.#removeDebuggerModelListeners(debuggerModel);
     }
-    await Promise.all(updatePromises);
+    await this.#updateModels();
 
     this.breakpointManager.removeBreakpoint(this, removeFromStorage);
     this.breakpointManager.targetManager.unobserveModels(SDK.DebuggerModel.DebuggerModel, this);
@@ -638,6 +670,17 @@ export class Breakpoint implements SDK.TargetManager.SDKModelObserver<SDK.Debugg
   getIsRemoved(): boolean {
     return this.isRemoved;
   }
+
+  async #updateModels(): Promise<void> {
+    await Promise.all(Array.from(this.#modelBreakpoints.values()).map(model => this.#updateModel(model)));
+  }
+
+  async #updateModel(model: ModelBreakpoint): Promise<void> {
+    const success = await model.scheduleUpdateInDebugger();
+    if (!success) {
+      await this.remove(false);
+    }
+  }
 }
 
 export class ModelBreakpoint {
@@ -646,8 +689,7 @@ export class ModelBreakpoint {
   readonly #debuggerWorkspaceBinding: DebuggerWorkspaceBinding;
   readonly #liveLocations: LiveLocationPool;
   readonly #uiLocations: Map<LiveLocation, Workspace.UISourceCode.UILocation>;
-  #hasPendingUpdate: boolean;
-  #updatePromise: Promise<void>|null;
+  #updateMutex = new Common.Mutex.Mutex();
   #cancelCallback: boolean;
   #currentState: Breakpoint.State|null;
   #breakpointIds: Protocol.Debugger.BreakpointId[];
@@ -662,18 +704,9 @@ export class ModelBreakpoint {
     this.#liveLocations = new LiveLocationPool();
 
     this.#uiLocations = new Map();
-    this.#debuggerModel.addEventListener(
-        SDK.DebuggerModel.Events.DebuggerWasDisabled, this.cleanUpAfterDebuggerIsGone, this);
-    this.#debuggerModel.addEventListener(
-        SDK.DebuggerModel.Events.DebuggerWasEnabled, this.scheduleUpdateInDebugger, this);
-    this.#hasPendingUpdate = false;
-    this.#updatePromise = null;
     this.#cancelCallback = false;
     this.#currentState = null;
     this.#breakpointIds = [];
-    if (this.#debuggerModel.debuggerEnabled()) {
-      void this.scheduleUpdateInDebugger();
-    }
   }
 
   get currentState(): Breakpoint.State|null {
@@ -689,18 +722,20 @@ export class ModelBreakpoint {
     this.#liveLocations.disposeAll();
   }
 
-  scheduleUpdateInDebugger(): Promise<void> {
-    this.#hasPendingUpdate = true;
-    if (!this.#updatePromise) {
-      this.#updatePromise = (async(): Promise<void> => {
-        while (this.#hasPendingUpdate) {
-          this.#hasPendingUpdate = false;
-          await this.updateInDebugger();
-        }
-        this.#updatePromise = null;
-      })();
+  // Returns true, if scheduling ran as expected.
+  // Returns false, if an error occurred.
+  async scheduleUpdateInDebugger(): Promise<boolean> {
+    if (!this.#debuggerModel.debuggerEnabled()) {
+      return true;
+    }
+
+    const release = await this.#updateMutex.acquire();
+    let result = DebuggerUpdateResult.PENDING;
+    while (result === DebuggerUpdateResult.PENDING) {
+      result = await this.#updateInDebugger();
     }
-    return this.#updatePromise;
+    release();
+    return result === DebuggerUpdateResult.OK;
   }
 
   private scriptDiverged(): boolean {
@@ -713,16 +748,16 @@ export class ModelBreakpoint {
     return false;
   }
 
-  private async updateInDebugger(): Promise<void> {
+  async #updateInDebugger(): Promise<DebuggerUpdateResult> {
     if (this.#debuggerModel.target().isDisposed()) {
       this.cleanUpAfterDebuggerIsGone();
-      return;
+      return DebuggerUpdateResult.OK;
     }
-
     const lineNumber = this.#breakpoint.lineNumber();
     const columnNumber = this.#breakpoint.columnNumber();
     const condition = this.#breakpoint.condition();
 
+    // Calculate the new state.
     let newState: Breakpoint.State|null = null;
     if (!this.#breakpoint.getIsRemoved() && this.#breakpoint.enabled() && !this.scriptDiverged()) {
       let debuggerLocations: SDK.DebuggerModel.Location[] = [];
@@ -766,71 +801,97 @@ export class ModelBreakpoint {
         }
       }
     }
+    const hasBackendState = this.#breakpointIds.length;
 
-    if (this.#breakpointIds.length && Breakpoint.State.equals(newState, this.#currentState)) {
-      return;
+    // Case 1: State hasn't changed, and back-end is up to date and has information
+    // on some breakpoints.
+    if (hasBackendState && Breakpoint.State.equals(newState, this.#currentState)) {
+      return DebuggerUpdateResult.OK;
     }
+
     this.#breakpoint.currentState = newState;
 
-    if (this.#breakpointIds.length) {
-      await this.refreshBreakpoint();
-      return;
+    // Case 2: State has changed, and the back-end has outdated information on old
+    // breakpoints.
+    if (hasBackendState) {
+      // Reset the current state.
+      await this.resetBreakpoint();
+      // Schedule another run of updates, to finally update to the new state.
+      return DebuggerUpdateResult.PENDING;
     }
 
+    // Case 3: State is null (no breakpoints to set), and back-end is up to date
+    // (no info on breakpoints).
     if (!newState) {
-      return;
+      return DebuggerUpdateResult.OK;
     }
 
-    const results = await Promise.all(newState.positions.map(pos => {
-      if (pos.url) {
-        return this.#debuggerModel.setBreakpointByURL(pos.url, pos.lineNumber, pos.columnNumber, condition);
-      }
-      return this.#debuggerModel.setBreakpointInAnonymousScript(
-          pos.scriptId, pos.scriptHash as string, pos.lineNumber, pos.columnNumber, condition);
-    }));
-    const breakpointIds: Protocol.Debugger.BreakpointId[] = [];
-    let locations: SDK.DebuggerModel.Location[] = [];
-    let maybeRescheduleUpdate = false;
-    for (const result of results) {
-      if (result.breakpointId) {
-        breakpointIds.push(result.breakpointId);
-        locations = locations.concat(result.locations);
-      } else if (this.#debuggerModel.debuggerEnabled() && !this.#debuggerModel.isReadyToPause()) {
-        maybeRescheduleUpdate = true;
-      }
-    }
+    // Case 4: State is not null, so we have breakpoints to set and the back-end
+    // has no information on breakpoints yet. Set the breakpoints.
+    const {breakpointIds, locations, serverError} = await this.#setBreakpointOnBackend(newState);
 
+    const maybeRescheduleUpdate =
+        serverError && this.#debuggerModel.debuggerEnabled() && !this.#debuggerModel.isReadyToPause();
     if (!breakpointIds.length && maybeRescheduleUpdate) {
       // TODO(crbug.com/1229541): This is a quickfix to prevent #breakpoints from
       // disappearing if the Debugger is actually not enabled
       // yet. This quickfix should be removed as soon as we have a solution
       // to correctly synchronize the front-end with the inspector back-end.
-      void this.scheduleUpdateInDebugger();
-      return;
+      return DebuggerUpdateResult.PENDING;
     }
 
     this.#currentState = newState;
     if (this.#cancelCallback) {
       this.#cancelCallback = false;
-      return;
+      return DebuggerUpdateResult.OK;
     }
 
+    // Something went wrong: we expect to have a non-null state, but have not received any
+    // breakpointIds from the back-end.
     if (!breakpointIds.length) {
-      // Do not await the remove, as we otherwise will create a circular
-      // dependency. Removing breakpoints will call `scheduleUpdateInDebugger` again.
-      // Calling it again would cause it to await this current run of `scheduleInDebugger`, which
-      // will then deadlock.
-      void this.#breakpoint.remove(true);
-      return;
+      return DebuggerUpdateResult.ERROR;
     }
 
     this.#breakpointIds = breakpointIds;
     this.#breakpointIds.forEach(
         breakpointId => this.#debuggerModel.addBreakpointListener(breakpointId, this.breakpointResolved, this));
-    await Promise.all(locations.map(location => this.addResolvedLocation(location)));
+    const resolvedResults = await Promise.all(locations.map(location => this.addResolvedLocation(location)));
+
+    // Breakpoint clash: the resolved location resolves to a different breakpoint, report an error.
+    if (resolvedResults.includes(ResolveLocationResult.ERROR)) {
+      return DebuggerUpdateResult.ERROR;
+    }
+    return DebuggerUpdateResult.OK;
+  }
+
+  async #setBreakpointOnBackend(newState: Breakpoint.State): Promise<{
+    breakpointIds: Protocol.Debugger.BreakpointId[],
+    locations: SDK.DebuggerModel.Location[],
+    serverError: boolean,
+  }> {
+    const condition = this.#breakpoint.condition();
+    const results = await Promise.all(newState.positions.map(pos => {
+      if (pos.url) {
+        return this.#debuggerModel.setBreakpointByURL(pos.url, pos.lineNumber, pos.columnNumber, condition);
+      }
+      return this.#debuggerModel.setBreakpointInAnonymousScript(
+          pos.scriptId, pos.scriptHash as string, pos.lineNumber, pos.columnNumber, condition);
+    }));
+    const breakpointIds: Protocol.Debugger.BreakpointId[] = [];
+    let locations: SDK.DebuggerModel.Location[] = [];
+    let serverError = false;
+    for (const result of results) {
+      if (result.breakpointId) {
+        breakpointIds.push(result.breakpointId);
+        locations = locations.concat(result.locations);
+      } else {
+        serverError = true;
+      }
+    }
+    return {breakpointIds, locations, serverError};
   }
 
-  async refreshBreakpoint(): Promise<void> {
+  async resetBreakpoint(): Promise<void> {
     if (!this.#breakpointIds.length) {
       return;
     }
@@ -838,7 +899,6 @@ export class ModelBreakpoint {
     await Promise.all(this.#breakpointIds.map(id => this.#debuggerModel.removeBreakpoint(id)));
     this.didRemoveFromDebugger();
     this.#currentState = null;
-    void this.scheduleUpdateInDebugger();
   }
 
   private didRemoveFromDebugger(): void {
@@ -855,7 +915,10 @@ export class ModelBreakpoint {
 
   private async breakpointResolved({data: location}: Common.EventTarget.EventTargetEvent<SDK.DebuggerModel.Location>):
       Promise<void> {
-    await this.addResolvedLocation(location);
+    const result = await this.addResolvedLocation(location);
+    if (result === ResolveLocationResult.ERROR) {
+      await this.#breakpoint.remove(false);
+    }
   }
 
   private async locationUpdated(liveLocation: LiveLocation): Promise<void> {
@@ -874,39 +937,29 @@ export class ModelBreakpoint {
     }
   }
 
-  private async addResolvedLocation(location: SDK.DebuggerModel.Location): Promise<void> {
+  private async addResolvedLocation(location: SDK.DebuggerModel.Location): Promise<ResolveLocationResult> {
     const uiLocation = await this.#debuggerWorkspaceBinding.rawLocationToUILocation(location);
     if (!uiLocation) {
-      return;
+      return ResolveLocationResult.OK;
     }
     const breakpointLocation = this.#breakpoint.breakpointManager.findBreakpoint(uiLocation);
     if (breakpointLocation && breakpointLocation.breakpoint !== this.#breakpoint) {
       // location clash
-      await this.#breakpoint.remove(false /* keepInStorage */);
-      return;
+      return ResolveLocationResult.ERROR;
     }
     await this.#debuggerWorkspaceBinding.createLiveLocation(
         location, this.locationUpdated.bind(this), this.#liveLocations);
+    return ResolveLocationResult.OK;
   }
 
   cleanUpAfterDebuggerIsGone(): void {
-    if (this.#updatePromise) {
-      this.#cancelCallback = true;
-    }
-    this.#hasPendingUpdate = false;
+    this.#cancelCallback = true;
     this.resetLocations();
     this.#currentState = null;
     if (this.#breakpointIds.length) {
       this.didRemoveFromDebugger();
     }
   }
-
-  removeEventListeners(): void {
-    this.#debuggerModel.removeEventListener(
-        SDK.DebuggerModel.Events.DebuggerWasDisabled, this.cleanUpAfterDebuggerIsGone, this);
-    this.#debuggerModel.removeEventListener(
-        SDK.DebuggerModel.Events.DebuggerWasEnabled, this.scheduleUpdateInDebugger, this);
-  }
 }
 
 interface Position {

package/front_end/models/bindings/ResourceScriptMapping.ts

@@ -33,7 +33,7 @@ import * as i18n from '../../core/i18n/i18n.js';
 import type * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import * as Workspace from '../workspace/workspace.js';
-import type * as Protocol from '../../generated/protocol.js';
+import * as Protocol from '../../generated/protocol.js';
 
 import type {Breakpoint} from './BreakpointManager.js';
 import {BreakpointManager} from './BreakpointManager.js';
@@ -320,34 +320,48 @@ export class ResourceScriptFile extends Common.ObjectWrapper.ObjectWrapper<Resou
                             .breakpointLocationsForUISourceCode(this.#uiSourceCodeInternal)
                             .map(breakpointLocation => breakpointLocation.breakpoint);
     const source = this.#uiSourceCodeInternal.workingCopy();
-    void this.scriptInternal.editSource(source).then(({error, exceptionDetails}) => {
-      void this.scriptSourceWasSet(source, breakpoints, error, exceptionDetails);
+    void this.scriptInternal.editSource(source).then(({status, exceptionDetails}) => {
+      void this.scriptSourceWasSet(source, breakpoints, status, exceptionDetails);
     });
   }
 
   async scriptSourceWasSet(
-      source: string, breakpoints: Breakpoint[], error: string|null,
+      source: string, breakpoints: Breakpoint[], status: Protocol.Debugger.SetScriptSourceResponseStatus,
       exceptionDetails?: Protocol.Runtime.ExceptionDetails): Promise<void> {
-    if (!error && !exceptionDetails) {
+    if (status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
       this.#scriptSource = source;
     }
     await this.update();
 
-    if (!error && !exceptionDetails) {
+    if (status === Protocol.Debugger.SetScriptSourceResponseStatus.Ok) {
       // Live edit can cause #breakpoints to be in the wrong position, or to be lost altogether.
       // If any #breakpoints were in the pre-live edit script, they need to be re-added.
       await Promise.all(breakpoints.map(breakpoint => breakpoint.refreshInDebugger()));
       return;
     }
     if (!exceptionDetails) {
+      // TODO(crbug.com/1334484): Instead of to the console, report these errors in an "info bar" at the bottom
+      //                          of the text editor, similar to e.g. source mapping errors.
       Common.Console.Console.instance().addMessage(
-          i18nString(UIStrings.liveEditFailed, {PH1: String(error)}), Common.Console.MessageLevel.Warning);
+          i18nString(UIStrings.liveEditFailed, {PH1: getErrorText(status)}), Common.Console.MessageLevel.Warning);
       return;
     }
     const messageText = i18nString(UIStrings.liveEditCompileFailed, {PH1: exceptionDetails.text});
     this.#uiSourceCodeInternal.addLineMessage(
         Workspace.UISourceCode.Message.Level.Error, messageText, exceptionDetails.lineNumber,
         exceptionDetails.columnNumber);
+
+    function getErrorText(status: Protocol.Debugger.SetScriptSourceResponseStatus): string {
+      switch (status) {
+        case Protocol.Debugger.SetScriptSourceResponseStatus.BlockedByActiveFunction:
+          return 'Functions that are on the stack (currently being executed) can not be edited';
+        case Protocol.Debugger.SetScriptSourceResponseStatus.BlockedByActiveGenerator:
+          return 'Async functions/generators that are active can not be edited';
+        case Protocol.Debugger.SetScriptSourceResponseStatus.CompileError:
+        case Protocol.Debugger.SetScriptSourceResponseStatus.Ok:
+          throw new Error('Compile errors and Ok status must not be reported on the console');
+      }
+    }
   }
 
   private async update(): Promise<void> {

package/front_end/models/source_map_scopes/NamesResolver.ts

@@ -181,13 +181,14 @@ export const scopeIdentifiers = async function(
   }
 };
 
-const identifierAndPunctuationRegExp = /^\s*([A-Za-z_$][A-Za-z_$0-9]*)\s*([.;,]?)\s*$/;
+const identifierAndPunctuationRegExp = /^\s*([A-Za-z_$][A-Za-z_$0-9]*)\s*([.;,=]?)\s*$/;
 
 const enum Punctuation {
-  None = 0,
-  Comma = 1,
-  Dot = 2,
-  Semicolon = 3,
+  None = 'none',
+  Comma = 'comma',
+  Dot = 'dot',
+  Semicolon = 'semicolon',
+  Equals = 'equals',
 }
 
 const resolveScope =
@@ -341,6 +342,9 @@ const resolveScope =
         case ';':
           punctuation = Punctuation.Semicolon;
           break;
+        case '=':
+          punctuation = Punctuation.Equals;
+          break;
         case '':
           punctuation = Punctuation.None;
           break;

package/package.json

@@ -55,5 +55,5 @@
     "unittest": "scripts/test/run_unittests.py --no-text-coverage",
     "watch": "vpython third_party/node/node.py --output scripts/watch_build.js"
   },
-  "version": "1.0.1015822"
+  "version": "1.0.1016075"
 }