Method constructor

valdi/vscode_debugger/src/binder.ts:62–146

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

  private _launchers?: ReadonlySet<ILauncher>;

  constructor(
    delegate: IBinderDelegate,
    connection: DapConnection,
    private readonly _rootServices: Container,
    targetOrigin: ITargetOrigin,
  ) {
    this._delegate = delegate;
    this._dap = connection.dap();
    this._targetOrigin = targetOrigin;
    this._disposables = [
      this._onTargetListChangedEmitter,
      installUnhandledErrorReporter(
        _rootServices.get(ILogger),
        _rootServices.get(ITelemetryReporter),
      ),
    ];

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

    this._dap.then(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 => {
        return {
          breakpoints:
            params.breakpoints?.map(() => ({
              id: ++lastBreakpointId,
              verified: false,
              message: localize('breakpoint.provisionalBreakpoint', `Unbound breakpoint`),
            })) ?? [],
        }; // TODO: Put a useful message here
      });
      dap.on('configurationDone', async () => ({}));
      dap.on('threads', async () => ({ threads: [] }));
      dap.on('loadedSources', async () => ({ sources: [] }));
      dap.on('breakpointLocations', () => Promise.resolve({ breakpoints: [] }));
      dap.on('attach', params =>
        this._boot(applyDefaults(params as AnyResolvingConfiguration), dap),
      );
      dap.on('launch', params =>
        this._boot(applyDefaults(params as AnyResolvingConfiguration), dap),
      );
      dap.on('terminate', async () => {
        await this._disconnect();