Method attach

valdi/vscode_debugger/src/binder.ts:340–391

(target: ITarget, launcher: ILauncher)

  }

  public async attach(target: ITarget, launcher: ILauncher) {
    if (!this._launchParams) {
      throw new Error('Cannot launch before params have been set');
    }

    if (!target.canAttach()) {
      return;
    }
    const cdp = await target.attach();
    if (!cdp) {
      return;
    }
    const connection = await this._delegate.acquireDap(target);
    const dap = await connection.dap();
    const launchParams = this._launchParams;

    if (!this._asyncStackPolicy) {
      this._asyncStackPolicy = getAsyncStackPolicy(launchParams.showAsyncStacks);
    }

    const parentTarget = target.parent();
    const parentContainer =
      (parentTarget && this._serviceTree.get(parentTarget)) || this._rootServices;
    const container = createTargetContainer(parentContainer, target, dap, cdp);
    connection.attachTelemetry(container.get(ITelemetryReporter));
    this._serviceTree.set(target, parentContainer);

    // todo: move scriptskipper into services collection
    const debugAdapter = new DebugAdapter(dap, this._asyncStackPolicy, launchParams, container);
    const thread = debugAdapter.createThread(cdp, target);
    this._threads.set(target, { thread, debugAdapter });
    const startThread = async () => {
      await debugAdapter.launchBlocker();
      cdp.Runtime.runIfWaitingForDebugger({});
      return {};
    };
    if (await this._delegate.initAdapter(debugAdapter, target, launcher)) {
      startThread();
    } else {
      dap.on('attach', startThread);
      dap.on('launch', startThread);
      dap.on('disconnect', () => this.detachTarget(target, container));
      dap.on('terminate', () => this.stopTarget(target, container));
      dap.on('restart', async () => {
        if (target.canRestart()) target.restart();
        else await this._restart();
        return {};
      });
    }

    await target.afterBind();
  }

  /**
   * Called when we get a disconnect for a target. We stop the