"nn" 태그로 연결된 4개 게시물개의 게시물이 있습니다.

export function createLspConnection(options: LspConnectionOptions) {
  const connection = createConnection(ProposedFeatures.all);
  const client = new LspClient(connection);
  const logger = new LspClientLogger(client, options.showMessageLevel);
  const documents = new TextDocuments(TextDocument);

  const context: Partial<LspContext> = {
    logger,
    client,
    documents,
    showMessageLevel: options.showMessageLevel
  }

  connection.onDidOpenTextDocument((params) => openTextDocument(params, context as LspContext))
  connection.onDidCloseTextDocument((params) => onDidCloseTextDocument(params, context as LspContext))
  documents.onDidChangeContent((params) => onDidChangeTextDocument(params, context as LspContext))

  connection.onInitialize((params) => initialize(params, context))
  connection.onCompletion((params, token) => completion(params, context as LspContext, token))
  connection.onHover((params, token) => hover(params, context as LspContext, token))

  connection.languages.semanticTokens.on((params) => semanticTokens(params, context as LspContext))

  documents.listen(connection);
  return connection;
}

export function createLspConnection(options: LspConnectionOptions): lsp.Connection {
    const connection = lsp.createConnection(lsp.ProposedFeatures.all);
    const lspClient = new LspClientImpl(connection);
    const logger = new LspClientLogger(lspClient, options.showMessageLevel);
    const server: LspServer = new LspServer({
        logger,
        lspClient,
    });

    connection.onInitialize(server.initialize.bind(server));
    connection.onInitialized(server.initialized.bind(server));
    connection.onDidChangeConfiguration(server.didChangeConfiguration.bind(server));

    connection.onDidOpenTextDocument(server.didOpenTextDocument.bind(server));
    connection.onDidSaveTextDocument(server.didSaveTextDocument.bind(server));
    connection.onDidCloseTextDocument(server.didCloseTextDocument.bind(server));
    connection.onDidChangeTextDocument(server.didChangeTextDocument.bind(server));

    connection.onCodeAction(server.codeAction.bind(server));
    connection.onCodeLens(server.codeLens.bind(server));
    connection.onCodeLensResolve(server.codeLensResolve.bind(server));
    connection.onCompletion(server.completion.bind(server));
    connection.onCompletionResolve(server.completionResolve.bind(server));
    connection.onDefinition(server.definition.bind(server));
    connection.onImplementation(server.implementation.bind(server));
    connection.onTypeDefinition(server.typeDefinition.bind(server));
    connection.onDocumentFormatting(server.documentFormatting.bind(server));
    connection.onDocumentRangeFormatting(server.documentRangeFormatting.bind(server));
    connection.onDocumentHighlight(server.documentHighlight.bind(server));
    connection.onDocumentSymbol(server.documentSymbol.bind(server));
    connection.onExecuteCommand(server.executeCommand.bind(server));
    connection.onHover(server.hover.bind(server));
    connection.onReferences(server.references.bind(server));
    connection.onRenameRequest(server.rename.bind(server));
    connection.onPrepareRename(server.prepareRename.bind(server));
    connection.onSelectionRanges(server.selectionRanges.bind(server));
    connection.onSignatureHelp(server.signatureHelp.bind(server));
    connection.onWorkspaceSymbol(server.workspaceSymbol.bind(server));
    connection.onFoldingRanges(server.foldingRanges.bind(server));
    connection.languages.onLinkedEditingRange(server.linkedEditingRange.bind(server));
    connection.languages.callHierarchy.onPrepare(server.prepareCallHierarchy.bind(server));
    connection.languages.callHierarchy.onIncomingCalls(server.callHierarchyIncomingCalls.bind(server));
    connection.languages.callHierarchy.onOutgoingCalls(server.callHierarchyOutgoingCalls.bind(server));
    connection.languages.inlayHint.on(server.inlayHints.bind(server));
    connection.languages.semanticTokens.on(server.semanticTokensFull.bind(server));
    connection.languages.semanticTokens.onRange(server.semanticTokensRange.bind(server));
    connection.workspace.onWillRenameFiles(server.willRenameFiles.bind(server));

    return connection;
}

export async function hover(params: TextDocumentPositionParams, context: LspContext, token?: CancellationToken): Promise<Hover | null> {

private triggerDiagnostics(delay: number = 200): void {
    this.diagnosticDelayer.trigger(() => {
        this.sendPendingDiagnostics();
    }, delay);
}

export class Delayer<T> {
  constructor(  
    public defaultDelay: number,
    private timeout: NodeJS.Timeout | null = null,
    private completionPromise: Promise<T> | null = null,
    private onSuccess: ((value: T) => void) | null = null,
    private task: (() => T) | null = null,
  )
  {
  }

  public trigger(task: () => T, delay: number = this.defaultDelay): Promise<T> {
    this.task = task;
    
    if (delay >= 0) {
      this.cancelTimeout();
    }

    if (!this.completionPromise) {
      this.completionPromise = new Promise<T>((resolve) => {
        this.onSuccess = resolve;
      }).then(() => {
        this.completionPromise = null;
        const result = this.task!();
        this.task = null;
        return result;
      });
    }

    if (delay >= 0 || this.timeout === null) {
      this.timeout = setTimeout(() => {
        this.timeout = null;
        this.onSuccess!(null!);
      }, delay >= 0 ? delay : this.defaultDelay);
    }

    return this.completionPromise;
  }

  public cancelTimeout(): void {
    if (this.timeout !== null) {
      clearTimeout(this.timeout);
      this.timeout = null;
    }
  }
}

export interface FileScope {
	path: string;
	declarations: DeclarationScope[];
}

export interface DeclarationScope {
	file: FileScope;
	declaration: string;

	sizes: Size[];
	values: Value[];
}

export interface Size {
	scope: DeclarationScope;
	ident: string;

	nodes: Set<Node>;
}

export interface Value {
	scope: DeclarationScope;
	ident: string;

	nodes: Set<Node>;
}

for (const decl of sourceCode) {
  const declScope: DeclarationScope = {
    file: fileScope,
    declaration: decl.name.value,
    sizes: [],
    values: []
  }

  decl.sizeDeclList.decls
    .forEach(ident => {
      const sizeScope = toSize(declScope, ident);
      declScope.sizes.push(sizeScope);
    });

  decl.argumentList.args
    .forEach(arg => {
      const valueScope = toValue(declScope, arg.ident);
      declScope.values.push(valueScope);
    });

  const callExpressions = travel(decl.exprs, isCallExpression);
  const identExprs = travel(decl.exprs, isIdentifierExpression);

  identExprs
    .forEach(identExpr => {
      const value = findValue(declScope, identExpr.ident.value);

      if (value) {
        value.nodes.add(identExpr.ident);
      } else {
        const newValue = toValue(declScope, identExpr.ident);
        declScope.values.push(newValue);
      }
    });

  callExpressions
    .flatMap(sizeDeclList => sizeDeclList.sizes)
    .filter(ident => !!ident)
    .filter(ident => typeof ident !== "number")
    .forEach(ident => {
      const size = findSize(declScope, ident.value);

      if (size) {
        size.nodes.add(ident);
      } else {
        const newSize = toSize(declScope, ident);
        declScope.sizes.push(newSize);
      }
    });

  fileScope.declarations.push(declScope);
}