Request for a visible document can reach the server before its didOpen when hidden documents are open at start #1868

exports.activate = () => {};

const path = require('path');
const vscode = require('vscode');
const { LanguageClient, TransportKind } = require('vscode-languageclient/node');

exports.run = async () => {
  const workspace = process.env.REPRO_WORKSPACE;
  // Documents that are loaded but not shown in an editor, and one visible one.
  for (let i = 0; i < Number(process.env.REPRO_HIDDEN); i++) {
    await vscode.workspace.openTextDocument(path.join(workspace, `hidden-${i}.txt`));
  }
  const visible = await vscode.workspace.openTextDocument(path.join(workspace, 'visible.txt'));
  await vscode.window.showTextDocument(visible);

  const server = { module: path.join(__dirname, '..', 'server.js'), transport: TransportKind.stdio };
  for (let attempt = 0; attempt < Number(process.env.REPRO_ATTEMPTS); attempt++) {
    // No middleware and default options.
    const client = new LanguageClient('repro', 'Repro', { run: server, debug: server }, {
      documentSelector: [{ scheme: 'file', language: 'plaintext' }],
    });
    await client.start();
    // Ask for the visible document's symbols as soon as the client is running.
    await vscode.commands.executeCommand('vscode.executeDocumentSymbolProvider', visible.uri);
    await client.stop();
  }
};

// Minimal LSP server over stdio: records the order of incoming messages and
// rejects requests for documents it has not received a didOpen for.
const fs = require('fs');
const log = process.env.REPRO_LOG;
const open = new Set();
let buffer = Buffer.alloc(0);

function send(message) {
  const body = Buffer.from(JSON.stringify({ jsonrpc: '2.0', ...message }));
  process.stdout.write(`Content-Length: ${body.length}\r\n\r\n`);
  process.stdout.write(body);
}

function handle(message) {
  const uri = message.params?.textDocument?.uri ?? '';
  fs.appendFileSync(log, `${message.method} ${uri.split('/').pop()}\n`);
  switch (message.method) {
    case 'initialize':
      return send({ id: message.id, result: { capabilities: {
        textDocumentSync: { openClose: true, change: 2 },
        documentSymbolProvider: true,
      } } });
    case 'textDocument/didOpen': open.add(uri); return;
    case 'textDocument/didClose': open.delete(uri); return;
    case 'textDocument/documentSymbol':
      if (!open.has(uri)) {
        fs.appendFileSync(log, `  -> rejected: ${uri.split('/').pop()} is not open\n`);
        return send({ id: message.id, error: { code: -32602, message: 'Document is not open' } });
      }
      return send({ id: message.id, result: [] });
    case 'shutdown': return send({ id: message.id, result: null });
    case 'exit': process.exit(0);
  }
}

process.stdin.on('data', chunk => {
  buffer = Buffer.concat([buffer, chunk]);
  for (;;) {
    const header = buffer.indexOf('\r\n\r\n');
    if (header < 0) return;
    const length = Number(/Content-Length: (\d+)/i.exec(buffer.subarray(0, header).toString())[1]);
    if (buffer.length < header + 4 + length) return;
    handle(JSON.parse(buffer.subarray(header + 4, header + 4 + length).toString()));
    buffer = buffer.subarray(header + 4 + length);
  }
});

const fs = require('fs');
const os = require('os');
const path = require('path');
const { runTests } = require('@vscode/test-electron');

(async () => {
  const log = path.join(__dirname, 'messages.log');
  fs.rmSync(log, { force: true });
  const workspace = path.join(__dirname, 'ws');
  const hidden = Number(process.env.REPRO_HIDDEN ?? 30);
  fs.rmSync(workspace, { recursive: true, force: true });
  fs.mkdirSync(workspace);
  for (let i = 0; i < hidden; i++) fs.writeFileSync(path.join(workspace, `hidden-${i}.txt`), 'hidden\n');
  fs.writeFileSync(path.join(workspace, 'visible.txt'), 'visible\n');
  const userData = fs.mkdtempSync(path.join(os.tmpdir(), 'lc-repro-'));
  await runTests({
    vscodeExecutablePath: process.env.VSCODE_EXECUTABLE_PATH,
    extensionDevelopmentPath: __dirname,
    extensionTestsPath: path.join(__dirname, 'test', 'index.js'),
    launchArgs: [workspace, '--disable-extensions', '--user-data-dir', userData],
    extensionTestsEnv: { REPRO_LOG: log, REPRO_WORKSPACE: workspace, REPRO_HIDDEN: String(hidden), REPRO_ATTEMPTS: process.env.REPRO_ATTEMPTS ?? '10' },
  });
  const messages = fs.readFileSync(log, 'utf8');
  process.stdout.write(messages);
  const starts = messages.split('\n').filter(line => line.startsWith('initialize ')).length;
  const rejected = messages.split('\n').filter(line => line.includes('-> rejected')).length;
  console.log(`${rejected} of ${starts} starts sent documentSymbol before didOpen`);
})().catch(error => { console.error(error); process.exit(1); });