Class Scope

src/adapter/variableStore.ts:1446–1501

}

class Scope implements IVariableContainer {
  /** @inheritdoc */
  public readonly id = getVariableId();

  constructor(
    public readonly remoteObject: Cdp.Runtime.RemoteObject,
    private readonly context: VariableContext,
    public readonly ref: IScopeRef,
    private readonly extraProperties: IExtraProperty[],
    private readonly renameProvider: IRenameProvider,
  ) {}

  public async getChildren(_params: Dap.VariablesParams): Promise<IVariable[]> {
    const variables = await this.context.createObjectPropertyVars(this.remoteObject);
    const existing = new Set(variables.map(v => v.name));
    for (const extraProperty of this.extraProperties) {
      if (!existing.has(extraProperty.name)) {
        variables.push(
          this.context.createVariableByType({ name: extraProperty.name }, extraProperty.value),
        );
      }
    }

    return variables;
  }

  /** Maps any rename for the identifier in the current scope. */
  public async getRename(forIdentifier: string) {
    const renames = await this.renameProvider.provideOnStackframe(this.ref.stackFrame);
    return renames.getOriginalName(forIdentifier, this.ref.stackFrame.rawPosition)
      || forIdentifier;
  }

  /** Sets a property of the scope */
  public async setProperty(name: string, expression: string): Promise<Variable> {
    const evaluated = await this.context.cdp.Debugger.evaluateOnCallFrame({
      expression: `${expression} ${getSourceSuffix()}`,
      callFrameId: this.ref.callFrameId,
    });
    if (!evaluated) {
      throw new ProtocolError(errors.createUserError(l10n.t('Invalid expression')));
    }
    if (evaluated.exceptionDetails) {
      throw new ProtocolError(errorFromException(evaluated.exceptionDetails));
    }

    await this.context.cdp.Debugger.setVariableValue({
      callFrameId: this.ref.callFrameId,
      scopeNumber: this.ref.scopeNumber,
      variableName: name,
      newValue: toCallArgument(evaluated.result),
    });

    return this.context.createVariableByType({ name }, evaluated.result);
  }
}

export interface IExtraProperty {