Method constructor

src/binder.ts:94–181

(
    private readonly _delegate: IBinderDelegate,
    connection: DapConnection,
    private readonly _rootServices: Container,
    targetOrigin: ITargetOrigin,
  )

  private _root = new TreeNode(undefined);

  constructor(
    private readonly _delegate: IBinderDelegate,
    connection: DapConnection,
    private readonly _rootServices: Container,
    targetOrigin: ITargetOrigin,
  ) {
    this._dap = connection.dap();
    this._targetOrigin = targetOrigin;
    this._disposables.callback(() => disposeContainer(_rootServices));
    this._disposables.push(
      installUnhandledErrorReporter(
        _rootServices.get(ILogger),
        _rootServices.get(ITelemetryReporter),
        _rootServices.get(IsVSCode),
      ),
    );

    connection.attachTelemetry(_rootServices.get(ITelemetryReporter));

    const dap = this._dap;
    let lastBreakpointId = 0;
    let selfProfile: SelfProfile | undefined;

    dap.on('initialize', async clientCapabilities => {
      this._rootServices.bind(IInitializeParams).toConstantValue(clientCapabilities);
      const capabilities = DebugAdapter.capabilities();
      if (clientCapabilities.clientID === 'vscode') {
        filterErrorsReportedToTelemetry();
      }

      setTimeout(() => dap.initialized({}), 0);
      return capabilities;
    });
    dap.on('setExceptionBreakpoints', async () => ({}));
    dap.on('setBreakpoints', async params => {
      if (params.breakpoints?.length) {
        _rootServices.get(DiagnosticToolSuggester).notifyHadBreakpoint();
      }

      return {
        breakpoints: params.breakpoints?.map(() => ({
          id: ++lastBreakpointId,
          verified: false,
          message: l10n.t('Unbound breakpoint'),
        })) ?? [],
      };
    });
    dap.on('configurationDone', async () => ({}));
    dap.on('threads', async () => ({ threads: [] }));
    dap.on('loadedSources', async () => ({ sources: [] }));
    dap.on('breakpointLocations', () => Promise.resolve({ breakpoints: [] }));
    dap.on('attach', async params => {
      await this.boot(params as AnyResolvingConfiguration, dap);
      return {};
    });
    dap.on('launch', async params => {
      await this.boot(params as AnyResolvingConfiguration, dap);
      return {};