@opensumi/ide-debug 2.21.13 → 2.22.0

package/src/browser/model/debug-source.ts

@@ -0,0 +1,144 @@
+/** ******************************************************************************
+ * 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/debug/src/browser/model/debug-source.ts
+
+import { URI, Uri, IRange } from '@opensumi/ide-core-browser';
+import { LabelService } from '@opensumi/ide-core-browser/lib/services';
+import { WorkbenchEditorService, IResourceOpenOptions } from '@opensumi/ide-editor';
+import { IFileServiceClient, FileStat } from '@opensumi/ide-file-service';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol/lib/debugProtocol';
+
+import { IDebugModelManager } from '../../common';
+import { DebugSession } from '../debug-session';
+
+import { DebugStackFrame } from './debug-stack-frame';
+
+export class DebugSourceData {
+  readonly raw: DebugProtocol.Source;
+}
+
+export class DebugSource extends DebugSourceData {
+  constructor(
+    protected readonly session: DebugSession,
+    protected readonly labelProvider: LabelService,
+    protected readonly modelManager: IDebugModelManager,
+    protected readonly workbenchEditorService: WorkbenchEditorService,
+    protected readonly fileSystem: IFileServiceClient,
+  ) {
+    super();
+  }
+
+  get uri(): URI {
+    return DebugSource.toUri(this.raw);
+  }
+
+  get available(): boolean {
+    return !!this.raw;
+  }
+
+  get presentationHint() {
+    return this.raw.presentationHint;
+  }
+
+  update(data: Partial<DebugSourceData>): void {
+    Object.assign(this, data);
+  }
+
+  async open(options: IResourceOpenOptions, frame?: DebugStackFrame) {
+    if (this.uri.scheme === DebugSource.SCHEME) {
+      const content = await this.load();
+      await this.fileSystem.setContent(
+        {
+          uri: this.uri.toString(),
+          lastModification: 0,
+        } as FileStat,
+        content,
+      );
+    }
+
+    if (frame && frame.raw) {
+      const { line, column } = frame.raw;
+      const range: IRange = {
+        startLineNumber: line,
+        startColumn: typeof column === 'number' ? column : 0,
+        endLineNumber: line,
+        endColumn: Infinity,
+      };
+      await this.workbenchEditorService.open(this.uri, {
+        ...options,
+        range,
+      });
+      // 更新当前进程的currentFrame为选中frame
+      frame.thread.currentFrame = frame;
+      // currentFrame变化会通知打开对应文件
+      const models = this.modelManager.resolve(this.uri);
+      if (models) {
+        for (const model of models) {
+          model.focusStackFrame();
+        }
+      }
+    } else {
+      await this.workbenchEditorService.open(this.uri, options);
+    }
+  }
+
+  async load(): Promise<string> {
+    const source = this.raw;
+    const sourceReference = source.sourceReference!;
+    const response = await this.session.sendRequest('source', {
+      sourceReference,
+      source,
+    });
+    return response.body.content;
+  }
+
+  get inMemory(): boolean {
+    return this.uri.scheme === DebugSource.SCHEME;
+  }
+
+  get reference(): number | undefined {
+    return this.raw.sourceReference;
+  }
+
+  get name(): string {
+    if (this.inMemory) {
+      return this.raw.name || this.uri.path.base || this.uri.path.toString();
+    }
+    return this.labelProvider.getName(this.uri);
+  }
+
+  get longName(): string {
+    if (this.inMemory) {
+      return this.name;
+    }
+    return this.labelProvider.getLongName(this.uri);
+  }
+
+  static SCHEME = 'debug';
+  static SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9\+\-\.]+:/;
+  static toUri(raw: DebugProtocol.Source): URI {
+    if (raw.sourceReference && raw.sourceReference > 0) {
+      return new URI().withScheme(DebugSource.SCHEME).withPath(raw.name!).withQuery(String(raw.sourceReference));
+    }
+    if (!raw.path) {
+      throw new Error('Unrecognized source type: ' + JSON.stringify(raw));
+    }
+    if (raw.path.match(DebugSource.SCHEME_PATTERN)) {
+      return new URI(raw.path);
+    }
+    return new URI(Uri.file(raw.path));
+  }
+}

package/src/browser/model/debug-stack-frame.ts

@@ -0,0 +1,111 @@
+import { IRange } from '@opensumi/ide-core-browser';
+import { IResourceOpenOptions } from '@opensumi/ide-editor';
+import { Range } from '@opensumi/monaco-editor-core/esm/vs/editor/common/core/range';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol/lib/debugProtocol';
+
+import { DebugSession } from '../debug-session';
+import { DebugScope, ExpressionContainer } from '../tree/debug-tree-node.define';
+
+import { DebugSource } from './debug-source';
+import { DebugThread } from './debug-thread';
+
+
+export class DebugStackFrameData {
+  readonly raw: DebugProtocol.StackFrame;
+}
+
+export class DebugStackFrame extends DebugStackFrameData {
+  constructor(readonly thread: DebugThread, readonly session: DebugSession) {
+    super();
+  }
+
+  get id(): string {
+    return this.session.id + ':' + this.thread.id + ':' + this.raw.id;
+  }
+
+  protected _source: DebugSource | undefined;
+  get source(): DebugSource | undefined {
+    return this._source;
+  }
+  update(data: Partial<DebugStackFrameData>): void {
+    Object.assign(this, data);
+    this._source = this.raw.source && this.session.getSource(this.raw.source);
+  }
+
+  async restart(): Promise<DebugProtocol.RestartFrameResponse | undefined> {
+    if (this.session.capabilities.supportsRestartFrame) {
+      return await this.session.sendRequest('restartFrame', { frameId: this.raw.id });
+    }
+    return Promise.reject(new Error('restartFrame not supported'));
+  }
+
+  get canRestart(): boolean {
+    return typeof this.raw.canRestart === 'boolean' ? this.raw.canRestart : true;
+  }
+
+  async open(options?: IResourceOpenOptions) {
+    if (!this.source) {
+      return;
+    }
+    const { line, column, endLine, endColumn } = this.raw;
+    let range: IRange = {
+      startLineNumber: line,
+      startColumn: column,
+      endLineNumber: line,
+      endColumn: Infinity,
+    };
+    if (typeof endLine === 'number') {
+      range = {
+        ...range,
+        endLineNumber: endLine,
+        endColumn: typeof endColumn === 'number' ? endColumn : Infinity,
+      };
+    }
+    this.source.open({
+      ...options,
+      range,
+    });
+  }
+
+  protected toArgs<T extends object>(arg?: T): { frameId: number } & T {
+    return Object.assign({}, arg, {
+      frameId: this.raw.id,
+    });
+  }
+
+  getScopes(parent?: ExpressionContainer): Promise<DebugScope[]> {
+    return this.doGetScopes(parent);
+  }
+  protected async doGetScopes(parent?: ExpressionContainer): Promise<DebugScope[]> {
+    try {
+      const response = await this.session.sendRequest('scopes', this.toArgs());
+      return response.body.scopes.map((raw) => new DebugScope(raw, this.session, parent));
+    } catch (e) {
+      return [];
+    }
+  }
+
+  public range(): IRange {
+    const rs = this.raw;
+    return new Range(rs.line, rs.column, rs.endLine || rs.line, rs.endColumn || rs.column);
+  }
+
+  public async getMostSpecificScopes(range: IRange): Promise<DebugScope[]> {
+    const scopes = await this.doGetScopes();
+    const nonExpensiveScopes = scopes.filter((s) => !s.getRawScope().expensive);
+    const haveRangeInfo = nonExpensiveScopes.some((s) => !!s.range());
+    if (!haveRangeInfo) {
+      return nonExpensiveScopes;
+    }
+
+    const scopesContainingRange = nonExpensiveScopes
+      .filter((scope) => scope.range() && Range.containsRange(scope.range()!, range))
+      .sort(
+        (first, second) =>
+          first.range()!.endLineNumber -
+          first.range()!.startLineNumber -
+          (second.range()!.endLineNumber - second.range()!.startLineNumber),
+      );
+    return scopesContainingRange.length ? scopesContainingRange : nonExpensiveScopes;
+  }
+}

package/src/browser/model/debug-thread.ts

@@ -0,0 +1,186 @@
+import { Event, Emitter } from '@opensumi/ide-core-browser';
+import { DebugProtocol } from '@opensumi/vscode-debugprotocol/lib/debugProtocol';
+
+import { DEBUG_REPORT_NAME, IDebugExceptionInfo } from '../../common';
+import { DebugSession } from '../debug-session';
+
+import { DebugStackFrame } from './debug-stack-frame';
+
+export type StoppedDetails = DebugProtocol.StoppedEvent['body'] & {
+  framesErrorMessage?: string;
+  totalFrames?: number;
+};
+
+export class DebugThreadData {
+  readonly raw: DebugProtocol.Thread;
+  readonly stoppedDetails: StoppedDetails | undefined;
+}
+
+export class DebugThread extends DebugThreadData {
+  protected readonly _onDidChanged = new Emitter<void>();
+  readonly onDidChanged: Event<void> = this._onDidChanged.event;
+
+  constructor(readonly session: DebugSession) {
+    super();
+  }
+
+  get id(): string {
+    return this.session.id + ':' + this.raw.id;
+  }
+
+  get threadId(): number {
+    return this.raw.id;
+  }
+
+  protected _currentFrame: DebugStackFrame | undefined;
+  get currentFrame(): DebugStackFrame | undefined {
+    return this._currentFrame;
+  }
+  set currentFrame(frame: DebugStackFrame | undefined) {
+    this._currentFrame = frame;
+    this._onDidChanged.fire();
+  }
+
+  get stopped(): boolean {
+    return !!this.stoppedDetails;
+  }
+
+  update(data: Partial<DebugThreadData>): void {
+    Object.assign(this, data);
+    if ('stoppedDetails' in data) {
+      this.clearFrames();
+    }
+  }
+
+  clear(): void {
+    this.update({
+      raw: this.raw,
+      stoppedDetails: undefined,
+    });
+  }
+
+  continue(): Promise<DebugProtocol.ContinueResponse> {
+    return this.session.sendRequest('continue', this.toArgs());
+  }
+
+  stepOver(): Promise<DebugProtocol.NextResponse> {
+    return this.session.sendRequest('next', this.toArgs());
+  }
+
+  stepIn(): Promise<DebugProtocol.StepInResponse> {
+    return this.session.sendRequest('stepIn', this.toArgs());
+  }
+
+  stepOut(): Promise<DebugProtocol.StepOutResponse> {
+    return this.session.sendRequest('stepOut', this.toArgs());
+  }
+
+  pause(): Promise<DebugProtocol.PauseResponse> {
+    return this.session.sendRequest('pause', this.toArgs());
+  }
+
+  terminate(): Promise<DebugProtocol.TerminateResponse> {
+    return this.session.sendRequest('terminateThreads', { threadIds: [this.raw.id] });
+  }
+
+  protected readonly _frames = new Map<number, DebugStackFrame>();
+  get frames(): DebugStackFrame[] {
+    return Array.from(this._frames.values());
+  }
+  get topFrame(): DebugStackFrame | undefined {
+    return this.frames[0];
+  }
+  get frameCount(): number {
+    return this._frames.size;
+  }
+
+  protected pendingFetch = Promise.resolve<DebugStackFrame[]>([]);
+  async rawFetchFrames(levels = 20): Promise<DebugStackFrame[]> {
+    return (this.pendingFetch = this.pendingFetch.then(async () => {
+      try {
+        const start = this.frameCount;
+        const frames = await this.doFetchFrames(start, levels);
+        const newframes = this.doUpdateFrames(frames);
+        return newframes;
+      } catch (e) {
+        return [];
+      }
+    }));
+  }
+
+  async fetchExceptionInfo(): Promise<IDebugExceptionInfo | undefined> {
+    try {
+      if (this.stoppedDetails?.reason === 'exception' && this.session.capabilities.supportsExceptionInfoRequest) {
+        const response = await this.session.exceptionInfo(this.toArgs());
+        if (response) {
+          return {
+            id: response.body.exceptionId,
+            description: response.body.description,
+            breakMode: response.body.breakMode,
+            details: response.body.details,
+          };
+        }
+      }
+    } catch (e) {
+      return undefined;
+    }
+  }
+
+  async fetchFrames(levels = 20): Promise<DebugStackFrame[]> {
+    const frames = await this.rawFetchFrames(levels);
+    this.updateCurrentFrame();
+    return frames;
+  }
+
+  protected async doFetchFrames(startFrame: number, levels: number): Promise<DebugProtocol.StackFrame[]> {
+    try {
+      const response = await this.session.sendRequest(
+        'stackTrace',
+        this.toArgs<Partial<DebugProtocol.StackTraceArguments>>({ startFrame, levels }),
+      );
+      if (this.stoppedDetails) {
+        this.stoppedDetails.totalFrames = response.body.totalFrames;
+      }
+      return response.body.stackFrames;
+    } catch (e) {
+      if (this.stoppedDetails) {
+        this.stoppedDetails.framesErrorMessage = e.message;
+      }
+      return [];
+    }
+  }
+  protected doUpdateFrames(frames: DebugProtocol.StackFrame[]): DebugStackFrame[] {
+    const frontEndTime = this.session.reportTime(DEBUG_REPORT_NAME.DEBUG_UI_FRONTEND_TIME, {
+      sessionId: this.session.id,
+      threadId: this.raw.id,
+      threadAmount: this.session.threadCount,
+    });
+    const result = new Map<number, DebugStackFrame>(this._frames);
+    for (const raw of frames) {
+      const id = raw.id;
+      const frame = this._frames.get(id) || new DebugStackFrame(this, this.session);
+      this._frames.set(id, frame);
+      frame.update({ raw });
+      result.set(id, frame);
+    }
+    const values = [...result.values()];
+    frontEndTime('doUpdateFrames');
+    return values;
+  }
+  protected clearFrames(): void {
+    this._frames.clear();
+    this.updateCurrentFrame();
+  }
+  protected updateCurrentFrame(): void {
+    const { currentFrame } = this;
+    const frameId = currentFrame && currentFrame.raw.id;
+    this.currentFrame =
+      (typeof frameId === 'number' && this._frames.get(frameId)) || this._frames.values().next().value;
+  }
+
+  protected toArgs<T extends object>(arg?: T): { threadId: number } & T {
+    return Object.assign({}, arg, {
+      threadId: this.raw.id,
+    });
+  }
+}

package/src/browser/model/debug-watch.ts

@@ -0,0 +1,129 @@
+import throttle from 'lodash/throttle';
+
+import { DisposableCollection, Emitter, Event, IReporterService } from '@opensumi/ide-core-browser';
+
+import { DEBUG_COMMANDS, DEBUG_REPORT_NAME } from '../../common';
+import { DebugSessionManager } from '../debug-session-manager';
+import { DebugWatchRoot, DebugWatchNode } from '../tree/debug-tree-node.define';
+
+export const IDebugWatchData = Symbol('IDebugWatchData');
+export interface IDebugWatchData {
+  getRoot: () => Promise<DebugWatchRoot | void>;
+  updateWatchExpressions: (data: string[]) => Promise<void>;
+  addWatchExpression: (value: string) => void;
+  clear: () => Promise<void>;
+  onDidChange: Event<void>;
+  onDidVariableChange: Event<void>;
+  onDidExpressionChange: Event<string[]>;
+}
+
+export class DebugWatch implements IDebugWatchData {
+  protected readonly toDispose = new DisposableCollection();
+
+  protected fireDidChange: () => void = throttle(() => this.onDidChangeEmitter.fire(), 50);
+  protected fireVariableChange: () => void = throttle(() => this.onDidVariableChangeEmitter.fire(), 50);
+  protected fireExpressionChange: (expressions: string[]) => void = throttle(
+    (expressions: string[]) => this.onDidExExpressionChangeEmitter.fire(expressions),
+    50,
+  );
+
+  private _expressions: string[] = [];
+  private _root: DebugWatchRoot;
+
+  whenReady: Promise<any>;
+
+  private onDidChangeEmitter: Emitter<void> = new Emitter();
+  private onDidVariableChangeEmitter: Emitter<void> = new Emitter();
+  private onDidExExpressionChangeEmitter: Emitter<string[]> = new Emitter();
+
+  constructor(private readonly manager: DebugSessionManager, private readonly reporterService: IReporterService) {
+    this.whenReady = this.init();
+  }
+
+  get onDidChange(): Event<void> {
+    return this.onDidChangeEmitter.event;
+  }
+
+  get onDidVariableChange(): Event<void> {
+    return this.onDidVariableChangeEmitter.event;
+  }
+
+  get onDidExpressionChange(): Event<string[]> {
+    return this.onDidExExpressionChangeEmitter.event;
+  }
+
+  async getRoot() {
+    const presets: DebugWatchNode[] = [];
+    const root = new DebugWatchRoot(this.manager.currentSession);
+    for (const expression of this._expressions) {
+      const node = new DebugWatchNode(this.manager.currentSession, expression, root);
+      // 执行运算以获取节点信息
+      await node.evaluate();
+      presets.push(node);
+    }
+    root.updatePresetChildren(presets);
+    this._root = root;
+    return this._root;
+  }
+
+  async init() {
+    this.toDispose.push(
+      this.manager.onDidStopDebugSession(() => {
+        this.fireDidChange();
+      }),
+    );
+    this.toDispose.push(
+      this.manager.onDidDestroyDebugSession(() => {
+        this.fireDidChange();
+      }),
+    );
+    this.toDispose.push(
+      this.manager.onDidChangeActiveDebugSession(() => {
+        const session = this.manager.currentSession;
+        if (session) {
+          session.onVariableChange(() => {
+            this.fireVariableChange();
+          });
+          session.onDidChangeCallStack(() => {
+            this.fireVariableChange();
+          });
+        }
+      }),
+    );
+  }
+
+  async clear() {
+    this.updateWatchExpressions([]);
+    this.fireExpressionChange([]);
+    this.fireDidChange();
+  }
+
+  async updateWatchExpressions(data: string[]) {
+    this._expressions = data;
+  }
+
+  addWatchExpression(value: string) {
+    this.reporterService.point(DEBUG_REPORT_NAME?.DEBUG_WATCH, DEBUG_COMMANDS.ADD_WATCHER.id, { value });
+    const index = this._expressions.indexOf(value);
+    if (index === -1) {
+      this._expressions.push(value);
+      this.fireExpressionChange(this._expressions);
+    }
+  }
+
+  renameWatchExpression(value: string, newValue: string) {
+    const index = this._expressions.indexOf(value);
+    if (index >= 0) {
+      this._expressions.splice(index, 1, newValue);
+    }
+    this.fireExpressionChange(this._expressions);
+  }
+
+  removeWatchExpression(value: string) {
+    const index = this._expressions.indexOf(value);
+    if (index >= 0) {
+      this._expressions.splice(index, 1);
+    }
+    this.fireExpressionChange(this._expressions);
+  }
+}

package/src/browser/model/index.ts

@@ -0,0 +1,4 @@
+export * from './debug-source';
+export * from './debug-stack-frame';
+export * from './debug-thread';
+export * from './debug-watch';

package/src/browser/preferences/launch-folder-preference-provider.ts

@@ -0,0 +1,23 @@
+import { Injectable } from '@opensumi/di';
+import { FolderFilePreferenceProvider } from '@opensumi/ide-preferences/lib/browser/folder-file-preference-provider';
+
+@Injectable()
+export class LaunchFolderPreferenceProvider extends FolderFilePreferenceProvider {
+  protected parse(content: string): any {
+    const launch = super.parse(content);
+    if (launch === undefined) {
+      return undefined;
+    }
+    return { launch: { ...launch } };
+  }
+
+  protected getPath(preferenceName: string): string[] | undefined {
+    if (preferenceName === 'launch') {
+      return [];
+    }
+    if (preferenceName.startsWith('launch.')) {
+      return [preferenceName.substr('launch.'.length)];
+    }
+    return undefined;
+  }
+}

package/src/browser/preferences/launch-preferences-contribution.ts

@@ -0,0 +1,9 @@
+import { PreferenceContribution, PreferenceSchema, Domain, PreferenceConfiguration } from '@opensumi/ide-core-browser';
+
+import { launchPreferencesSchema } from './launch-preferences';
+
+@Domain(PreferenceContribution, PreferenceConfiguration)
+export class LaunchPreferencesContribution implements PreferenceContribution, PreferenceConfiguration {
+  schema: PreferenceSchema = launchPreferencesSchema;
+  name = 'launch';
+}

package/src/browser/preferences/launch-preferences.ts

@@ -0,0 +1,16 @@
+import { PreferenceSchema } from '@opensumi/ide-core-browser';
+
+import { launchSchemaUri } from '../../common';
+
+export const launchPreferencesSchema: PreferenceSchema = {
+  type: 'object',
+  scope: 'resource',
+  properties: {
+    launch: {
+      $ref: launchSchemaUri,
+      description:
+        "Global debug launch configuration. Should be used as an alternative to 'launch.json' that is shared across workspaces",
+      defaultValue: { configurations: [], compounds: [] },
+    },
+  },
+};