TypeScript IConnection.onDocumentSymbol方法代码示例

  constructor(
      protected connection: IConnection,
      private converter: AnalyzerLSPConverter,
      private featureFinder: FeatureFinder, private analyzer: LsAnalyzer,
      settings: Settings) {
    super();

    this.connection.onDefinition(async(textPosition) => {
      return this.handleErrors(
          this.getDefinition(textPosition), undefined) as Promise<Definition>;
    });

    this.connection.onReferences(async(params) => {
      return this.handleErrors(this.getReferences(params), []);
    });

    this.connection.onWorkspaceSymbol(async(params) => {
      const analysis =
          await this.analyzer.analyzePackage('get workspace symbols');
      const symbols = this.findSymbols(analysis);
      return fuzzaldrin.filter(symbols, params.query, {key: 'name'});
    });

    this.connection.onDocumentSymbol(async(params) => {
      const localPath = converter.getWorkspacePathToFile(params.textDocument);
      const analysis =
          await this.analyzer.analyze([localPath], 'get document symbols');
      const maybeDocument = analysis.getDocument(localPath);
      if (!(maybeDocument instanceof Document)) {
        return [];
      }
      return this.findSymbols(maybeDocument);
    });

    this.connection.onCodeLens(async(params) => {
      const lenses = [];
      if (settings.referencesCodeLens) {
        lenses.push(...await this.handleErrors(this.getCodeLenses(params), []));
      }
      return lenses;
    });
  }

  constructor(
      protected connection: IConnection,
      private converter: AnalyzerLSPConverter,
      private featureFinder: FeatureFinder, private analyzer: LsAnalyzer,
      settings: Settings) {
    super();
    this.connection.onDefinition(async(textPosition) => {
      return this.handleErrors(this.getDefinition(textPosition), null);
    });

    this.connection.onReferences(async(params) => {
      return this.handleErrors(this.getReferences(params), []);
    });

    this.connection.onWorkspaceSymbol(async(params) => {
      const analysis =
          await this.analyzer.analyzePackage({reason: 'get workspace symbols'});
      const symbols = this.findSymbols(analysis);
      return fuzzaldrin.filter(symbols, params.query, {key: 'name'});
    });

    this.connection.onDocumentSymbol(async(params) => {
      const url = params.textDocument.uri;
      const analysis =
          await this.analyzer.analyze([url], {reason: 'get document symbols'});
      const result = analysis.getDocument(url);
      if (!result.successful) {
        return [];
      }
      return this.findSymbols(result.value);
    });

    this.connection.onCodeLens(async(params) => {
      const lenses = [];
      if (settings.referencesCodeLens) {
        lenses.push(...await this.handleErrors(this.getCodeLenses(params), []));
      }
      return lenses;
    });
  }

	};
	let links: DocumentLink[] = [];
	languageModes.getAllModesInDocument(document).forEach(m => {
		if (m.findDocumentLinks) {
			pushAll(links, m.findDocumentLinks(document, documentContext));
		}
	});
	return links;
});

connection.onDocumentSymbol(documentSymbolParms => {
	let document = documents.get(documentSymbolParms.textDocument.uri);
	let symbols: SymbolInformation[] = [];
	languageModes.getAllModesInDocument(document).forEach(m => {
		if (m.findDocumentSymbols) {
			pushAll(symbols, m.findDocumentSymbols(document));
		}
	});
	return symbols;
});

connection.onRequest(DocumentColorRequest.type, params => {
	let infos: ColorInformation[] = [];
	let document = documents.get(params.textDocument.uri);
	if (document) {
		languageModes.getAllModesInDocument(document).forEach(m => {
			if (m.findDocumentColors) {
				pushAll(infos, m.findDocumentColors(document));
			}
		});
	}

connection.onDocumentSymbol((symbolParam) => {
  try {
    if (currentSettings.parser.exportSourcemap === false) {
      connection.window.showWarningMessage('\
        The current parser options have source maps disabled.\
        Without those, it\'s not possible to generate document symbol.\
        ', { title: 'More Info' }).then(() => {
          connection.sendNotification('openUrl', getHelpUrl('#no-sourcemaps-enabled'));
        });

      return Promise.resolve([]); // I cannot let you navigate if I have no source map.
    }

    const documentObject = documents.get(symbolParam.textDocument.uri);
    let textDocument = documentObject.getText();

    if (documentObject.languageId === 'apiblueprint') {
      textDocument = utf16to8(textDocument);

      /*
        The reason why this is happening just for API Blueprint is that drafter.js
        is coming from C++ code (using es). Swagger parser is pure javascript thuos
        sourcemaps are char based and not byte based.

        See https://github.com/apiaryio/fury.js/issues/63 for more details.
      */
    }

    const documentLines = textDocument.split(/\r?\n/g);
    const refractOutput = refractDocuments.get(symbolParam.textDocument.uri.toString());

    if (typeof (refractOutput) === 'undefined') {
      return parse(textDocument, currentSettings.parser)
        .then((output) => {
          refractDocuments.set(symbolParam.textDocument.uri.toString(), output);
          return refractUtils.extractSymbols(output, textDocument, documentLines, desideredSymbols);
        });
    }

    const symbolArray = refractUtils.extractSymbols(refractOutput, textDocument, documentLines, desideredSymbols);
    return Promise.resolve(symbolArray);
  } catch (err) {
    connection.window.showErrorMessage(err.message);
  }

});

    connection.sendDiagnostics({ uri: textDocument.uri, diagnostics });
  }
}

connection.onDocumentSymbol((symbolParam) => {
  try {
    if (currentSettings.parser.exportSourcemap === false) {
      connection.window.showWarningMessage("\
        The current parser options have source maps disabled.\
        Without those, it's not possible to generate document symbol.\
        ");

      return Promise.resolve([]); // I cannot let you navigate if I have no source map.
    }

    const textDocument = utf16to8(documents.get(symbolParam.textDocument.uri).getText());
    const documentLines = textDocument.split(/\r?\n/g);
    const refractOutput = refractDocuments.get(symbolParam.textDocument.uri.toString());

    const symbolArray = refractUtils.extractSymbols(refractOutput, textDocument, documentLines);
    return Promise.resolve(symbolArray);
  } catch(err) {
    connection.window.showErrorMessage(err.message);
  }


});

connection.onRequest({method: "parserOutput"}, (code) => {
  try {
    return parser.parse(code);