@opensumi/ide-debug 2.21.3 → 2.21.4-rc-1668395886.0

package/src/browser/editor/debug-run-to-cursor.service.ts

@@ -0,0 +1,180 @@
+import { Injectable, Autowired } from '@opensumi/di';
+import { URI } from '@opensumi/ide-core-common';
+import { WorkbenchEditorService } from '@opensumi/ide-editor';
+import { Position } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/position';
+
+import { IDebugBreakpoint } from '../../common';
+
+import { IDebugSessionManager, DebugState } from './../../common/debug-session';
+import { DebugBreakpoint } from './../breakpoint/breakpoint-marker';
+import { DebugSessionManager } from './../debug-session-manager';
+import { DebugBreakpointsService } from './../view/breakpoints/debug-breakpoints.service';
+
+@Injectable()
+export class DebugRunToCursorService {
+  @Autowired(IDebugSessionManager)
+  protected readonly sessionManager: DebugSessionManager;
+
+  @Autowired(WorkbenchEditorService)
+  protected readonly workbenchEditorService: WorkbenchEditorService;
+
+  @Autowired(DebugBreakpointsService)
+  protected readonly debugBreakpointsService: DebugBreakpointsService;
+
+  constructor() {}
+
+  /**
+   * @param uri
+   * @param isForce 为 true 表示强制运行到光标处，不管中间有没有启用的断点，它就是要畅通无阻
+   * @returns
+   */
+  public async run(uri: URI, isForce = false): Promise<void> {
+    const currentSession = this.sessionManager.currentSession;
+    if (!currentSession) {
+      return;
+    }
+
+    if (currentSession.state !== DebugState.Stopped) {
+      return;
+    }
+
+    const currentEditor = this.workbenchEditorService.currentEditor;
+
+    if (!currentEditor) {
+      return;
+    } else if (!currentEditor.monacoEditor) {
+      return;
+    }
+
+    const { monacoEditor } = currentEditor;
+
+    const position = monacoEditor.getPosition();
+    if (!(monacoEditor.hasModel() && position)) {
+      return;
+    }
+
+    const sessionModel = currentSession.getModel();
+    if (!sessionModel) {
+      return;
+    }
+
+    const bpExists = !!sessionModel.getBreakpoints(uri, { column: position.column, lineNumber: position.lineNumber })
+      .length;
+
+    let breakpointToRemove: IDebugBreakpoint | undefined;
+    let threadToContinue = currentSession.currentThread;
+    let enabledBreakpoints: IDebugBreakpoint[] = [];
+
+    if (!bpExists) {
+      if (isForce) {
+        enabledBreakpoints = sessionModel
+          .getBreakpoints()
+          .filter((bk) => bk.enabled)
+          .filter((bk) => bk.raw.column !== position.column && bk.raw.line !== position.lineNumber);
+        // 先将所有断点禁用，并收集起来，continue 之后再恢复状态
+        enabledBreakpoints.forEach((bk) => {
+          this.debugBreakpointsService.toggleBreakpointEnable(bk);
+        });
+      }
+
+      const addResult = await this.addBreakpoints(uri, position);
+      if (!addResult) {
+        this.recoverStatus(enabledBreakpoints);
+        return;
+      }
+
+      if (addResult.thread) {
+        threadToContinue = addResult.thread;
+      }
+
+      if (addResult.breakpoint) {
+        breakpointToRemove = addResult.breakpoint;
+      }
+    }
+
+    if (!threadToContinue) {
+      this.recoverStatus(enabledBreakpoints);
+      return;
+    }
+
+    const oneTimeListener = threadToContinue.session.onDidChangeState(() => {
+      const state = currentSession.state;
+      if (state === DebugState.Stopped || state === DebugState.Inactive) {
+        if (breakpointToRemove) {
+          currentSession.delBreakpoint(breakpointToRemove);
+        }
+        oneTimeListener.dispose();
+      }
+    });
+
+    await threadToContinue.continue();
+    this.recoverStatus(enabledBreakpoints);
+  }
+
+  private async addBreakpoints(uri: URI, position: Position) {
+    const currentSession = this.sessionManager.currentSession;
+
+    if (!currentSession) {
+      return;
+    }
+
+    let column = 1;
+    const currentFrame = currentSession.currentFrame;
+    if (currentFrame && currentFrame.range().startLineNumber === position.lineNumber) {
+      // https://github.com/microsoft/vscode/issues/102199
+      column = position.column || 1;
+    }
+
+    const bp = DebugBreakpoint.create(uri, { line: position.lineNumber, column });
+
+    await currentSession.addBreakpoint(bp, true);
+    if (!bp) {
+      return { breakpoint: undefined, thread: currentSession.currentThread };
+    }
+
+    // Look at paused threads for sessions that verified this bp. Prefer, in order:
+    const enum Score {
+      /** The focused thread */
+      Focused,
+      /** Any other stopped thread of a session that verified the bp */
+      Verified,
+      /** Any thread that verified and paused in the same file */
+      VerifiedAndPausedInFile,
+      /** The focused thread if it verified the breakpoint */
+      VerifiedAndFocused,
+    }
+
+    let bestThread = currentSession.currentThread;
+    let bestScore = Score.Focused;
+
+    const threads = currentSession.threads.filter((t) => t.stopped);
+    if (bestScore < Score.VerifiedAndFocused) {
+      if (currentSession.currentThread && threads.includes(currentSession.currentThread)) {
+        bestThread = currentSession.currentThread;
+        bestScore = Score.VerifiedAndFocused;
+      }
+    }
+
+    if (bestScore < Score.VerifiedAndPausedInFile) {
+      const pausedInThisFile = threads.find((t) => t.topFrame);
+
+      if (pausedInThisFile) {
+        bestThread = pausedInThisFile;
+        bestScore = Score.VerifiedAndPausedInFile;
+      }
+    }
+
+    if (bestScore < Score.Verified) {
+      bestThread = threads[0];
+      bestScore = Score.VerifiedAndPausedInFile;
+    }
+
+    return { thread: bestThread, breakpoint: bp };
+  }
+
+  private recoverStatus(bks: IDebugBreakpoint[]): void {
+    bks.forEach((bk) => {
+      this.debugBreakpointsService.toggleBreakpointEnable(bk);
+    });
+  }
+}

package/src/browser/editor/debug-styles.ts

@@ -0,0 +1,66 @@
+import * as monaco from '@opensumi/monaco-editor-core/esm/vs/editor/editor.api';
+
+export const STICKINESS = monaco.editor.TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges;
+
+export const BREAK_PONINT_HOVER_MARGIN: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-hover',
+  glyphMarginClassName: 'sumi-debug-hover',
+  linesDecorationsClassName: 'sumi-debug-hover',
+  isWholeLine: true,
+};
+
+export const TOP_STACK_FRAME_MARGIN: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-top-stack-frame',
+  glyphMarginClassName: 'sumi-debug-top-stack-frame',
+  stickiness: STICKINESS,
+};
+
+export const FOCUSED_STACK_FRAME_MARGIN: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-focused-stack-frame',
+  glyphMarginClassName: 'sumi-debug-focused-stack-frame',
+  stickiness: STICKINESS,
+};
+
+export const TOP_STACK_FRAME_DECORATION: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-top-stack-frame-line',
+  isWholeLine: true,
+  className: 'sumi-debug-top-stack-frame-line',
+  stickiness: STICKINESS,
+};
+
+export const TOP_STACK_FRAME_EXCEPTION_DECORATION: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-top-stack-frame-exception-line',
+  isWholeLine: true,
+  className: 'sumi-debug-top-stack-frame-exception-line',
+  stickiness: STICKINESS,
+};
+
+export const FOCUSED_STACK_FRAME_DECORATION: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-focused-stack-frame-line',
+  isWholeLine: true,
+  className: 'sumi-debug-focused-stack-frame-line',
+  stickiness: STICKINESS,
+};
+
+export const TOP_STACK_FRAME_INLINE_DECORATION: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-top-stack-frame-column',
+  beforeContentClassName: 'sumi-debug-top-stack-frame-column',
+};
+
+export const BREAKPOINT_HINT_DECORATION: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-breakpoint-hint',
+  glyphMarginClassName: 'sumi-debug-breakpoint-hint',
+  stickiness: STICKINESS,
+};
+
+export const BREAKPOINT_DECORATION: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-breakpoint',
+  glyphMarginClassName: 'sumi-debug-breakpoint',
+  stickiness: STICKINESS,
+};
+
+export const BREAKPOINT_DECORATION_DISABLED: monaco.editor.IModelDecorationOptions = {
+  description: 'debug-breakpoint-disabled',
+  glyphMarginClassName: 'sumi-debug-breakpoint-disabled',
+  stickiness: STICKINESS,
+};

package/src/browser/editor/evaluatable-expression.ts

@@ -0,0 +1,47 @@
+import { Injectable } from '@opensumi/di';
+import { IDisposable } from '@opensumi/ide-core-common';
+import { LanguageFeatureRegistry } from '@opensumi/monaco-editor-core/esm/vs/editor/common/languageFeatureRegistry';
+import type { ITextModel } from '@opensumi/monaco-editor-core/esm/vs/editor/common/model';
+
+import { EvaluatableExpressionProvider } from '../../common/evaluatable-expression';
+
+interface SerializedDocumentFilter {
+  $serialized: true;
+  language?: string;
+  scheme?: string;
+  // 类型不兼容
+  pattern?: any;
+}
+
+const EvaluatableExpressionRegistry = new LanguageFeatureRegistry<EvaluatableExpressionProvider>();
+
+export interface IEvaluatableExpressionService {
+  registerEvaluatableExpressionProvider(
+    selector: SerializedDocumentFilter[],
+    provider: EvaluatableExpressionProvider,
+  ): IDisposable;
+
+  getSupportedEvaluatableExpressionProvider(model: ITextModel): EvaluatableExpressionProvider[];
+
+  hasEvaluatableExpressProvider(model: ITextModel): boolean;
+}
+
+export const IEvaluatableExpressionService = Symbol('IEvaluatableExpressionService');
+
+@Injectable()
+export class EvaluatableExpressionServiceImpl implements IEvaluatableExpressionService {
+  getSupportedEvaluatableExpressionProvider(model: ITextModel): EvaluatableExpressionProvider[] {
+    return EvaluatableExpressionRegistry.ordered(model);
+  }
+
+  registerEvaluatableExpressionProvider(
+    selector: SerializedDocumentFilter[],
+    provider: EvaluatableExpressionProvider,
+  ): IDisposable {
+    return EvaluatableExpressionRegistry.register(selector, provider);
+  }
+
+  hasEvaluatableExpressProvider(model: ITextModel): boolean {
+    return EvaluatableExpressionRegistry.has(model);
+  }
+}

package/src/browser/editor/index.ts

@@ -0,0 +1,6 @@
+export * from './debug-breakpoint-widget';
+export * from './debug-hover-widget';
+export * from './debug-model';
+export * from './debug-model-manager';
+export * from './debug-styles';
+export * from './debug-expression-provider';

package/src/browser/index.ts

@@ -0,0 +1,127 @@
+import { Injectable, Injector, Provider } from '@opensumi/di';
+import { BrowserModule, IContextKeyService } from '@opensumi/ide-core-browser';
+import { FolderPreferenceProvider } from '@opensumi/ide-preferences/lib/browser/folder-preference-provider';
+
+import {
+  DebugEditor,
+  DebugModelFactory,
+  IDebugConsoleModelService,
+  IDebugModelManager,
+  IDebugProgress,
+  IDebugServer,
+  IDebugService,
+  IDebugSessionManager,
+} from '../common';
+
+import { BreakpointManager } from './breakpoint';
+import { DebugCallStackItemTypeKey } from './contextkeys';
+import { DebugConfigurationManager } from './debug-configuration-manager';
+import { DebugContribution } from './debug-contribution';
+import { injectDebugPreferences } from './debug-preferences';
+import { DebugProgressService } from './debug-progress.service';
+import { DebugService } from './debug-service';
+import {
+  DebugSessionContribution,
+  DebugSessionContributionRegistry,
+  DebugSessionContributionRegistryImpl,
+} from './debug-session-contribution';
+import { DebugSessionManager } from './debug-session-manager';
+import { DebugExpressionProvider, DebugModel, DebugModelManager } from './editor';
+import { DebugHoverSource } from './editor/debug-hover-source';
+import { EvaluatableExpressionServiceImpl, IEvaluatableExpressionService } from './editor/evaluatable-expression';
+import { LaunchFolderPreferenceProvider } from './preferences/launch-folder-preference-provider';
+import { LaunchPreferencesContribution } from './preferences/launch-preferences-contribution';
+import { DebugToolbarOverlayWidget } from './view/configuration/debug-toolbar.view';
+import { DebugConsoleModelService } from './view/console/debug-console-tree.model.service';
+import { DebugConsoleContribution } from './view/console/debug-console.contribution';
+import { DebugCallStackContribution } from './view/frames/debug-call-stack.contribution';
+import { VariablesPanelContribution } from './view/variables/debug-variables.contribution';
+import { WatchPanelContribution } from './view/watch/debug-watch.contribution';
+
+import './debug-style.less';
+
+@Injectable()
+export class DebugModule extends BrowserModule {
+  providers: Provider[] = [
+    {
+      token: DebugHoverSource,
+      useClass: DebugHoverSource,
+    },
+    {
+      token: DebugExpressionProvider,
+      useClass: DebugExpressionProvider,
+    },
+    {
+      token: IDebugModelManager,
+      useClass: DebugModelManager,
+    },
+    {
+      token: IDebugSessionManager,
+      useClass: DebugSessionManager,
+    },
+    {
+      token: BreakpointManager,
+      useClass: BreakpointManager,
+    },
+    {
+      token: DebugConfigurationManager,
+      useClass: DebugConfigurationManager,
+    },
+    {
+      token: IEvaluatableExpressionService,
+      useClass: EvaluatableExpressionServiceImpl,
+    },
+    {
+      token: FolderPreferenceProvider,
+      useClass: LaunchFolderPreferenceProvider,
+      dropdownForTag: true,
+      tag: 'launch',
+    },
+    {
+      token: DebugModelFactory,
+      useFactory: (injector: Injector) => (editor: DebugEditor) => DebugModel.createModel(injector, editor),
+    },
+    {
+      token: DebugSessionContributionRegistry,
+      useClass: DebugSessionContributionRegistryImpl,
+    },
+    {
+      token: IDebugService,
+      useClass: DebugService,
+    },
+    // 这里原本的实现意图就是Debug作为单独模块执行时使用Node作为调试进程的启动及连接逻辑
+    // 在当前调试依赖插件进程的前提下，没必要引入这块冗余代码带来混淆
+    // packages/extension/src/browser/index.ts#L30
+    {
+      token: IDebugServer,
+      useValue: {},
+    },
+    {
+      token: IDebugProgress,
+      useClass: DebugProgressService,
+    },
+    {
+      token: IDebugConsoleModelService,
+      useClass: DebugConsoleModelService,
+    },
+    // contributions
+    LaunchPreferencesContribution,
+    DebugContribution,
+    DebugConsoleContribution,
+    VariablesPanelContribution,
+    DebugCallStackContribution,
+    WatchPanelContribution,
+    // contextkeys
+    {
+      token: DebugCallStackItemTypeKey,
+      useFactory: (injector: Injector) => injector.get(IContextKeyService).createKey('callStackItemType'),
+    },
+  ];
+
+  contributionProvider = DebugSessionContribution;
+
+  preferences = injectDebugPreferences;
+
+  isOverlay = true;
+  component = DebugToolbarOverlayWidget;
+}

package/src/browser/markers/index.ts

@@ -0,0 +1,2 @@
+export * from './marker-manager';
+export * from './marker';

package/src/browser/markers/marker-manager.ts

@@ -0,0 +1,201 @@
+/** ******************************************************************************
+ * Copyright (C) 2018 Red Hat, Inc. and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0 which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the Eclipse
+ * Public License v. 2.0 are satisfied: GNU General Public License, version 2
+ * with the GNU Classpath Exception which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ ********************************************************************************/
+// Some code copied and modified from https://github.com/eclipse-theia/theia/tree/v1.14.0/packages/markers/src/browser/marker-manager.ts
+
+import { Injectable, Autowired } from '@opensumi/di';
+import { Event, Emitter, URI } from '@opensumi/ide-core-browser';
+import { FileChangeEvent, FileChangeType } from '@opensumi/ide-file-service';
+import { IFileServiceClient } from '@opensumi/ide-file-service';
+
+import { Marker } from './marker';
+
+/*
+ * findMarkers方法的参数
+ */
+export interface SearchFilter<D> {
+  uri?: URI;
+  owner?: string;
+  dataFilter?: (data: D) => boolean;
+}
+
+export class MarkerCollection<T> {
+  protected readonly owner2Markers = new Map<string, Readonly<Marker<T>>[]>();
+
+  constructor(public readonly uri: URI, public readonly kind: string) {}
+
+  get empty(): boolean {
+    return !this.owner2Markers.size;
+  }
+
+  getOwners(): string[] {
+    return Array.from(this.owner2Markers.keys());
+  }
+
+  getMarkers(owner: string): Readonly<Marker<T>>[] {
+    return this.owner2Markers.get(owner) || [];
+  }
+
+  setMarkers(owner: string, markerData: T[]): Marker<T>[] {
+    const before = this.owner2Markers.get(owner);
+    if (markerData.length > 0) {
+      this.owner2Markers.set(
+        owner,
+        markerData.map((data) => this.createMarker(owner, data)),
+      );
+    } else {
+      this.owner2Markers.delete(owner);
+    }
+    return before || [];
+  }
+
+  protected createMarker(owner: string, data: T): Readonly<Marker<T>> {
+    return Object.freeze({
+      uri: this.uri.toString(),
+      kind: this.kind,
+      owner,
+      data,
+    });
+  }
+
+  findMarkers(filter: SearchFilter<T>): Marker<T>[] {
+    if (filter.owner) {
+      if (this.owner2Markers.has(filter.owner)) {
+        return this.filterMarkers(filter, this.owner2Markers.get(filter.owner));
+      }
+      return [];
+    } else {
+      const result: Marker<T>[] = [];
+      for (const markers of this.owner2Markers.values()) {
+        result.push(...this.filterMarkers(filter, markers));
+      }
+      return result;
+    }
+  }
+
+  protected filterMarkers(filter: SearchFilter<T>, toFilter?: Marker<T>[]) {
+    if (!toFilter) {
+      return [];
+    }
+    if (filter.dataFilter) {
+      return toFilter.filter((d) => filter.dataFilter!(d.data));
+    } else {
+      return toFilter;
+    }
+  }
+}
+
+export interface Uri2MarkerEntry {
+  uri: string;
+  markers: Owner2MarkerEntry[];
+}
+
+export interface Owner2MarkerEntry {
+  owner: string;
+  markerData: object[];
+}
+
+@Injectable()
+export abstract class MarkerManager<D extends object> {
+  public abstract getKind(): string;
+
+  protected readonly uri2MarkerCollection = new Map<string, MarkerCollection<D>>();
+  protected readonly onDidChangeMarkersEmitter = new Emitter<URI>();
+
+  @Autowired(IFileServiceClient) protected fileService: IFileServiceClient;
+
+  constructor() {
+    this.init();
+  }
+
+  protected init(): void {
+    this.fileService.onFilesChanged((event) => {
+      const relevantEvent = event.filter(({ type }) => type === FileChangeType.DELETED);
+      if (relevantEvent.length) {
+        this.cleanMarkers(relevantEvent);
+      }
+    });
+  }
+
+  protected cleanMarkers(event: FileChangeEvent): void {
+    for (const uriString of this.uri2MarkerCollection.keys()) {
+      const uri = new URI(uriString);
+      if (FileChangeEvent.isDeleted(event, uri)) {
+        this.cleanAllMarkers(uri);
+      }
+    }
+  }
+
+  get onDidChangeMarkers(): Event<URI> {
+    return this.onDidChangeMarkersEmitter.event;
+  }
+
+  protected fireOnDidChangeMarkers(uri: URI): void {
+    this.onDidChangeMarkersEmitter.fire(uri);
+  }
+
+  /*
+   * 替换遮罩元素属性
+   */
+  setMarkers(uri: URI, owner: string, data: D[]): Marker<D>[] {
+    const uriString = uri.toString();
+    const collection = this.uri2MarkerCollection.get(uriString) || new MarkerCollection<D>(uri, this.getKind());
+    const oldMarkers = collection.setMarkers(owner, data);
+    if (collection.empty) {
+      this.uri2MarkerCollection.delete(uri.toString());
+    } else {
+      this.uri2MarkerCollection.set(uriString, collection);
+    }
+    this.fireOnDidChangeMarkers(uri);
+    return oldMarkers;
+  }
+
+  /*
+   * 根据filter函数返回所有断点
+   */
+  findMarkers(filter: SearchFilter<D> = {}): Marker<D>[] {
+    if (filter.uri) {
+      const collection = this.uri2MarkerCollection.get(filter.uri.toString());
+      return collection ? collection.findMarkers(filter) : [];
+    }
+    const result: Marker<D>[] = [];
+    for (const uri of this.getUris()) {
+      result.push(...this.uri2MarkerCollection.get(uri)!.findMarkers(filter));
+    }
+    return result;
+  }
+
+  getUris(): IterableIterator<string> {
+    return this.uri2MarkerCollection.keys();
+  }
+
+  cleanAllMarkers(uri?: URI): void {
+    if (uri) {
+      this.doCleanAllMarkers(uri);
+    } else {
+      for (const uriString of this.getUris()) {
+        this.doCleanAllMarkers(new URI(uriString));
+      }
+    }
+  }
+  protected doCleanAllMarkers(uri: URI): void {
+    const uriString = uri.toString();
+    const collection = this.uri2MarkerCollection.get(uriString);
+    if (collection !== undefined) {
+      this.uri2MarkerCollection.delete(uriString);
+      this.fireOnDidChangeMarkers(uri);
+    }
+  }
+}

package/src/browser/markers/marker.ts

@@ -0,0 +1,20 @@
+export interface Marker<T> {
+  /**
+   * 遮罩元素定位的uri
+   */
+  uri: string;
+  /*
+   * 遮罩元素的注册者
+   */
+  owner: string;
+
+  /**
+   * 类型
+   */
+  kind?: string;
+
+  /*
+   * 缓存数据
+   */
+  data: T;
+}