Method evaluate

src/adapter/threads.ts:624–672

(args: Dap.EvaluateParamsExtended)

  }

  public async evaluate(args: Dap.EvaluateParamsExtended): Promise<Dap.EvaluateResult> {
    let callFrameId: Cdp.Debugger.CallFrameId | undefined;
    let stackFrame: StackFrame | InlinedFrame | undefined;
    if (args.frameId !== undefined) {
      stackFrame = this._pausedDetails
        ? this._pausedDetails.stackTrace.frame(args.frameId)
        : undefined;

      if (!stackFrame) {
        throw new ProtocolError(this._stackFrameNotFoundError());
      }

      callFrameId = stackFrame.root.callFrameId();
      if (!callFrameId) {
        throw new ProtocolError(this._evaluateOnAsyncFrameError());
      }
    }

    if (args.context === 'repl' && args.expression.startsWith('cd ')) {
      const contextName = args.expression.substring('cd '.length).trim();
      for (const ec of this._executionContexts.values()) {
        if (this.target.executionContextName(ec.description) === contextName) {
          this._selectedContext = ec;
          return {
            result: `[${contextName}]`,
            variablesReference: 0,
          };
        }
      }
    }

    const variableStore = callFrameId ? this._pausedVariables : this.replVariables;
    if (!variableStore) {
      throw new ProtocolError(errors.createSilentError(l10n.t('Unable to evaluate')));
    }

    const variable = (await this._evaluteWasm(stackFrame, args, variableStore))
      ?? (await this._evaluteJs(stackFrame, args, variableStore));

    return {
      type: variable.type,
      result: variable.value,
      variablesReference: variable.variablesReference,
      namedVariables: variable.namedVariables,
      indexedVariables: variable.indexedVariables,
      memoryReference: variable.memoryReference,
      valueLocationReference: variable.valueLocationReference,
    };
  }

  private getHoverEvalTimeout() {
    const configuredTimeout = this.launchConfig.timeouts?.hoverEvaluation;