Class WasmVariable

src/adapter/variableStore.ts:1321–1404

}

class WasmVariable implements IVariable, IMemoryReadable {
  public static presentationHint: Dap.VariablePresentationHint = {
    attributes: ['readOnly'],
  };

  /** @inheritdoc */
  public readonly id = getVariableId();

  /** @inheritdoc */
  public readonly sortOrder = 0;

  constructor(
    private readonly context: VariableContext,
    private readonly variable: IWasmVariableEvaluation,
    private readonly scopeRef: IScopeRef,
  ) {}

  public toDap(): Promise<Dap.Variable> {
    return Promise.resolve({
      name: this.context.name,
      value: this.variable.description || '',
      variablesReference: this.variable.getChildren ? this.id : 0,
      memoryReference: this.variable.linearMemoryAddress ? String(this.id) : undefined,
      presentationHint: this.context.presentationHint,
    });
  }

  public async getChildren(): Promise<IVariable[]> {
    const children = (await this.variable.getChildren?.()) || [];
    return children.map(c =>
      this.context.createVariable(
        WasmVariable,
        { name: c.name, presentationHint: WasmVariable.presentationHint },
        c.value,
        this.scopeRef,
      )
    );
  }

  /** @inheritdoc */
  public async readMemory(offset: number, count: number): Promise<Buffer | undefined> {
    const addr = this.variable.linearMemoryAddress;
    if (addr === undefined) {
      return undefined;
    }

    const result = await this.context.cdp.Debugger.evaluateOnCallFrame({
      callFrameId: this.scopeRef.callFrameId,
      expression: `(${readMemory.source}).call(memories[0].buffer, ${
        +addr + offset
      }, ${+count}) ${getSourceSuffix()}`,
      returnByValue: true,
    });

    if (!result) {
      throw new RemoteException({
        exceptionId: 0,
        text: 'No response from CDP',