TypeScript languages.registerWorkspaceSymbolProvider方法代码示例

 disposables.add(server.onServerStart(() => {
     // register language feature provider on start
     localDisposables = new CompositeDisposable();
     const definitionMetadataDocumentProvider = new DefinitionMetadataDocumentProvider();
     definitionMetadataDocumentProvider.register();
     localDisposables.add(definitionMetadataDocumentProvider);
     const definitionProvider = new DefinitionProvider(server, definitionMetadataDocumentProvider);
     localDisposables.add(vscode.languages.registerDefinitionProvider(documentSelector, definitionProvider));
     localDisposables.add(vscode.languages.registerDefinitionProvider({ scheme: definitionMetadataDocumentProvider.scheme }, definitionProvider));
     localDisposables.add(vscode.languages.registerImplementationProvider(documentSelector, new ImplementationProvider(server)));
     const testManager = new TestManager(server, eventStream);
     localDisposables.add(testManager);
     localDisposables.add(vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(server, testManager, optionProvider)));
     localDisposables.add(vscode.languages.registerDocumentHighlightProvider(documentSelector, new DocumentHighlightProvider(server)));
     localDisposables.add(vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider(server)));
     localDisposables.add(vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider(server)));
     localDisposables.add(vscode.languages.registerHoverProvider(documentSelector, new HoverProvider(server)));
     localDisposables.add(vscode.languages.registerRenameProvider(documentSelector, new RenameProvider(server)));
     if (options.useFormatting) {
         localDisposables.add(vscode.languages.registerDocumentRangeFormattingEditProvider(documentSelector, new FormatProvider(server)));
         localDisposables.add(vscode.languages.registerOnTypeFormattingEditProvider(documentSelector, new FormatProvider(server), '}', ';'));
     }
     localDisposables.add(vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionItemProvider(server), '.', ' '));
     localDisposables.add(vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(server, optionProvider)));
     localDisposables.add(vscode.languages.registerSignatureHelpProvider(documentSelector, new SignatureHelpProvider(server), '(', ','));
     const codeActionProvider = new CodeActionProvider(server, optionProvider);
     localDisposables.add(codeActionProvider);
     localDisposables.add(vscode.languages.registerCodeActionsProvider(documentSelector, codeActionProvider));
     localDisposables.add(reportDiagnostics(server, advisor));
     localDisposables.add(forwardChanges(server));
     localDisposables.add(trackVirtualDocuments(server, eventStream));
     localDisposables.add(vscode.languages.registerFoldingRangeProvider(documentSelector, new StructureProvider(server)));
 }));

    disposables.push(server.onServerStart(() => {
        // register language feature provider on start
        const definitionMetadataDocumentProvider = new DefinitionMetadataDocumentProvider();
        definitionMetadataDocumentProvider.register();
        localDisposables.push(definitionMetadataDocumentProvider);

        localDisposables.push(vscode.languages.registerDefinitionProvider(documentSelector, new DefinitionProvider(server, definitionMetadataDocumentProvider)));
        localDisposables.push(vscode.languages.registerImplementationProvider(documentSelector, new ImplementationProvider(server)));
        localDisposables.push(vscode.languages.registerCodeLensProvider(documentSelector, new CodeLensProvider(server)));
        localDisposables.push(vscode.languages.registerDocumentHighlightProvider(documentSelector, new DocumentHighlightProvider(server)));
        localDisposables.push(vscode.languages.registerDocumentSymbolProvider(documentSelector, new DocumentSymbolProvider(server)));
        localDisposables.push(vscode.languages.registerReferenceProvider(documentSelector, new ReferenceProvider(server)));
        localDisposables.push(vscode.languages.registerHoverProvider(documentSelector, new HoverProvider(server)));
        localDisposables.push(vscode.languages.registerRenameProvider(documentSelector, new RenameProvider(server)));
        localDisposables.push(vscode.languages.registerDocumentRangeFormattingEditProvider(documentSelector, new FormatProvider(server)));
        localDisposables.push(vscode.languages.registerOnTypeFormattingEditProvider(documentSelector, new FormatProvider(server), '}', ';'));
        localDisposables.push(vscode.languages.registerCompletionItemProvider(documentSelector, new CompletionItemProvider(server), '.', '<'));
        localDisposables.push(vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(server)));
        localDisposables.push(vscode.languages.registerSignatureHelpProvider(documentSelector, new SignatureHelpProvider(server), '(', ','));
        const codeActionProvider = new CodeActionProvider(server);
        localDisposables.push(codeActionProvider);
        localDisposables.push(vscode.languages.registerCodeActionsProvider(documentSelector, codeActionProvider));
        localDisposables.push(reportDiagnostics(server, advisor));
        localDisposables.push(forwardChanges(server));
    }));

export function registerIntellisenseProvider(ctx: ExtensionContext) {
	// for locate: if it's a project, use the root, othewise, don't bother
	if (vscode.workspace.getConfiguration('ruby').intellisense == 'rubyLocate') {
		const refreshLocate = () => {
			let progressOptions = { location: vscode.ProgressLocation.Window, title: 'Indexing Ruby source files' };
			vscode.window.withProgress(progressOptions, () => locate.walk());
		};
		const settings: any = vscode.workspace.getConfiguration("ruby.locate") || {};
		let locate = new Locate(vscode.workspace.rootPath, settings);
		refreshLocate();
		ctx.subscriptions.push(vscode.commands.registerCommand('ruby.reloadProject', refreshLocate));

		const watch = vscode.workspace.createFileSystemWatcher(settings.include);
		watch.onDidChange(uri => locate.parse(uri.fsPath));
		watch.onDidCreate(uri => locate.parse(uri.fsPath));
		watch.onDidDelete(uri => locate.rm(uri.fsPath));
		const locationConverter = match => new vscode.Location(vscode.Uri.file(match.file), new vscode.Position(match.line, match.char));
		const defProvider = {
			provideDefinition: (doc, pos) => {
				const txt = doc.getText(doc.getWordRangeAtPosition(pos));
				return locate.find(txt).then(matches => matches.map(locationConverter));
			}
		};
		ctx.subscriptions.push(vscode.languages.registerDefinitionProvider(['ruby', 'erb'], defProvider));
		const symbolKindTable = {
			class: () => SymbolKind.Class,
			module: () => SymbolKind.Module,
			method: symbolInfo => symbolInfo.name === 'initialize' ? SymbolKind.Constructor : SymbolKind.Method,
			classMethod: () => SymbolKind.Method,
		};
		const defaultSymbolKind = symbolInfo => {
			console.warn(`Unknown symbol type: ${symbolInfo.type}`);
			return SymbolKind.Variable;
		};
		// NOTE: Workaround for high CPU usage on IPC (channel.onread) when too many symbols returned.
		// For channel.onread see issue like this: https://github.com/Microsoft/vscode/issues/6026
		const numOfSymbolLimit = 3000;
		const symbolsConverter = matches => matches.slice(0, numOfSymbolLimit).map(match => {
			const symbolKind = (symbolKindTable[match.type] || defaultSymbolKind)(match);
			return new SymbolInformation(match.name, symbolKind, match.containerName, locationConverter(match));
		});
		const docSymbolProvider = {
			provideDocumentSymbols: (document, token) => {
				return locate.listInFile(document.fileName).then(symbolsConverter);
			}
		};
		ctx.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(['ruby', 'erb'], docSymbolProvider));
		const workspaceSymbolProvider = {
			provideWorkspaceSymbols: (query, token) => {
				return locate.query(query).then(symbolsConverter);
			}
		};
		ctx.subscriptions.push(vscode.languages.registerWorkspaceSymbolProvider(workspaceSymbolProvider));
	} else {
		var rubyLocateDisabled = () => {
			vscode.window.showInformationMessage('The `ruby.intellisense` configuration is not set to use rubyLocate.')
		};
		ctx.subscriptions.push(vscode.commands.registerCommand('ruby.reloadProject', rubyLocateDisabled));
	}
}

 public constructor(
     context: ExtensionContext,
     configuration: Configuration,
     currentWorkingDirectoryManager: CurrentWorkingDirectoryManager
 ) {
     this.configuration = configuration;
     this.currentWorkingDirectoryManager = currentWorkingDirectoryManager;
     this.symbolSearchManager = new SymbolSearchManager(configuration);
     context.subscriptions.push(languages.registerWorkspaceSymbolProvider(this));
 }

		this.description.modeIds.forEach(modeId => {
			let selector: DocumentFilter = { scheme: 'file', language: modeId };
			languages.registerCompletionItemProvider(selector, this.completionItemProvider, '.');
			languages.registerHoverProvider(selector, hoverProvider);
			languages.registerDefinitionProvider(selector, definitionProvider);
			languages.registerDocumentHighlightProvider(selector, documentHighlightProvider);
			languages.registerReferenceProvider(selector, referenceProvider);
			languages.registerDocumentSymbolProvider(selector, documentSymbolProvider);
			languages.registerSignatureHelpProvider(selector, signatureHelpProvider, '(', ',');
			languages.registerRenameProvider(selector, renameProvider);
			languages.registerOnTypeFormattingEditProvider(selector, this.formattingProvider, ';', '}', '\n');
			languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(client, modeId));
			if (client.apiVersion.has213Features()) {
				languages.registerCodeActionsProvider(selector, new CodeActionProvider(client, modeId));
			}
			languages.setLanguageConfiguration(modeId, {
				indentationRules: {
					// ^(.*\*/)?\s*\}.*$
					decreaseIndentPattern: /^(.*\*\/)?\s*\}.*$/,
					// ^.*\{[^}"']*$
					increaseIndentPattern: /^.*\{[^}"']*$/
				},
				wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\@\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
				onEnterRules: [
					{
						// e.g. /** | */
						beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
						afterText: /^\s*\*\/$/,
						action: { indentAction: IndentAction.IndentOutdent, appendText: ' * ' }
					},
					{
						// e.g. /** ...|
						beforeText: /^\s*\/\*\*(?!\/)([^\*]|\*(?!\/))*$/,
						action: { indentAction: IndentAction.None, appendText: ' * ' }
					},
					{
						// e.g.  * ...|
						beforeText: /^(\t|(\ \ ))*\ \*(\ ([^\*]|\*(?!\/))*)?$/,
						action: { indentAction: IndentAction.None, appendText: '* ' }
					},
					{
						// e.g.  */|
						beforeText: /^(\t|(\ \ ))*\ \*\/\s*$/,
						action: { indentAction: IndentAction.None, removeText: 1 }
					},
					{
						// e.g.  *-----*/|
						beforeText: /^(\t|(\ \ ))*\ \*[^/]*\*\/\s*$/,
						action: { indentAction: IndentAction.None, removeText: 1 }
					}
				]
			});
		});

    constructor(private outputChannel: vscode.OutputChannel) {
        this.disposables = [];
        this.disposables.push(this.outputChannel);
        this.generator = new Generator(this.outputChannel);
        this.disposables.push(this.generator);
        this.installer = new Installer();
        this.disposables.push(this.installer);
        this.registerCommands();

        // The extension has just loaded, so lets rebuild the tags
        vscode.languages.registerWorkspaceSymbolProvider(new WorkspaceSymbolProvider(this.generator, this.outputChannel));
        this.buildWorkspaceSymbols(true);
    }

	const connectedSetup = analyzer.registerForServerConnected((sc) => {
		connectedSetup.dispose();

		if (analyzer.capabilities.supportsClosingLabels && config.closingLabels) {
			context.subscriptions.push(new ClosingLabelsDecorations(analyzer));
		}

		if (analyzer.capabilities.supportsGetDeclerations) {
			context.subscriptions.push(vs.languages.registerWorkspaceSymbolProvider(new DartWorkspaceSymbolProvider(analyzer)));
		} else {
			context.subscriptions.push(vs.languages.registerWorkspaceSymbolProvider(new LegacyDartWorkspaceSymbolProvider(analyzer)));
		}

		if (analyzer.capabilities.supportsCustomFolding && config.analysisServerFolding)
			context.subscriptions.push(vs.languages.registerFoldingRangeProvider(DART_MODE, new DartFoldingProvider(analyzer)));

		if (analyzer.capabilities.supportsGetSignature)
			context.subscriptions.push(vs.languages.registerSignatureHelpProvider(
				DART_MODE,
				new DartSignatureHelpProvider(analyzer),
				...(config.triggerSignatureHelpAutomatically ? ["(", ","] : []),
			));

		const documentSymbolProvider = new DartDocumentSymbolProvider(analyzer);
		activeFileFilters.forEach((filter) => {
			context.subscriptions.push(vs.languages.registerDocumentSymbolProvider(filter, documentSymbolProvider));
		});

		context.subscriptions.push(new OpenFileTracker(analyzer));

		// Set up completions for unimported items.
		if (analyzer.capabilities.supportsAvailableSuggestions && config.autoImportCompletions) {
			analyzer.completionSetSubscriptions({
				subscriptions: ["AVAILABLE_SUGGESTION_SETS"],
			});
		}
	});

export function activate(context: vscode.ExtensionContext) {
	const telemetryReporter = loadDefaultTelemetryReporter();
	context.subscriptions.push(telemetryReporter);

	const contributions = getMarkdownExtensionContributions(context);

	const cspArbiter = new ExtensionContentSecurityPolicyArbiter(context.globalState, context.workspaceState);
	const engine = new MarkdownEngine(contributions, githubSlugifier);
	const logger = new Logger();

	const selector: vscode.DocumentSelector = [
		{ language: 'markdown', scheme: 'file' },
		{ language: 'markdown', scheme: 'untitled' }
	];

	const contentProvider = new MarkdownContentProvider(engine, context, cspArbiter, contributions, logger);
	const symbolProvider = new MDDocumentSymbolProvider(engine);
	const previewManager = new MarkdownPreviewManager(contentProvider, logger, contributions);
	context.subscriptions.push(previewManager);

	context.subscriptions.push(vscode.languages.setLanguageConfiguration('markdown', {
		wordPattern: new RegExp('(\\p{Alphabetic}|\\p{Number})+', 'ug'),
	}));
	context.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(selector, symbolProvider));
	context.subscriptions.push(vscode.languages.registerDocumentLinkProvider(selector, new LinkProvider()));
	context.subscriptions.push(vscode.languages.registerFoldingRangeProvider(selector, new MarkdownFoldingProvider(engine)));
	context.subscriptions.push(vscode.languages.registerWorkspaceSymbolProvider(new MarkdownWorkspaceSymbolProvider(symbolProvider)));

	const previewSecuritySelector = new PreviewSecuritySelector(cspArbiter, previewManager);

	const commandManager = new CommandManager();
	context.subscriptions.push(commandManager);
	commandManager.register(new commands.ShowPreviewCommand(previewManager, telemetryReporter));
	commandManager.register(new commands.ShowPreviewToSideCommand(previewManager, telemetryReporter));
	commandManager.register(new commands.ShowLockedPreviewToSideCommand(previewManager, telemetryReporter));
	commandManager.register(new commands.ShowSourceCommand(previewManager));
	commandManager.register(new commands.RefreshPreviewCommand(previewManager));
	commandManager.register(new commands.MoveCursorToPositionCommand());
	commandManager.register(new commands.ShowPreviewSecuritySelectorCommand(previewSecuritySelector, previewManager));
	commandManager.register(new commands.OpenDocumentLinkCommand(engine));
	commandManager.register(new commands.ToggleLockCommand(previewManager));

	context.subscriptions.push(vscode.workspace.onDidChangeConfiguration(() => {
		logger.updateConfiguration();
		previewManager.updateConfiguration();
	}));
}

export function activate(ctx: ExtensionContext) {
    languages.setLanguageConfiguration('erlang', {
        indentationRules: {
            increaseIndentPattern: /^\s*([^%]*->|receive|if|fun|case\s+.*\s+of|try\s+.*\s+of|catch)\s*$/,
            decreaseIndentPattern: /^.*(;|\.)\s*$/,
        },
        comments: {
            lineComment: '%'
        },
        brackets: [
            ['{', '}'],
            ['[', ']'],
            ['(', ')'],
            ['<<', '>>']
        ],
        __characterPairSupport: {
			autoClosingPairs: [
				{ open: '{', close: '}' },
				{ open: '[', close: ']' },
				{ open: '(', close: ')' },
				{ open: '<<', close: '>>', notIn: ['string', 'comment'] },
				{ open: '"', close: '"', notIn: ['string'] },
				{ open: '\'', close: '\'', notIn: ['string', 'comment'] }
			]
		}
    });

    // enable auto completion
    let config = workspace.getConfiguration('erlang');
    if (config['enableExperimentalAutoComplete']) {
        const whatelsClient = createWhatelsClient(workspace.rootPath);
        ctx.subscriptions.push(whatelsClient);
        const completionJsonPath = ctx.asAbsolutePath("./priv/erlang-libs.json");
        ctx.subscriptions.push(languages.registerCompletionItemProvider({
            language: 'erlang'
        }, new ErlangCompletionProvider(whatelsClient, completionJsonPath), ':'));
        ctx.subscriptions.push(languages.registerDocumentSymbolProvider({
            language: 'erlang'
        }, new ErlangDocumentSymbolProvider(whatelsClient)));
        ctx.subscriptions.push(languages.registerWorkspaceSymbolProvider(
            new ErlangWorkspaceDocumentSymbolProvider(whatelsClient)
        ));
    }
}

function registerMarkdownLanguageFeatures(
	symbolProvider: MDDocumentSymbolProvider,
	engine: MarkdownEngine
): vscode.Disposable {
	const selector: vscode.DocumentSelector = [
		{ language: 'markdown', scheme: 'file' },
		{ language: 'markdown', scheme: 'untitled' }
	];

	return vscode.Disposable.from(
		vscode.languages.setLanguageConfiguration('markdown', {
			wordPattern: new RegExp('(\\p{Alphabetic}|\\p{Number})+', 'ug'),
		}),
		vscode.languages.registerDocumentSymbolProvider(selector, symbolProvider),
		vscode.languages.registerDocumentLinkProvider(selector, new LinkProvider()),
		vscode.languages.registerFoldingRangeProvider(selector, new MarkdownFoldingProvider(engine)),
		vscode.languages.registerWorkspaceSymbolProvider(new MarkdownWorkspaceSymbolProvider(symbolProvider))
	);
}