TypeScript languages.registerDocumentFormattingEditProvider方法代码示例

 const elixirSenseServer = new ElixirSenseServerProcess(elixirSetting.command, projectPath, (host, port, authToken) => {
   const elixirSenseClient = new ElixirSenseClient(host, port, authToken, env, projectPath);
   elixirSenseClients[projectPath] = elixirSenseClient;
   const autoCompleteProvider = new ElixirSenseAutocompleteProvider(elixirSenseClient);
   const definitionProvider = new ElixirSenseDefinitionProvider(elixirSenseClient);
   const hoverProvider = new ElixirSenseHoverProvider(elixirSenseClient);
   const signatureHelpProvider = new ElixirSenseSignatureHelpProvider(elixirSenseClient);
   const elixirFormatterProvider = new ElixirFormatterProvider();
   subscriptions = [
     vscode.languages.registerCompletionItemProvider(ELIXIR_MODE, autoCompleteProvider, '.', '{', '@'),
     vscode.languages.registerDefinitionProvider(ELIXIR_MODE, definitionProvider),
     vscode.languages.registerHoverProvider(ELIXIR_MODE, hoverProvider),
     vscode.languages.registerSignatureHelpProvider(ELIXIR_MODE, signatureHelpProvider, '(', ','),
     vscode.languages.registerDocumentFormattingEditProvider(ELIXIR_MODE, elixirFormatterProvider),
     vscode.languages.setLanguageConfiguration('elixir', configuration)
   ];
   ctx.subscriptions.concat(subscriptions);
 });

export function activate(context: vscode.ExtensionContext) {
    let rootDir = context.asAbsolutePath(".");
    let pythonSettings = settings.PythonSettings.getInstance();
    telemetryHelper.sendTelemetryEvent(telemetryContracts.EVENT_LOAD, {
        CodeComplete_Has_ExtraPaths: pythonSettings.autoComplete.extraPaths.length > 0 ? "true" : "false",
        Format_Has_Custom_Python_Path: pythonSettings.pythonPath.length !== "python".length ? "true" : "false"
    });
    unitTestOutChannel = vscode.window.createOutputChannel(pythonSettings.unitTest.outputWindow);
    unitTestOutChannel.clear();
    formatOutChannel = unitTestOutChannel;
    lintingOutChannel = unitTestOutChannel;
    if (pythonSettings.unitTest.outputWindow !== pythonSettings.formatting.outputWindow) {
        formatOutChannel = vscode.window.createOutputChannel(pythonSettings.formatting.outputWindow);
        formatOutChannel.clear();
    }
    if (pythonSettings.unitTest.outputWindow !== pythonSettings.linting.outputWindow) {
        lintingOutChannel = vscode.window.createOutputChannel(pythonSettings.linting.outputWindow);
        lintingOutChannel.clear();
    }

    sortImports.activate(context, formatOutChannel);
    activateUnitTestProvider(context, pythonSettings, unitTestOutChannel);
    context.subscriptions.push(activateFormatOnSaveProvider(PYTHON, pythonSettings, formatOutChannel, vscode.workspace.rootPath));

    // Enable indentAction
    vscode.languages.setLanguageConfiguration(PYTHON.language, {
        onEnterRules: [
            {
                beforeText: /^\s*(?:def|class|for|if|elif|else|while|try|with|finally).*?:\s*$/,
                action: { indentAction: vscode.IndentAction.Indent }
            }
        ]
    });

    context.subscriptions.push(vscode.languages.registerRenameProvider(PYTHON, new PythonRenameProvider(context)));
    context.subscriptions.push(vscode.languages.registerHoverProvider(PYTHON, new PythonHoverProvider(context)));
    context.subscriptions.push(vscode.languages.registerDefinitionProvider(PYTHON, new PythonDefinitionProvider(context)));
    context.subscriptions.push(vscode.languages.registerReferenceProvider(PYTHON, new PythonReferenceProvider(context)));
    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(PYTHON, new PythonCompletionItemProvider(context), "."));
    context.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(PYTHON, new PythonSymbolProvider(context)));

    context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(PYTHON, new PythonFormattingEditProvider(context, formatOutChannel, pythonSettings, vscode.workspace.rootPath)));
    context.subscriptions.push(new LintProvider(context, lintingOutChannel, vscode.workspace.rootPath));
}

export function activate(context: vscode.ExtensionContext) {
    var rootDir = context.asAbsolutePath(".");
    var pythonSettings = new settings.PythonSettings();
    unitTestOutChannel = vscode.window.createOutputChannel(pythonSettings.unitTest.outputWindow);
    unitTestOutChannel.clear();
    formatOutChannel = unitTestOutChannel;
    lintingOutChannel = unitTestOutChannel;
    if (pythonSettings.unitTest.outputWindow !== pythonSettings.formatting.outputWindow) {
        formatOutChannel = vscode.window.createOutputChannel(pythonSettings.formatting.outputWindow);
        formatOutChannel.clear();
    }
    if (pythonSettings.unitTest.outputWindow !== pythonSettings.linting.outputWindow) {
        lintingOutChannel = vscode.window.createOutputChannel(pythonSettings.linting.outputWindow);
        lintingOutChannel.clear();
    }


    sortImports.activate(context);
    activateUnitTestProvider(context, pythonSettings, unitTestOutChannel);
    activateFormatOnSaveProvider(PYTHON, context, pythonSettings, formatOutChannel);

    //Enable indentAction
    vscode.languages.setLanguageConfiguration(PYTHON.language, {
        onEnterRules: [
            {
                beforeText: /^\s*(?:def|class|for|if|elif|else|while|try|with|finally).*?:\s*$/,
                action: { indentAction: vscode.IndentAction.Indent }
            }
        ]
    });

    context.subscriptions.push(vscode.languages.registerRenameProvider(PYTHON, new PythonRenameProvider(context)));
    context.subscriptions.push(vscode.languages.registerHoverProvider(PYTHON, new PythonHoverProvider(context)));
    context.subscriptions.push(vscode.languages.registerDefinitionProvider(PYTHON, new PythonDefinitionProvider(context)));
    context.subscriptions.push(vscode.languages.registerReferenceProvider(PYTHON, new PythonReferenceProvider(context)));
    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(PYTHON, new PythonCompletionItemProvider(context), '.'));
    context.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(PYTHON, new PythonSymbolProvider(context)));
    // context.subscriptions.push(vscode.languages.registerSignatureHelpProvider(PYTHON, new PythonSignatureHelpProvider(context), '('));

    context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(PYTHON, new PythonFormattingEditProvider(context, pythonSettings, formatOutChannel)));
    context.subscriptions.push(new LintProvider(context, pythonSettings, lintingOutChannel));
}

export function activate(ctx: vscode.ExtensionContext) {
  const elixirSetting = vscode.workspace.getConfiguration('elixir');
  useElixirSense = elixirSetting.useElixirSense;
  autoSpawnElixirSenseServers = elixirSetting.autoSpawnElixirSenseServers;
  const projectPath = elixirSetting.projectPath;
  // TODO: detect environment automatically.
  const env = elixirSetting.elixirEnv;

  if (useElixirSense) {
    ElixirSenseServerProcess.initClass();
    if (autoSpawnElixirSenseServers) {
      (vscode.workspace.workspaceFolders || []).forEach(workspaceFolder => {
        startElixirSenseServerForWorkspaceFolder(workspaceFolder, ctx, env, projectPath);
      });
    } else if ((vscode.workspace.workspaceFolders || []).length === 1) {
      startElixirSenseServerForWorkspaceFolder(vscode.workspace.workspaceFolders[0], ctx, env);
    }
    vscode.workspace.onDidChangeWorkspaceFolders(e => {
      (e.removed || []).forEach(workspaceFolder => stopElixirSenseServerByPath(workspaceFolder.uri.fsPath));
      if (autoSpawnElixirSenseServers) {
        (e.added || []).forEach(workspaceFolder => startElixirSenseServerForWorkspaceFolder(workspaceFolder, ctx, env));
      }
    });
  } else {
    this.elixirServer = new ElixirServer(elixirSetting.command);
    this.elixirServer.start();
    ctx.subscriptions.push(vscode.languages.registerCompletionItemProvider(ELIXIR_MODE, new ElixirAutocomplete(this.elixirServer), '.'));
    ctx.subscriptions.push(vscode.languages.registerDefinitionProvider(ELIXIR_MODE, new ElixirDefinitionProvider(this.elixirServer)));
    ctx.subscriptions.push(vscode.languages.registerHoverProvider(ELIXIR_MODE, new ElixirHoverProvider(this.elixirServer)));
    ctx.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(ELIXIR_MODE, new ElixirFormatterProvider()));
    ctx.subscriptions.push(vscode.languages.setLanguageConfiguration('elixir', configuration));
  }

  ctx.subscriptions.push(vscode.languages.registerDocumentSymbolProvider({ language: 'elixir' }, new ElixirDocumentSymbolProvider()));

  const disposables = [];
  if (useElixirSense) {
    disposables.push(vscode.commands.registerCommand('extension.selectElixirSenseWorkspaceFolder', () => selectElixirSenseWorkspaceFolder(ctx, env)));
  }
  ctx.subscriptions.push(...disposables);
}

export function activate(context: vscode.ExtensionContext) {
    var rootDir = context.asAbsolutePath(".");
    var pythonSettings = new settings.PythonSettings();
    outChannel = vscode.window.createOutputChannel('Python');
    outChannel.clear();

    sortImports.activate(context);
    activateUnitTestProvider(context, pythonSettings, outChannel);

    context.subscriptions.push(vscode.languages.registerRenameProvider(PYTHON, new PythonRenameProvider(context)));
    context.subscriptions.push(vscode.languages.registerHoverProvider(PYTHON, new PythonHoverProvider(context)));
    context.subscriptions.push(vscode.languages.registerDefinitionProvider(PYTHON, new PythonDefinitionProvider(context)));
    context.subscriptions.push(vscode.languages.registerReferenceProvider(PYTHON, new PythonReferenceProvider(context)));
    context.subscriptions.push(vscode.languages.registerCompletionItemProvider(PYTHON, new PythonCompletionItemProvider(context), '.'));
    context.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(PYTHON, new PythonSymbolProvider(context)));
    // context.subscriptions.push(vscode.languages.registerSignatureHelpProvider(PYTHON, new PythonSignatureHelpProvider(context), '('));

    context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(PYTHON, new PythonFormattingEditProvider(context, pythonSettings, outChannel)));

    context.subscriptions.push(new LintProvider(context, pythonSettings, outChannel));
}

export function activate(ctx: vscode.ExtensionContext) {
  ctx.subscriptions.push(vscode.workspace.onDidSaveTextDocument((document: vscode.TextDocument) => {
    runLinter(document);
  }));
  ctx.subscriptions.push(vscode.workspace.onDidSaveTextDocument((document: vscode.TextDocument) => {
    runFormatOnSave(document);
  }));
  activateRepl().forEach((d: vscode.Disposable) => ctx.subscriptions.push(d));
  activateReactor().forEach((d: vscode.Disposable) => ctx.subscriptions.push(d));
  activateMake().forEach((d: vscode.Disposable) => ctx.subscriptions.push(d));
  activatePackage().forEach((d: vscode.Disposable) => ctx.subscriptions.push(d));
  activateClean().forEach((d: vscode.Disposable) => ctx.subscriptions.push(d));

  ctx.subscriptions.push(vscode.languages.setLanguageConfiguration('elm', configuration))
  ctx.subscriptions.push(vscode.languages.registerHoverProvider(ELM_MODE, new ElmHoverProvider()));
  ctx.subscriptions.push(vscode.languages.registerCompletionItemProvider(ELM_MODE, new ElmCompletionProvider(), '.'));
  ctx.subscriptions.push(vscode.languages.registerDocumentSymbolProvider(ELM_MODE, new ElmSymbolProvider()));
  ctx.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(ELM_MODE, new ElmFormatProvider()))

  // ctx.subscriptions.push(vscode.languages.registerDefinitionProvider(ELM_MODE, new ElmDefinitionProvider()));
}

export function activate(context: ExtensionContext) {

    const disposables: Disposable[] = [];

    console.log("--STARTING CM EXTENSION--");
    
    diagnosticCollection = languages.createDiagnosticCollection( "cm" );
    // setup compiler Adapter
    compilerAdapter = new cmCompilerAdapter( diagnosticCollection, cmConfig.cmOutputFilePath() );
    
    // setup watcher
    var watcher = createWatcher();
    // createFileOpenWatcher();
    
    var completionProvider = new CMCompletionItemProvider();
    
    // subscriptions
    disposables.push(languages.registerDefinitionProvider(CM_MODE, new CMDefinitionProvider()));
    disposables.push(languages.registerCompletionItemProvider(CM_MODE, completionProvider, '.' ) );
    disposables.push(languages.registerDocumentFormattingEditProvider(CM_MODE, new ClangDocumentFormattingEditProvider() ));
    disposables.push(languages.registerHoverProvider( CM_MODE, new CMHoverProvider() ) );
    
    if ( cmConfig.isDebug() ) {
        // put experimental features here
        // disposables.push( languages.registerSignatureHelpProvider( CM_MODE, new SignatureHelpProvider(), '(', ',' ) );
    }
    
    
    disposables.push(diagnosticCollection);
    
    // commands
    // cm commands
    // setupCMCommands( context, compilerAdapter );
    disposables.push( registerCommands( compilerAdapter, completionProvider ) );
    
    setupLangConfig();
    
    context.subscriptions.push(...disposables);
}

export function activate(context: vscode.ExtensionContext) {

	// The server is implemented in node
	let serverModule = context.asAbsolutePath(path.join('server', 'server.js'));
	// The debug options for the server
	let debugOptions = { execArgv: ["--nolazy", "--debug=6004"] };
	
	// If the extension is launch in debug mode the debug server options are use
	// Otherwise the run options are used
	let serverOptions: ServerOptions = {
		run : { module: serverModule, transport: TransportKind.ipc },
		debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions }
	}
	
	// Options to control the language client
	let clientOptions: LanguageClientOptions = {
		// Register the server for plain text documents
		documentSelector: ['lua'],
		synchronize: {
			// Synchronize the setting section 'languageServerExample' to the server
			configurationSection: 'languageServerExample',
			// Notify the server about file changes to '.clientrc files contain in the workspace
			fileEvents: vscode.workspace.createFileSystemWatcher('**/.clientrc')
		}
	}
	
	// Create the language client and start the client.
	let disposable = new LanguageClient('Language Server Example', serverOptions, clientOptions).start();
	
	// Push the disposable to the context's subscriptions so that the 
	// client can be deactivated on extension deactivation
	context.subscriptions.push(disposable);
	
	let outChannel = vscode.window.createOutputChannel('Lua');
	outChannel.clear();
	
	context.subscriptions.push(vscode.languages.registerDocumentFormattingEditProvider(LUA, new LuaFormattingEditProvider(context, outChannel)));
}

			() => ctx.subscriptions.push(
				vscode.languages.registerDocumentFormattingEditProvider('ruby', this)
			),

			() => ctx.subscriptions.push(
				vscode.languages.registerDocumentFormattingEditProvider(documentSelector, this)
			)