From a94ed00f9904a15213a79a1b1644da5e527148f7 Mon Sep 17 00:00:00 2001 From: kingwl Date: Fri, 25 Dec 2020 17:42:43 +0800 Subject: [PATCH 01/16] Add ts server for inline hints --- .../src/languageFeatures/inlineHints.ts | 98 +++++++++++++++++++ .../src/languageProvider.ts | 1 + 2 files changed, 99 insertions(+) create mode 100644 extensions/typescript-language-features/src/languageFeatures/inlineHints.ts diff --git a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts new file mode 100644 index 0000000000000..8607fb92c894a --- /dev/null +++ b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts @@ -0,0 +1,98 @@ +/*--------------------------------------------------------------------------------------------- + * Copyright (c) Microsoft Corporation. All rights reserved. + * Licensed under the MIT License. See License.txt in the project root for license information. + *--------------------------------------------------------------------------------------------*/ + +import * as vscode from 'vscode'; +import * as Proto from '../protocol'; +import { DocumentSelector } from '../utils/documentSelector'; +import { ClientCapability, ITypeScriptServiceClient, ServerResponse, ExecConfig } from '../typescriptService'; +import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration'; +import { Position } from '../utils/typeConverters'; + +export namespace ExperimentalProto { + export const enum CommandTypes { + ProvideInlineHints = 'ProvideInlineHints' + } + + export interface ProvideInlineHintsArgs extends Proto.FileRequestArgs { + /** + * Start position of the span. + */ + start: number; + /** + * Length of the span. + */ + length: number; + } + + export interface ProvideInlineHintsRequest extends Proto.Request { + command: CommandTypes.ProvideInlineHints; + arguments: ProvideInlineHintsArgs; + } + + interface HintItem { + text: string; + position: Proto.Location; + whitespaceBefore?: boolean; + whitespaceAfter?: boolean; + } + + export interface ProvideInlineHintsResponse extends Proto.Response { + body?: HintItem[]; + } + + export interface IExtendedTypeScriptServiceClient { + execute( + command: K, + args: ExtendedTsServerRequests[K][0], + token: vscode.CancellationToken, + config?: ExecConfig + ): Promise>; + } + + export interface ExtendedTsServerRequests { + 'provideInlineHints': [ProvideInlineHintsArgs, ProvideInlineHintsResponse]; + } +} + +class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { + constructor( + private readonly client: ITypeScriptServiceClient + ) { } + + async provideInlineHints(model: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): Promise { + const filepath = this.client.toOpenedFilePath(model); + if (!filepath) { + return []; + } + + const start = model.offsetAt(range.start); + const length = model.offsetAt(range.end) - start; + + try { + const response = await (this.client as ExperimentalProto.IExtendedTypeScriptServiceClient).execute('provideInlineHints', { file: filepath, start, length }, token); + if (response.type !== 'response' || !response.success || !response.body) { + return []; + } + + return response.body.map(hint => { + return new vscode.InlineHint(hint.text, Position.fromLocation(hint.position), hint.whitespaceBefore, hint.whitespaceAfter); + }); + } catch (e) { + return []; + } + } +} + +export function register( + selector: DocumentSelector, + client: ITypeScriptServiceClient +) { + return conditionalRegistration([ + requireSomeCapability(client, ClientCapability.Semantic), + ], () => { + return vscode.languages.registerInlineHintsProvider(selector.semantic, + new TypeScriptInlineHintsProvider(client)); + }); +} diff --git a/extensions/typescript-language-features/src/languageProvider.ts b/extensions/typescript-language-features/src/languageProvider.ts index 5634edb44df5b..ffc4aa950dd55 100644 --- a/extensions/typescript-language-features/src/languageProvider.ts +++ b/extensions/typescript-language-features/src/languageProvider.ts @@ -83,6 +83,7 @@ export default class LanguageProvider extends Disposable { import('./languageFeatures/smartSelect').then(provider => this._register(provider.register(selector, this.client))), import('./languageFeatures/tagClosing').then(provider => this._register(provider.register(selector, this.description.id, this.client))), import('./languageFeatures/typeDefinitions').then(provider => this._register(provider.register(selector, this.client))), + import('./languageFeatures/inlineHints').then(provider => this._register(provider.register(selector, this.client))), ]); } From 6bf8b9d42036d3b400650da6e920861f27e44466 Mon Sep 17 00:00:00 2001 From: kingwl Date: Fri, 25 Dec 2020 23:26:02 +0800 Subject: [PATCH 02/16] Add some feature related configure --- .../typescript-language-features/package.json | 18 ++++++++++++++++++ .../package.nls.json | 3 +++ .../fileConfigurationManager.ts | 13 ++++++++++++- .../src/languageFeatures/inlineHints.ts | 2 +- .../src/typescriptServiceClient.ts | 17 ++++++++++++++++- .../src/utils/configuration.ts | 18 ++++++++++++++++++ 6 files changed, 68 insertions(+), 3 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index d22f57d509522..335c6b57f57bd 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -258,6 +258,24 @@ "description": "%configuration.suggest.includeAutomaticOptionalChainCompletions%", "scope": "resource" }, + "typescript.inlineHints.includeInlineParameterName": { + "type": "boolean", + "default": true, + "description": "%configuration.inlineHints.includeInlineParameterName%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineFunctionParameterType": { + "type": "boolean", + "default": true, + "description": "%configuration.inlineHints.includeInlineFunctionParameterType%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineVariableType": { + "type": "boolean", + "default": true, + "description": "%configuration.inlineHints.includeInlineVariableType%", + "scope": "resource" + }, "typescript.reportStyleChecksAsWarnings": { "type": "boolean", "default": true, diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index a347b903d4178..f2fd5edae6ca5 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -69,6 +69,9 @@ "configuration.implicitProjectConfig.strictNullChecks": "Enable/disable [strict null checks](https://www.typescriptlang.org/tsconfig#strictNullChecks) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.implicitProjectConfig.strictFunctionTypes": "Enable/disable [strict function types](https://www.typescriptlang.org/tsconfig#strictFunctionTypes) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.suggest.autoImports": "Enable/disable auto import suggestions.", + "configuration.inlineHints.includeInlineParameterName": "Enable/disable inline hints of parameter name.", + "configuration.inlineHints.includeInlineFunctionParameterType": "Enable/disable inline hints of function parameter name.", + "configuration.inlineHints.includeInlineVariableType": "Enable/disable inline hints of variable type.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index 05fa16cf97aa8..bbc0c6a0c8efa 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -13,6 +13,14 @@ import { isTypeScriptDocument } from '../utils/languageModeIds'; import { equals } from '../utils/objects'; import { ResourceMap } from '../utils/resourceMap'; +namespace ExperimentalProto { + export interface UserPreferences extends Proto.UserPreferences { + includeInlineParameterName?: boolean; + includeInlineFunctionParameterType?: boolean; + includeInlineVariableType?: boolean; + } +} + interface FileConfiguration { readonly formatOptions: Proto.FormatCodeSettings; readonly preferences: Proto.UserPreferences; @@ -173,7 +181,7 @@ export default class FileConfigurationManager extends Disposable { isTypeScriptDocument(document) ? 'typescript.preferences' : 'javascript.preferences', document.uri); - const preferences: Proto.UserPreferences = { + const preferences: ExperimentalProto.UserPreferences = { quotePreference: this.getQuoteStylePreference(preferencesConfig), // @ts-expect-error until TypeScript 4.2 API importModuleSpecifierPreference: getImportModuleSpecifierPreference(preferencesConfig), @@ -183,6 +191,9 @@ export default class FileConfigurationManager extends Disposable { allowRenameOfImportPath: true, includeAutomaticOptionalChainCompletions: config.get('suggest.includeAutomaticOptionalChainCompletions', true), provideRefactorNotApplicableReason: true, + includeInlineParameterName: config.get('inlineHints.includeInlineParameterName', true), + includeInlineFunctionParameterType: config.get('inlineHints.includeInlineFunctionParameterType', true), + includeInlineVariableType: config.get('inlineHints.includeInlineVariableType', true), }; return preferences; diff --git a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts index 8607fb92c894a..ce634866951cf 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts @@ -10,7 +10,7 @@ import { ClientCapability, ITypeScriptServiceClient, ServerResponse, ExecConfig import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration'; import { Position } from '../utils/typeConverters'; -export namespace ExperimentalProto { +namespace ExperimentalProto { export const enum CommandTypes { ProvideInlineHints = 'ProvideInlineHints' } diff --git a/extensions/typescript-language-features/src/typescriptServiceClient.ts b/extensions/typescript-language-features/src/typescriptServiceClient.ts index c27928ad1e12c..10eb203543c0e 100644 --- a/extensions/typescript-language-features/src/typescriptServiceClient.ts +++ b/extensions/typescript-language-features/src/typescriptServiceClient.ts @@ -30,6 +30,18 @@ import { TelemetryProperties, TelemetryReporter, VSCodeTelemetryReporter } from import Tracer from './utils/tracer'; import { inferredProjectCompilerOptions, ProjectType } from './utils/tsconfig'; +namespace ExperimentalProto { + export interface UserPreferences extends Proto.UserPreferences { + includeInlineParameterName?: boolean; + includeInlineFunctionParameterType?: boolean; + includeInlineVariableType?: boolean; + } + + export interface ConfigureRequestArguments extends Proto.ConfigureRequestArguments { + preferences?: UserPreferences; + } +} + const localize = nls.loadMessageBundle(); export interface TsDiagnostics { @@ -529,12 +541,15 @@ export default class TypeScriptServiceClient extends Disposable implements IType ? this.configuration.watchOptions : undefined; - const configureOptions: Proto.ConfigureRequestArguments = { + const configureOptions: ExperimentalProto.ConfigureRequestArguments = { hostInfo: 'vscode', preferences: { providePrefixAndSuffixTextForRename: true, allowRenameOfImportPath: true, includePackageJsonAutoImports: this._configuration.includePackageJsonAutoImports, + includeInlineParameterName: this._configuration.includeInlineParameterName, + includeInlineFunctionParameterType: this._configuration.includeInlineFunctionParameterType, + includeInlineVariableType: this._configuration.includeInlineVariableType }, watchOptions }; diff --git a/extensions/typescript-language-features/src/utils/configuration.ts b/extensions/typescript-language-features/src/utils/configuration.ts index c43a121079cb1..4027df4e42f12 100644 --- a/extensions/typescript-language-features/src/utils/configuration.ts +++ b/extensions/typescript-language-features/src/utils/configuration.ts @@ -103,6 +103,9 @@ export class TypeScriptServiceConfiguration { public readonly watchOptions: protocol.WatchOptions | undefined; public readonly includePackageJsonAutoImports: 'auto' | 'on' | 'off' | undefined; public readonly enableTsServerTracing: boolean; + public readonly includeInlineParameterName: boolean | undefined; + public readonly includeInlineFunctionParameterType: boolean | undefined; + public readonly includeInlineVariableType: boolean | undefined; public static loadFromWorkspace(): TypeScriptServiceConfiguration { return new TypeScriptServiceConfiguration(); @@ -126,6 +129,9 @@ export class TypeScriptServiceConfiguration { this.watchOptions = TypeScriptServiceConfiguration.readWatchOptions(configuration); this.includePackageJsonAutoImports = TypeScriptServiceConfiguration.readIncludePackageJsonAutoImports(configuration); this.enableTsServerTracing = TypeScriptServiceConfiguration.readEnableTsServerTracing(configuration); + this.includeInlineParameterName = TypeScriptServiceConfiguration.readIncludeInlineParameterName(configuration); + this.includeInlineFunctionParameterType = TypeScriptServiceConfiguration.readIncludeInlineFunctionParameterType(configuration); + this.includeInlineVariableType = TypeScriptServiceConfiguration.readIncludeInlineVariableType(configuration); } public isEqualTo(other: TypeScriptServiceConfiguration): boolean { @@ -216,4 +222,16 @@ export class TypeScriptServiceConfiguration { private static readEnableTsServerTracing(configuration: vscode.WorkspaceConfiguration): boolean { return configuration.get('typescript.tsserver.enableTracing', false); } + + private static readIncludeInlineParameterName(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineParameterName', true); + } + + private static readIncludeInlineFunctionParameterType(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineFunctionParameterType', true); + } + + private static readIncludeInlineVariableType(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineVariableType', true); + } } From 65d2a64df0dac0610a65f3b382752be9693fa51a Mon Sep 17 00:00:00 2001 From: kingwl Date: Wed, 30 Dec 2020 13:37:53 +0800 Subject: [PATCH 03/16] Add more config --- .../typescript-language-features/package.json | 39 ++++++++++++++++++- .../package.nls.json | 6 +++ .../fileConfigurationManager.ts | 12 ++++++ .../src/typescriptServiceClient.ts | 14 ++++++- .../src/utils/configuration.ts | 36 +++++++++++++++++ 5 files changed, 105 insertions(+), 2 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index 335c6b57f57bd..6ee03a6ebbfcd 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -272,10 +272,47 @@ }, "typescript.inlineHints.includeInlineVariableType": { "type": "boolean", - "default": true, + "default": false, "description": "%configuration.inlineHints.includeInlineVariableType%", "scope": "resource" }, + "typescript.inlineHints.includeInlineNonLiteralParameterName": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineNonLiteralParameterName%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineDuplicatedParameterName": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineDuplicatedParameterName%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineRequireAssignedVariableType": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineRequireAssignedVariableType%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlinePropertyDeclarationType": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlinePropertyDeclarationType%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineFunctionLikeReturnType": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineFunctionLikeReturnType%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineEnumMemberValue": { + "type": "boolean", + "default": true, + "description": "%configuration.inlineHints.includeInlineEnumMemberValue%", + "scope": "resource" + }, + "typescript.reportStyleChecksAsWarnings": { "type": "boolean", "default": true, diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index f2fd5edae6ca5..e51ad3ab13952 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -72,6 +72,12 @@ "configuration.inlineHints.includeInlineParameterName": "Enable/disable inline hints of parameter name.", "configuration.inlineHints.includeInlineFunctionParameterType": "Enable/disable inline hints of function parameter name.", "configuration.inlineHints.includeInlineVariableType": "Enable/disable inline hints of variable type.", + "configuration.inlineHints.includeInlineNonLiteralParameterName": "Enable/disable inline hints of non literal argument.", + "configuration.inlineHints.includeInlineDuplicatedParameterName": "Enable/disable inline hints of duplicated argument.", + "configuration.inlineHints.includeInlineRequireAssignedVariableType": "Enable/disable inline hints of require assigned variable.", + "configuration.inlineHints.includeInlinePropertyDeclarationType": "Enable/disable inline hints of property declaration.", + "configuration.inlineHints.includeInlineFunctionLikeReturnType": "Enable/disable inline hints of return type for function like.", + "configuration.inlineHints.includeInlineEnumMemberValue": "Enable/disable inline hints of enum member.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index bbc0c6a0c8efa..164bed1bd80fc 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -18,6 +18,12 @@ namespace ExperimentalProto { includeInlineParameterName?: boolean; includeInlineFunctionParameterType?: boolean; includeInlineVariableType?: boolean; + includeInlineNonLiteralParameterName?: boolean; + includeInlineDuplicatedParameterName?: boolean; + includeInlineRequireAssignedVariableType?: boolean; + includeInlinePropertyDeclarationType?: boolean; + includeInlineFunctionLikeReturnType?: boolean; + includeInlineEnumMemberValue?: boolean; } } @@ -194,6 +200,12 @@ export default class FileConfigurationManager extends Disposable { includeInlineParameterName: config.get('inlineHints.includeInlineParameterName', true), includeInlineFunctionParameterType: config.get('inlineHints.includeInlineFunctionParameterType', true), includeInlineVariableType: config.get('inlineHints.includeInlineVariableType', true), + includeInlineNonLiteralParameterName: config.get('inlineHints.includeInlineNonLiteralParameterName', true), + includeInlineDuplicatedParameterName: config.get('inlineHints.includeInlineDuplicatedParameterName', true), + includeInlineRequireAssignedVariableType: config.get('inlineHints.includeInlineRequireAssignedVariableType', true), + includeInlinePropertyDeclarationType: config.get('inlineHints.includeInlinePropertyDeclarationType', true), + includeInlineFunctionLikeReturnType: config.get('inlineHints.includeInlineFunctionLikeReturnType', true), + includeInlineEnumMemberValue: config.get('inlineHints.includeInlineEnumMemberValue', true), }; return preferences; diff --git a/extensions/typescript-language-features/src/typescriptServiceClient.ts b/extensions/typescript-language-features/src/typescriptServiceClient.ts index 10eb203543c0e..193efe8aade06 100644 --- a/extensions/typescript-language-features/src/typescriptServiceClient.ts +++ b/extensions/typescript-language-features/src/typescriptServiceClient.ts @@ -35,6 +35,12 @@ namespace ExperimentalProto { includeInlineParameterName?: boolean; includeInlineFunctionParameterType?: boolean; includeInlineVariableType?: boolean; + includeInlineNonLiteralParameterName?: boolean; + includeInlineDuplicatedParameterName?: boolean; + includeInlineRequireAssignedVariableType?: boolean; + includeInlinePropertyDeclarationType?: boolean; + includeInlineFunctionLikeReturnType?: boolean; + includeInlineEnumMemberValue?: boolean; } export interface ConfigureRequestArguments extends Proto.ConfigureRequestArguments { @@ -549,7 +555,13 @@ export default class TypeScriptServiceClient extends Disposable implements IType includePackageJsonAutoImports: this._configuration.includePackageJsonAutoImports, includeInlineParameterName: this._configuration.includeInlineParameterName, includeInlineFunctionParameterType: this._configuration.includeInlineFunctionParameterType, - includeInlineVariableType: this._configuration.includeInlineVariableType + includeInlineVariableType: this._configuration.includeInlineVariableType, + includeInlineNonLiteralParameterName: this._configuration.includeInlineNonLiteralParameterName, + includeInlineDuplicatedParameterName: this._configuration.includeInlineDuplicatedParameterName, + includeInlineRequireAssignedVariableType: this._configuration.includeInlineRequireAssignedVariableType, + includeInlinePropertyDeclarationType: this._configuration.includeInlinePropertyDeclarationType, + includeInlineFunctionLikeReturnType: this._configuration.includeInlineFunctionLikeReturnType, + includeInlineEnumMemberValue: this._configuration.includeInlineEnumMemberValue, }, watchOptions }; diff --git a/extensions/typescript-language-features/src/utils/configuration.ts b/extensions/typescript-language-features/src/utils/configuration.ts index 4027df4e42f12..9cb821043c3e0 100644 --- a/extensions/typescript-language-features/src/utils/configuration.ts +++ b/extensions/typescript-language-features/src/utils/configuration.ts @@ -106,6 +106,12 @@ export class TypeScriptServiceConfiguration { public readonly includeInlineParameterName: boolean | undefined; public readonly includeInlineFunctionParameterType: boolean | undefined; public readonly includeInlineVariableType: boolean | undefined; + public readonly includeInlineNonLiteralParameterName: boolean | undefined; + public readonly includeInlineDuplicatedParameterName: boolean | undefined; + public readonly includeInlineRequireAssignedVariableType: boolean | undefined; + public readonly includeInlinePropertyDeclarationType: boolean | undefined; + public readonly includeInlineFunctionLikeReturnType: boolean | undefined; + public readonly includeInlineEnumMemberValue: boolean | undefined; public static loadFromWorkspace(): TypeScriptServiceConfiguration { return new TypeScriptServiceConfiguration(); @@ -132,6 +138,12 @@ export class TypeScriptServiceConfiguration { this.includeInlineParameterName = TypeScriptServiceConfiguration.readIncludeInlineParameterName(configuration); this.includeInlineFunctionParameterType = TypeScriptServiceConfiguration.readIncludeInlineFunctionParameterType(configuration); this.includeInlineVariableType = TypeScriptServiceConfiguration.readIncludeInlineVariableType(configuration); + this.includeInlineNonLiteralParameterName = TypeScriptServiceConfiguration.readIncludeInlineNonLiteralParameterName(configuration); + this.includeInlineDuplicatedParameterName = TypeScriptServiceConfiguration.readIncludeInlineDuplicatedParameterName(configuration); + this.includeInlineRequireAssignedVariableType = TypeScriptServiceConfiguration.readIncludeInlineRequireAssignedVariableType(configuration); + this.includeInlinePropertyDeclarationType = TypeScriptServiceConfiguration.readIncludeInlinePropertyDeclarationType(configuration); + this.includeInlineFunctionLikeReturnType = TypeScriptServiceConfiguration.readIncludeInlineFunctionLikeReturnType(configuration); + this.includeInlineEnumMemberValue = TypeScriptServiceConfiguration.readIncludeInlineEnumMemberValue(configuration); } public isEqualTo(other: TypeScriptServiceConfiguration): boolean { @@ -234,4 +246,28 @@ export class TypeScriptServiceConfiguration { private static readIncludeInlineVariableType(configuration: vscode.WorkspaceConfiguration): boolean { return configuration.get('typescript.inlineHints.includeInlineVariableType', true); } + + private static readIncludeInlineNonLiteralParameterName(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineNonLiteralParameterName', true); + } + + private static readIncludeInlineDuplicatedParameterName(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineDuplicatedParameterName', true); + } + + private static readIncludeInlineRequireAssignedVariableType(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineRequireAssignedVariableType', true); + } + + private static readIncludeInlinePropertyDeclarationType(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlinePropertyDeclarationType', true); + } + + private static readIncludeInlineFunctionLikeReturnType(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineFunctionLikeReturnType', true); + } + + private static readIncludeInlineEnumMemberValue(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineEnumMemberValue', true); + } } From 5a760dd81641b0c101a9b8633896b5c5954e6035 Mon Sep 17 00:00:00 2001 From: kingwl Date: Wed, 30 Dec 2020 18:02:26 +0800 Subject: [PATCH 04/16] Rename all options --- .../typescript-language-features/package.json | 42 +++++----- .../package.nls.json | 19 ++--- .../fileConfigurationManager.ts | 38 ++++----- .../src/typescriptServiceClient.ts | 38 ++++----- .../src/utils/configuration.ts | 78 ++++++++++--------- 5 files changed, 116 insertions(+), 99 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index 6ee03a6ebbfcd..e75726ff7fb73 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -258,58 +258,64 @@ "description": "%configuration.suggest.includeAutomaticOptionalChainCompletions%", "scope": "resource" }, - "typescript.inlineHints.includeInlineParameterName": { + "typescript.inlineHints.includeInlineParameterNameHints": { "type": "boolean", "default": true, - "description": "%configuration.inlineHints.includeInlineParameterName%", + "description": "%configuration.inlineHints.includeInlineParameterNameHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineFunctionParameterType": { + "typescript.inlineHints.includeInlineFunctionParameterTypeHints": { "type": "boolean", "default": true, - "description": "%configuration.inlineHints.includeInlineFunctionParameterType%", + "description": "%configuration.inlineHints.includeInlineFunctionParameterTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineVariableType": { + "typescript.inlineHints.includeInlineVariableTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineVariableType%", + "description": "%configuration.inlineHints.includeInlineVariableTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineNonLiteralParameterName": { + "typescript.inlineHints.includeInlineNonLiteralParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineNonLiteralParameterName%", + "description": "%configuration.inlineHints.includeInlineNonLiteralParameterNameHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineDuplicatedParameterName": { + "typescript.inlineHints.includeInlineDuplicatedParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineDuplicatedParameterName%", + "description": "%configuration.inlineHints.includeInlineDuplicatedParameterNameHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineRequireAssignedVariableType": { + "typescript.inlineHints.includeInlineRequireAssignedVariableTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineRequireAssignedVariableType%", + "description": "%configuration.inlineHints.includeInlineRequireAssignedVariableTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlinePropertyDeclarationType": { + "typescript.inlineHints.includeInlinePropertyDeclarationTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlinePropertyDeclarationType%", + "description": "%configuration.inlineHints.includeInlinePropertyDeclarationTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineFunctionLikeReturnType": { + "typescript.inlineHints.includeInlineFunctionLikeReturnTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineFunctionLikeReturnType%", + "description": "%configuration.inlineHints.includeInlineFunctionLikeReturnTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineEnumMemberValue": { + "typescript.inlineHints.includeInlineEnumMemberValueHints": { "type": "boolean", "default": true, - "description": "%configuration.inlineHints.includeInlineEnumMemberValue%", + "description": "%configuration.inlineHints.includeInlineEnumMemberValueHints%", + "scope": "resource" + }, + "typescript.inlineHints.includeInlineCallChainsHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineCallChainsHints%", "scope": "resource" }, diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index e51ad3ab13952..292fc683a8acb 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -69,15 +69,16 @@ "configuration.implicitProjectConfig.strictNullChecks": "Enable/disable [strict null checks](https://www.typescriptlang.org/tsconfig#strictNullChecks) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.implicitProjectConfig.strictFunctionTypes": "Enable/disable [strict function types](https://www.typescriptlang.org/tsconfig#strictFunctionTypes) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.suggest.autoImports": "Enable/disable auto import suggestions.", - "configuration.inlineHints.includeInlineParameterName": "Enable/disable inline hints of parameter name.", - "configuration.inlineHints.includeInlineFunctionParameterType": "Enable/disable inline hints of function parameter name.", - "configuration.inlineHints.includeInlineVariableType": "Enable/disable inline hints of variable type.", - "configuration.inlineHints.includeInlineNonLiteralParameterName": "Enable/disable inline hints of non literal argument.", - "configuration.inlineHints.includeInlineDuplicatedParameterName": "Enable/disable inline hints of duplicated argument.", - "configuration.inlineHints.includeInlineRequireAssignedVariableType": "Enable/disable inline hints of require assigned variable.", - "configuration.inlineHints.includeInlinePropertyDeclarationType": "Enable/disable inline hints of property declaration.", - "configuration.inlineHints.includeInlineFunctionLikeReturnType": "Enable/disable inline hints of return type for function like.", - "configuration.inlineHints.includeInlineEnumMemberValue": "Enable/disable inline hints of enum member.", + "configuration.inlineHints.includeInlineParameterNameHints": "Enable/disable inline hints of parameter name.", + "configuration.inlineHints.includeInlineFunctionParameterTypeHints": "Enable/disable inline hints of function parameter name.", + "configuration.inlineHints.includeInlineVariableTypeHints": "Enable/disable inline hints of variable type.", + "configuration.inlineHints.includeInlineNonLiteralParameterNameHints": "Enable/disable inline hints of non literal argument.", + "configuration.inlineHints.includeInlineDuplicatedParameterNameHints": "Enable/disable inline hints of duplicated argument.", + "configuration.inlineHints.includeInlineRequireAssignedVariableTypeHints": "Enable/disable inline hints of require assigned variable.", + "configuration.inlineHints.includeInlinePropertyDeclarationTypeHints": "Enable/disable inline hints of property declaration.", + "configuration.inlineHints.includeInlineFunctionLikeReturnTypeHints": "Enable/disable inline hints of return type for function like.", + "configuration.inlineHints.includeInlineEnumMemberValueHints": "Enable/disable inline hints of enum member.", + "configuration.inlineHints.includeInlineCallChainsHints": "Enable/disable inline hints of call chains.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index 164bed1bd80fc..4873f0f296eb8 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -15,15 +15,16 @@ import { ResourceMap } from '../utils/resourceMap'; namespace ExperimentalProto { export interface UserPreferences extends Proto.UserPreferences { - includeInlineParameterName?: boolean; - includeInlineFunctionParameterType?: boolean; - includeInlineVariableType?: boolean; - includeInlineNonLiteralParameterName?: boolean; - includeInlineDuplicatedParameterName?: boolean; - includeInlineRequireAssignedVariableType?: boolean; - includeInlinePropertyDeclarationType?: boolean; - includeInlineFunctionLikeReturnType?: boolean; - includeInlineEnumMemberValue?: boolean; + includeInlineParameterNameHints?: boolean; + includeInlineFunctionParameterTypeHints?: boolean; + includeInlineVariableTypeHints?: boolean; + includeInlineNonLiteralParameterNameHints?: boolean; + includeInlineDuplicatedParameterNameHints?: boolean; + includeInlineRequireAssignedVariableTypeHints?: boolean; + includeInlinePropertyDeclarationTypeHints?: boolean; + includeInlineFunctionLikeReturnTypeHints?: boolean; + includeInlineEnumMemberValueHints?: boolean; + includeInlineCallChainsHints?: boolean; } } @@ -197,15 +198,16 @@ export default class FileConfigurationManager extends Disposable { allowRenameOfImportPath: true, includeAutomaticOptionalChainCompletions: config.get('suggest.includeAutomaticOptionalChainCompletions', true), provideRefactorNotApplicableReason: true, - includeInlineParameterName: config.get('inlineHints.includeInlineParameterName', true), - includeInlineFunctionParameterType: config.get('inlineHints.includeInlineFunctionParameterType', true), - includeInlineVariableType: config.get('inlineHints.includeInlineVariableType', true), - includeInlineNonLiteralParameterName: config.get('inlineHints.includeInlineNonLiteralParameterName', true), - includeInlineDuplicatedParameterName: config.get('inlineHints.includeInlineDuplicatedParameterName', true), - includeInlineRequireAssignedVariableType: config.get('inlineHints.includeInlineRequireAssignedVariableType', true), - includeInlinePropertyDeclarationType: config.get('inlineHints.includeInlinePropertyDeclarationType', true), - includeInlineFunctionLikeReturnType: config.get('inlineHints.includeInlineFunctionLikeReturnType', true), - includeInlineEnumMemberValue: config.get('inlineHints.includeInlineEnumMemberValue', true), + includeInlineParameterNameHints: config.get('inlineHints.includeInlineParameterName', true), + includeInlineFunctionParameterTypeHints: config.get('inlineHints.includeInlineFunctionParameterType', true), + includeInlineVariableTypeHints: config.get('inlineHints.includeInlineVariableType', true), + includeInlineNonLiteralParameterNameHints: config.get('inlineHints.includeInlineNonLiteralParameterName', true), + includeInlineDuplicatedParameterNameHints: config.get('inlineHints.includeInlineDuplicatedParameterName', true), + includeInlineRequireAssignedVariableTypeHints: config.get('inlineHints.includeInlineRequireAssignedVariableType', true), + includeInlinePropertyDeclarationTypeHints: config.get('inlineHints.includeInlinePropertyDeclarationType', true), + includeInlineFunctionLikeReturnTypeHints: config.get('inlineHints.includeInlineFunctionLikeReturnType', true), + includeInlineEnumMemberValueHints: config.get('inlineHints.includeInlineEnumMemberValue', true), + includeInlineCallChainsHints: config.get('inlineHints.includeInlineCallChainsHints', true) }; return preferences; diff --git a/extensions/typescript-language-features/src/typescriptServiceClient.ts b/extensions/typescript-language-features/src/typescriptServiceClient.ts index 193efe8aade06..90c8062ffad70 100644 --- a/extensions/typescript-language-features/src/typescriptServiceClient.ts +++ b/extensions/typescript-language-features/src/typescriptServiceClient.ts @@ -32,15 +32,16 @@ import { inferredProjectCompilerOptions, ProjectType } from './utils/tsconfig'; namespace ExperimentalProto { export interface UserPreferences extends Proto.UserPreferences { - includeInlineParameterName?: boolean; - includeInlineFunctionParameterType?: boolean; - includeInlineVariableType?: boolean; - includeInlineNonLiteralParameterName?: boolean; - includeInlineDuplicatedParameterName?: boolean; - includeInlineRequireAssignedVariableType?: boolean; - includeInlinePropertyDeclarationType?: boolean; - includeInlineFunctionLikeReturnType?: boolean; - includeInlineEnumMemberValue?: boolean; + includeInlineParameterNameHints?: boolean; + includeInlineFunctionParameterTypeHints?: boolean; + includeInlineVariableTypeHints?: boolean; + includeInlineNonLiteralParameterNameHints?: boolean; + includeInlineDuplicatedParameterNameHints?: boolean; + includeInlineRequireAssignedVariableTypeHints?: boolean; + includeInlinePropertyDeclarationTypeHints?: boolean; + includeInlineFunctionLikeReturnTypeHints?: boolean; + includeInlineEnumMemberValueHints?: boolean; + includeInlineCallChainsHints?: boolean; } export interface ConfigureRequestArguments extends Proto.ConfigureRequestArguments { @@ -553,15 +554,16 @@ export default class TypeScriptServiceClient extends Disposable implements IType providePrefixAndSuffixTextForRename: true, allowRenameOfImportPath: true, includePackageJsonAutoImports: this._configuration.includePackageJsonAutoImports, - includeInlineParameterName: this._configuration.includeInlineParameterName, - includeInlineFunctionParameterType: this._configuration.includeInlineFunctionParameterType, - includeInlineVariableType: this._configuration.includeInlineVariableType, - includeInlineNonLiteralParameterName: this._configuration.includeInlineNonLiteralParameterName, - includeInlineDuplicatedParameterName: this._configuration.includeInlineDuplicatedParameterName, - includeInlineRequireAssignedVariableType: this._configuration.includeInlineRequireAssignedVariableType, - includeInlinePropertyDeclarationType: this._configuration.includeInlinePropertyDeclarationType, - includeInlineFunctionLikeReturnType: this._configuration.includeInlineFunctionLikeReturnType, - includeInlineEnumMemberValue: this._configuration.includeInlineEnumMemberValue, + includeInlineParameterNameHints: this._configuration.includeInlineParameterNameHints, + includeInlineFunctionParameterTypeHints: this._configuration.includeInlineFunctionParameterTypeHints, + includeInlineVariableTypeHints: this._configuration.includeInlineVariableTypeHints, + includeInlineNonLiteralParameterNameHints: this._configuration.includeInlineNonLiteralParameterNameHints, + includeInlineDuplicatedParameterNameHints: this._configuration.includeInlineDuplicatedParameterNameHints, + includeInlineRequireAssignedVariableTypeHints: this._configuration.includeInlineRequireAssignedVariableTypeHints, + includeInlinePropertyDeclarationTypeHints: this._configuration.includeInlinePropertyDeclarationTypeHints, + includeInlineFunctionLikeReturnTypeHints: this._configuration.includeInlineFunctionLikeReturnTypeHints, + includeInlineEnumMemberValueHints: this._configuration.includeInlineEnumMemberValueHints, + includeInlineCallChainsHints: this._configuration.includeInlineCallChainsHints }, watchOptions }; diff --git a/extensions/typescript-language-features/src/utils/configuration.ts b/extensions/typescript-language-features/src/utils/configuration.ts index 9cb821043c3e0..5203af4ffb513 100644 --- a/extensions/typescript-language-features/src/utils/configuration.ts +++ b/extensions/typescript-language-features/src/utils/configuration.ts @@ -103,15 +103,16 @@ export class TypeScriptServiceConfiguration { public readonly watchOptions: protocol.WatchOptions | undefined; public readonly includePackageJsonAutoImports: 'auto' | 'on' | 'off' | undefined; public readonly enableTsServerTracing: boolean; - public readonly includeInlineParameterName: boolean | undefined; - public readonly includeInlineFunctionParameterType: boolean | undefined; - public readonly includeInlineVariableType: boolean | undefined; - public readonly includeInlineNonLiteralParameterName: boolean | undefined; - public readonly includeInlineDuplicatedParameterName: boolean | undefined; - public readonly includeInlineRequireAssignedVariableType: boolean | undefined; - public readonly includeInlinePropertyDeclarationType: boolean | undefined; - public readonly includeInlineFunctionLikeReturnType: boolean | undefined; - public readonly includeInlineEnumMemberValue: boolean | undefined; + public readonly includeInlineParameterNameHints: boolean | undefined; + public readonly includeInlineFunctionParameterTypeHints: boolean | undefined; + public readonly includeInlineVariableTypeHints: boolean | undefined; + public readonly includeInlineNonLiteralParameterNameHints: boolean | undefined; + public readonly includeInlineDuplicatedParameterNameHints: boolean | undefined; + public readonly includeInlineRequireAssignedVariableTypeHints: boolean | undefined; + public readonly includeInlinePropertyDeclarationTypeHints: boolean | undefined; + public readonly includeInlineFunctionLikeReturnTypeHints: boolean | undefined; + public readonly includeInlineEnumMemberValueHints: boolean | undefined; + public readonly includeInlineCallChainsHints: boolean | undefined; public static loadFromWorkspace(): TypeScriptServiceConfiguration { return new TypeScriptServiceConfiguration(); @@ -135,15 +136,16 @@ export class TypeScriptServiceConfiguration { this.watchOptions = TypeScriptServiceConfiguration.readWatchOptions(configuration); this.includePackageJsonAutoImports = TypeScriptServiceConfiguration.readIncludePackageJsonAutoImports(configuration); this.enableTsServerTracing = TypeScriptServiceConfiguration.readEnableTsServerTracing(configuration); - this.includeInlineParameterName = TypeScriptServiceConfiguration.readIncludeInlineParameterName(configuration); - this.includeInlineFunctionParameterType = TypeScriptServiceConfiguration.readIncludeInlineFunctionParameterType(configuration); - this.includeInlineVariableType = TypeScriptServiceConfiguration.readIncludeInlineVariableType(configuration); - this.includeInlineNonLiteralParameterName = TypeScriptServiceConfiguration.readIncludeInlineNonLiteralParameterName(configuration); - this.includeInlineDuplicatedParameterName = TypeScriptServiceConfiguration.readIncludeInlineDuplicatedParameterName(configuration); - this.includeInlineRequireAssignedVariableType = TypeScriptServiceConfiguration.readIncludeInlineRequireAssignedVariableType(configuration); - this.includeInlinePropertyDeclarationType = TypeScriptServiceConfiguration.readIncludeInlinePropertyDeclarationType(configuration); - this.includeInlineFunctionLikeReturnType = TypeScriptServiceConfiguration.readIncludeInlineFunctionLikeReturnType(configuration); - this.includeInlineEnumMemberValue = TypeScriptServiceConfiguration.readIncludeInlineEnumMemberValue(configuration); + this.includeInlineParameterNameHints = TypeScriptServiceConfiguration.readIncludeInlineParameterNameHints(configuration); + this.includeInlineFunctionParameterTypeHints = TypeScriptServiceConfiguration.readIncludeInlineFunctionParameterTypeHints(configuration); + this.includeInlineVariableTypeHints = TypeScriptServiceConfiguration.readIncludeInlineVariableTypeHints(configuration); + this.includeInlineNonLiteralParameterNameHints = TypeScriptServiceConfiguration.readIncludeInlineNonLiteralParameterNameHints(configuration); + this.includeInlineDuplicatedParameterNameHints = TypeScriptServiceConfiguration.readIncludeInlineDuplicatedParameterNameHints(configuration); + this.includeInlineRequireAssignedVariableTypeHints = TypeScriptServiceConfiguration.readIncludeInlineRequireAssignedVariableTypeHints(configuration); + this.includeInlinePropertyDeclarationTypeHints = TypeScriptServiceConfiguration.readIncludeInlinePropertyDeclarationTypeHints(configuration); + this.includeInlineFunctionLikeReturnTypeHints = TypeScriptServiceConfiguration.readIncludeInlineFunctionLikeReturnTypeHints(configuration); + this.includeInlineEnumMemberValueHints = TypeScriptServiceConfiguration.readIncludeInlineEnumMemberValueHints(configuration); + this.includeInlineCallChainsHints = TypeScriptServiceConfiguration.readIncludeInlineCallChainsHints(configuration); } public isEqualTo(other: TypeScriptServiceConfiguration): boolean { @@ -235,39 +237,43 @@ export class TypeScriptServiceConfiguration { return configuration.get('typescript.tsserver.enableTracing', false); } - private static readIncludeInlineParameterName(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineParameterName', true); + private static readIncludeInlineParameterNameHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineParameterNameHints', true); } - private static readIncludeInlineFunctionParameterType(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineFunctionParameterType', true); + private static readIncludeInlineFunctionParameterTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineFunctionParameterTypeHints', true); } - private static readIncludeInlineVariableType(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineVariableType', true); + private static readIncludeInlineVariableTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineVariableTypeHints', false); } - private static readIncludeInlineNonLiteralParameterName(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineNonLiteralParameterName', true); + private static readIncludeInlineNonLiteralParameterNameHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineNonLiteralParameterNameHints', false); } - private static readIncludeInlineDuplicatedParameterName(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineDuplicatedParameterName', true); + private static readIncludeInlineDuplicatedParameterNameHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineDuplicatedParameterNameHints', false); } - private static readIncludeInlineRequireAssignedVariableType(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineRequireAssignedVariableType', true); + private static readIncludeInlineRequireAssignedVariableTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineRequireAssignedVariableTypeHints', false); } - private static readIncludeInlinePropertyDeclarationType(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlinePropertyDeclarationType', true); + private static readIncludeInlinePropertyDeclarationTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlinePropertyDeclarationTypeHints', false); } - private static readIncludeInlineFunctionLikeReturnType(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineFunctionLikeReturnType', true); + private static readIncludeInlineFunctionLikeReturnTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineFunctionLikeReturnTypeHints', false); } - private static readIncludeInlineEnumMemberValue(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineEnumMemberValue', true); + private static readIncludeInlineEnumMemberValueHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineEnumMemberValueHints', true); + } + + private static readIncludeInlineCallChainsHints(configuration: vscode.WorkspaceConfiguration): boolean { + return configuration.get('typescript.inlineHints.includeInlineCallChainsHints', false); } } From 3944756c388e048cccb8b0911a83e47080f78a0a Mon Sep 17 00:00:00 2001 From: kingwl Date: Wed, 13 Jan 2021 20:56:40 +0800 Subject: [PATCH 05/16] Support range --- .../src/languageFeatures/inlineHints.ts | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts index ce634866951cf..13849cbc93709 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts @@ -8,7 +8,7 @@ import * as Proto from '../protocol'; import { DocumentSelector } from '../utils/documentSelector'; import { ClientCapability, ITypeScriptServiceClient, ServerResponse, ExecConfig } from '../typescriptService'; import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration'; -import { Position } from '../utils/typeConverters'; +import { Range } from '../utils/typeConverters'; namespace ExperimentalProto { export const enum CommandTypes { @@ -33,7 +33,7 @@ namespace ExperimentalProto { interface HintItem { text: string; - position: Proto.Location; + range: Proto.TextSpan; whitespaceBefore?: boolean; whitespaceAfter?: boolean; } @@ -77,7 +77,7 @@ class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { } return response.body.map(hint => { - return new vscode.InlineHint(hint.text, Position.fromLocation(hint.position), hint.whitespaceBefore, hint.whitespaceAfter); + return new vscode.InlineHint(hint.text, Range.fromTextSpan(hint.range), hint.whitespaceBefore, hint.whitespaceAfter); }); } catch (e) { return []; From 396dbbb9427a9b11d02742fdb145ac4f73c3d25b Mon Sep 17 00:00:00 2001 From: kingwl Date: Tue, 19 Jan 2021 17:14:33 +0800 Subject: [PATCH 06/16] use new interface --- .../src/languageFeatures/inlineHints.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts index 13849cbc93709..a97c31073e4ab 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts @@ -34,6 +34,7 @@ namespace ExperimentalProto { interface HintItem { text: string; range: Proto.TextSpan; + hoverMessage?: string; whitespaceBefore?: boolean; whitespaceAfter?: boolean; } @@ -77,7 +78,7 @@ class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { } return response.body.map(hint => { - return new vscode.InlineHint(hint.text, Range.fromTextSpan(hint.range), hint.whitespaceBefore, hint.whitespaceAfter); + return new vscode.InlineHint(hint.text, Range.fromTextSpan(hint.range), hint.hoverMessage, hint.whitespaceBefore, hint.whitespaceAfter); }); } catch (e) { return []; From 66ff1fa83bda44286180066f6e19cd1b1e0c0c5b Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Wed, 20 Jan 2021 13:14:34 +0800 Subject: [PATCH 07/16] Fix cr issues --- .../typescript-language-features/package.json | 66 ++++++++++++++++++- .../fileConfigurationManager.ts | 26 +++++--- .../src/languageFeatures/inlineHints.ts | 42 ++++++++---- .../src/languageProvider.ts | 2 +- .../src/typescriptServiceClient.ts | 10 --- .../src/utils/api.ts | 1 + .../src/utils/configuration.ts | 60 ----------------- 7 files changed, 109 insertions(+), 98 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index e75726ff7fb73..f863f9e2e024b 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -260,13 +260,13 @@ }, "typescript.inlineHints.includeInlineParameterNameHints": { "type": "boolean", - "default": true, + "default": false, "description": "%configuration.inlineHints.includeInlineParameterNameHints%", "scope": "resource" }, "typescript.inlineHints.includeInlineFunctionParameterTypeHints": { "type": "boolean", - "default": true, + "default": false, "description": "%configuration.inlineHints.includeInlineFunctionParameterTypeHints%", "scope": "resource" }, @@ -308,7 +308,7 @@ }, "typescript.inlineHints.includeInlineEnumMemberValueHints": { "type": "boolean", - "default": true, + "default": false, "description": "%configuration.inlineHints.includeInlineEnumMemberValueHints%", "scope": "resource" }, @@ -318,6 +318,66 @@ "description": "%configuration.inlineHints.includeInlineCallChainsHints%", "scope": "resource" }, + "javascript.inlineHints.includeInlineParameterNameHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineParameterNameHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineFunctionParameterTypeHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineFunctionParameterTypeHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineVariableTypeHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineVariableTypeHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineNonLiteralParameterNameHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineNonLiteralParameterNameHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineDuplicatedParameterNameHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineDuplicatedParameterNameHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineRequireAssignedVariableTypeHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineRequireAssignedVariableTypeHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlinePropertyDeclarationTypeHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlinePropertyDeclarationTypeHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineFunctionLikeReturnTypeHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineFunctionLikeReturnTypeHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineEnumMemberValueHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineEnumMemberValueHints%", + "scope": "resource" + }, + "javascript.inlineHints.includeInlineCallChainsHints": { + "type": "boolean", + "default": false, + "description": "%configuration.inlineHints.includeInlineCallChainsHints%", + "scope": "resource" + }, "typescript.reportStyleChecksAsWarnings": { "type": "boolean", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index 4873f0f296eb8..922c77eed9cc6 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -198,16 +198,7 @@ export default class FileConfigurationManager extends Disposable { allowRenameOfImportPath: true, includeAutomaticOptionalChainCompletions: config.get('suggest.includeAutomaticOptionalChainCompletions', true), provideRefactorNotApplicableReason: true, - includeInlineParameterNameHints: config.get('inlineHints.includeInlineParameterName', true), - includeInlineFunctionParameterTypeHints: config.get('inlineHints.includeInlineFunctionParameterType', true), - includeInlineVariableTypeHints: config.get('inlineHints.includeInlineVariableType', true), - includeInlineNonLiteralParameterNameHints: config.get('inlineHints.includeInlineNonLiteralParameterName', true), - includeInlineDuplicatedParameterNameHints: config.get('inlineHints.includeInlineDuplicatedParameterName', true), - includeInlineRequireAssignedVariableTypeHints: config.get('inlineHints.includeInlineRequireAssignedVariableType', true), - includeInlinePropertyDeclarationTypeHints: config.get('inlineHints.includeInlinePropertyDeclarationType', true), - includeInlineFunctionLikeReturnTypeHints: config.get('inlineHints.includeInlineFunctionLikeReturnType', true), - includeInlineEnumMemberValueHints: config.get('inlineHints.includeInlineEnumMemberValue', true), - includeInlineCallChainsHints: config.get('inlineHints.includeInlineCallChainsHints', true) + ...getInlineHintsPreferences(config) }; return preferences; @@ -222,6 +213,21 @@ export default class FileConfigurationManager extends Disposable { } } +export function getInlineHintsPreferences(config: vscode.WorkspaceConfiguration) { + return { + includeInlineParameterNameHints: config.get('inlineHints.includeInlineParameterNameHints', false), + includeInlineFunctionParameterTypeHints: config.get('inlineHints.includeInlineFunctionParameterTypeHints', false), + includeInlineVariableTypeHints: config.get('inlineHints.includeInlineVariableTypeHints', false), + includeInlineNonLiteralParameterNameHints: config.get('inlineHints.includeInlineNonLiteralParameterNameHints', false), + includeInlineDuplicatedParameterNameHints: config.get('inlineHints.includeInlineDuplicatedParameterNameHints', false), + includeInlineRequireAssignedVariableTypeHints: config.get('inlineHints.includeInlineRequireAssignedVariableTypeHints', false), + includeInlinePropertyDeclarationTypeHints: config.get('inlineHints.includeInlinePropertyDeclarationTypeHints', false), + includeInlineFunctionLikeReturnTypeHints: config.get('inlineHints.includeInlineFunctionLikeReturnTypeHints', false), + includeInlineEnumMemberValueHints: config.get('inlineHints.includeInlineEnumMemberValueHints', false), + includeInlineCallChainsHints: config.get('inlineHints.includeInlineCallChainsHints', false) + }; +} + function getImportModuleSpecifierPreference(config: vscode.WorkspaceConfiguration) { switch (config.get('importModuleSpecifier')) { case 'project-relative': return 'project-relative'; diff --git a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts index a97c31073e4ab..c41a9e5d74491 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts @@ -7,8 +7,11 @@ import * as vscode from 'vscode'; import * as Proto from '../protocol'; import { DocumentSelector } from '../utils/documentSelector'; import { ClientCapability, ITypeScriptServiceClient, ServerResponse, ExecConfig } from '../typescriptService'; -import { conditionalRegistration, requireSomeCapability } from '../utils/dependentRegistration'; +import { conditionalRegistration, requireMinVersion, requireSomeCapability } from '../utils/dependentRegistration'; import { Range } from '../utils/typeConverters'; +import FileConfigurationManager, { getInlineHintsPreferences } from './fileConfigurationManager'; +import API from '../utils/api'; +import { isTypeScriptDocument } from '../utils/languageModeIds'; namespace ExperimentalProto { export const enum CommandTypes { @@ -58,8 +61,11 @@ namespace ExperimentalProto { } class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { + public static readonly minVersion = API.v420; + constructor( - private readonly client: ITypeScriptServiceClient + private readonly client: ITypeScriptServiceClient, + private readonly fileConfigurationManager: FileConfigurationManager ) { } async provideInlineHints(model: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): Promise { @@ -68,32 +74,40 @@ class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { return []; } + await this.fileConfigurationManager.ensureConfigurationForDocument(model, token); + + if (!this.someInlineHintsEnabled(model)) { + return []; + } + const start = model.offsetAt(range.start); const length = model.offsetAt(range.end) - start; - try { - const response = await (this.client as ExperimentalProto.IExtendedTypeScriptServiceClient).execute('provideInlineHints', { file: filepath, start, length }, token); - if (response.type !== 'response' || !response.success || !response.body) { - return []; - } - - return response.body.map(hint => { - return new vscode.InlineHint(hint.text, Range.fromTextSpan(hint.range), hint.hoverMessage, hint.whitespaceBefore, hint.whitespaceAfter); - }); - } catch (e) { + const response = await (this.client as ExperimentalProto.IExtendedTypeScriptServiceClient).execute('provideInlineHints', { file: filepath, start, length }, token); + if (response.type !== 'response' || !response.success || !response.body) { return []; } + + return response.body.map(hint => new vscode.InlineHint(hint.text, Range.fromTextSpan(hint.range), hint.hoverMessage, hint.whitespaceBefore, hint.whitespaceAfter)); + } + + private someInlineHintsEnabled(model: vscode.TextDocument) { + const config = vscode.workspace.getConfiguration(isTypeScriptDocument(model) ? 'typescript' : 'javascript', model.uri); + const preferences = getInlineHintsPreferences(config); + return Object.values(preferences).some(Boolean); } } export function register( selector: DocumentSelector, - client: ITypeScriptServiceClient + client: ITypeScriptServiceClient, + fileConfigurationManager: FileConfigurationManager ) { return conditionalRegistration([ + requireMinVersion(client, TypeScriptInlineHintsProvider.minVersion), requireSomeCapability(client, ClientCapability.Semantic), ], () => { return vscode.languages.registerInlineHintsProvider(selector.semantic, - new TypeScriptInlineHintsProvider(client)); + new TypeScriptInlineHintsProvider(client, fileConfigurationManager)); }); } diff --git a/extensions/typescript-language-features/src/languageProvider.ts b/extensions/typescript-language-features/src/languageProvider.ts index ffc4aa950dd55..49461f7f3ef3e 100644 --- a/extensions/typescript-language-features/src/languageProvider.ts +++ b/extensions/typescript-language-features/src/languageProvider.ts @@ -83,7 +83,7 @@ export default class LanguageProvider extends Disposable { import('./languageFeatures/smartSelect').then(provider => this._register(provider.register(selector, this.client))), import('./languageFeatures/tagClosing').then(provider => this._register(provider.register(selector, this.description.id, this.client))), import('./languageFeatures/typeDefinitions').then(provider => this._register(provider.register(selector, this.client))), - import('./languageFeatures/inlineHints').then(provider => this._register(provider.register(selector, this.client))), + import('./languageFeatures/inlineHints').then(provider => this._register(provider.register(selector, this.client, this.fileConfigurationManager))), ]); } diff --git a/extensions/typescript-language-features/src/typescriptServiceClient.ts b/extensions/typescript-language-features/src/typescriptServiceClient.ts index 90c8062ffad70..623f0d4c5a590 100644 --- a/extensions/typescript-language-features/src/typescriptServiceClient.ts +++ b/extensions/typescript-language-features/src/typescriptServiceClient.ts @@ -554,16 +554,6 @@ export default class TypeScriptServiceClient extends Disposable implements IType providePrefixAndSuffixTextForRename: true, allowRenameOfImportPath: true, includePackageJsonAutoImports: this._configuration.includePackageJsonAutoImports, - includeInlineParameterNameHints: this._configuration.includeInlineParameterNameHints, - includeInlineFunctionParameterTypeHints: this._configuration.includeInlineFunctionParameterTypeHints, - includeInlineVariableTypeHints: this._configuration.includeInlineVariableTypeHints, - includeInlineNonLiteralParameterNameHints: this._configuration.includeInlineNonLiteralParameterNameHints, - includeInlineDuplicatedParameterNameHints: this._configuration.includeInlineDuplicatedParameterNameHints, - includeInlineRequireAssignedVariableTypeHints: this._configuration.includeInlineRequireAssignedVariableTypeHints, - includeInlinePropertyDeclarationTypeHints: this._configuration.includeInlinePropertyDeclarationTypeHints, - includeInlineFunctionLikeReturnTypeHints: this._configuration.includeInlineFunctionLikeReturnTypeHints, - includeInlineEnumMemberValueHints: this._configuration.includeInlineEnumMemberValueHints, - includeInlineCallChainsHints: this._configuration.includeInlineCallChainsHints }, watchOptions }; diff --git a/extensions/typescript-language-features/src/utils/api.ts b/extensions/typescript-language-features/src/utils/api.ts index 2282791a9ddbf..5ff6572be29fb 100644 --- a/extensions/typescript-language-features/src/utils/api.ts +++ b/extensions/typescript-language-features/src/utils/api.ts @@ -35,6 +35,7 @@ export default class API { public static readonly v400 = API.fromSimpleString('4.0.0'); public static readonly v401 = API.fromSimpleString('4.0.1'); public static readonly v420 = API.fromSimpleString('4.2.0'); + public static readonly v430 = API.fromSimpleString('4.3.0'); public static fromVersionString(versionString: string): API { let version = semver.valid(versionString); diff --git a/extensions/typescript-language-features/src/utils/configuration.ts b/extensions/typescript-language-features/src/utils/configuration.ts index 5203af4ffb513..c43a121079cb1 100644 --- a/extensions/typescript-language-features/src/utils/configuration.ts +++ b/extensions/typescript-language-features/src/utils/configuration.ts @@ -103,16 +103,6 @@ export class TypeScriptServiceConfiguration { public readonly watchOptions: protocol.WatchOptions | undefined; public readonly includePackageJsonAutoImports: 'auto' | 'on' | 'off' | undefined; public readonly enableTsServerTracing: boolean; - public readonly includeInlineParameterNameHints: boolean | undefined; - public readonly includeInlineFunctionParameterTypeHints: boolean | undefined; - public readonly includeInlineVariableTypeHints: boolean | undefined; - public readonly includeInlineNonLiteralParameterNameHints: boolean | undefined; - public readonly includeInlineDuplicatedParameterNameHints: boolean | undefined; - public readonly includeInlineRequireAssignedVariableTypeHints: boolean | undefined; - public readonly includeInlinePropertyDeclarationTypeHints: boolean | undefined; - public readonly includeInlineFunctionLikeReturnTypeHints: boolean | undefined; - public readonly includeInlineEnumMemberValueHints: boolean | undefined; - public readonly includeInlineCallChainsHints: boolean | undefined; public static loadFromWorkspace(): TypeScriptServiceConfiguration { return new TypeScriptServiceConfiguration(); @@ -136,16 +126,6 @@ export class TypeScriptServiceConfiguration { this.watchOptions = TypeScriptServiceConfiguration.readWatchOptions(configuration); this.includePackageJsonAutoImports = TypeScriptServiceConfiguration.readIncludePackageJsonAutoImports(configuration); this.enableTsServerTracing = TypeScriptServiceConfiguration.readEnableTsServerTracing(configuration); - this.includeInlineParameterNameHints = TypeScriptServiceConfiguration.readIncludeInlineParameterNameHints(configuration); - this.includeInlineFunctionParameterTypeHints = TypeScriptServiceConfiguration.readIncludeInlineFunctionParameterTypeHints(configuration); - this.includeInlineVariableTypeHints = TypeScriptServiceConfiguration.readIncludeInlineVariableTypeHints(configuration); - this.includeInlineNonLiteralParameterNameHints = TypeScriptServiceConfiguration.readIncludeInlineNonLiteralParameterNameHints(configuration); - this.includeInlineDuplicatedParameterNameHints = TypeScriptServiceConfiguration.readIncludeInlineDuplicatedParameterNameHints(configuration); - this.includeInlineRequireAssignedVariableTypeHints = TypeScriptServiceConfiguration.readIncludeInlineRequireAssignedVariableTypeHints(configuration); - this.includeInlinePropertyDeclarationTypeHints = TypeScriptServiceConfiguration.readIncludeInlinePropertyDeclarationTypeHints(configuration); - this.includeInlineFunctionLikeReturnTypeHints = TypeScriptServiceConfiguration.readIncludeInlineFunctionLikeReturnTypeHints(configuration); - this.includeInlineEnumMemberValueHints = TypeScriptServiceConfiguration.readIncludeInlineEnumMemberValueHints(configuration); - this.includeInlineCallChainsHints = TypeScriptServiceConfiguration.readIncludeInlineCallChainsHints(configuration); } public isEqualTo(other: TypeScriptServiceConfiguration): boolean { @@ -236,44 +216,4 @@ export class TypeScriptServiceConfiguration { private static readEnableTsServerTracing(configuration: vscode.WorkspaceConfiguration): boolean { return configuration.get('typescript.tsserver.enableTracing', false); } - - private static readIncludeInlineParameterNameHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineParameterNameHints', true); - } - - private static readIncludeInlineFunctionParameterTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineFunctionParameterTypeHints', true); - } - - private static readIncludeInlineVariableTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineVariableTypeHints', false); - } - - private static readIncludeInlineNonLiteralParameterNameHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineNonLiteralParameterNameHints', false); - } - - private static readIncludeInlineDuplicatedParameterNameHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineDuplicatedParameterNameHints', false); - } - - private static readIncludeInlineRequireAssignedVariableTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineRequireAssignedVariableTypeHints', false); - } - - private static readIncludeInlinePropertyDeclarationTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlinePropertyDeclarationTypeHints', false); - } - - private static readIncludeInlineFunctionLikeReturnTypeHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineFunctionLikeReturnTypeHints', false); - } - - private static readIncludeInlineEnumMemberValueHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineEnumMemberValueHints', true); - } - - private static readIncludeInlineCallChainsHints(configuration: vscode.WorkspaceConfiguration): boolean { - return configuration.get('typescript.inlineHints.includeInlineCallChainsHints', false); - } } From 7b0cb491c6bbea75ca6a5aab15e249bdf49af3b8 Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Thu, 3 Jun 2021 14:04:28 +0800 Subject: [PATCH 08/16] Update inlay hints for ts plugin --- .../typescript-language-features/package.json | 80 +++++++++---------- .../package.nls.json | 20 ++--- .../fileConfigurationManager.ts | 44 +++++----- .../{inlineHints.ts => inlayHints.ts} | 55 ++++++++----- .../src/languageProvider.ts | 2 +- .../src/utils/api.ts | 1 + 6 files changed, 107 insertions(+), 95 deletions(-) rename extensions/typescript-language-features/src/languageFeatures/{inlineHints.ts => inlayHints.ts} (61%) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index 0f1e336882442..0456f0d1cf7cf 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -270,124 +270,124 @@ "description": "%configuration.suggest.includeAutomaticOptionalChainCompletions%", "scope": "resource" }, - "typescript.inlineHints.includeInlineParameterNameHints": { + "typescript.inlayHints.includeInlayParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayParameterNameHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineFunctionParameterTypeHints": { + "typescript.inlayHints.includeInlayFunctionParameterTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineFunctionParameterTypeHints%", + "description": "%configuration.inlayHints.includeInlayFunctionParameterTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineVariableTypeHints": { + "typescript.inlayHints.includeInlayVariableTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineVariableTypeHints%", + "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineNonLiteralParameterNameHints": { + "typescript.inlayHints.includeInlayNonLiteralParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineNonLiteralParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayNonLiteralParameterNameHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineDuplicatedParameterNameHints": { + "typescript.inlayHints.includeInlayDuplicatedParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineDuplicatedParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayDuplicatedParameterNameHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineRequireAssignedVariableTypeHints": { + "typescript.inlayHints.includeInlayRequireAssignedVariableTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineRequireAssignedVariableTypeHints%", + "description": "%configuration.inlayHints.includeInlayRequireAssignedVariableTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlinePropertyDeclarationTypeHints": { + "typescript.inlayHints.includeInlayPropertyDeclarationTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlinePropertyDeclarationTypeHints%", + "description": "%configuration.inlayHints.includeInlayPropertyDeclarationTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineFunctionLikeReturnTypeHints": { + "typescript.inlayHints.includeInlayFunctionLikeReturnTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineFunctionLikeReturnTypeHints%", + "description": "%configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineEnumMemberValueHints": { + "typescript.inlayHints.includeInlayEnumMemberValueHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineEnumMemberValueHints%", + "description": "%configuration.inlayHints.includeInlayEnumMemberValueHints%", "scope": "resource" }, - "typescript.inlineHints.includeInlineCallChainsHints": { + "typescript.inlayHints.includeInlayCallChainsHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineCallChainsHints%", + "description": "%configuration.inlayHints.includeInlayCallChainsHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineParameterNameHints": { + "javascript.inlayHints.includeInlayParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayParameterNameHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineFunctionParameterTypeHints": { + "javascript.inlayHints.includeInlayFunctionParameterTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineFunctionParameterTypeHints%", + "description": "%configuration.inlayHints.includeInlayFunctionParameterTypeHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineVariableTypeHints": { + "javascript.inlayHints.includeInlayVariableTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineVariableTypeHints%", + "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineNonLiteralParameterNameHints": { + "javascript.inlayHints.includeInlayNonLiteralParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineNonLiteralParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayNonLiteralParameterNameHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineDuplicatedParameterNameHints": { + "javascript.inlayHints.includeInlayDuplicatedParameterNameHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineDuplicatedParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayDuplicatedParameterNameHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineRequireAssignedVariableTypeHints": { + "javascript.inlayHints.includeInlayRequireAssignedVariableTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineRequireAssignedVariableTypeHints%", + "description": "%configuration.inlayHints.includeInlayRequireAssignedVariableTypeHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlinePropertyDeclarationTypeHints": { + "javascript.inlayHints.includeInlayPropertyDeclarationTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlinePropertyDeclarationTypeHints%", + "description": "%configuration.inlayHints.includeInlayPropertyDeclarationTypeHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineFunctionLikeReturnTypeHints": { + "javascript.inlayHints.includeInlayFunctionLikeReturnTypeHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineFunctionLikeReturnTypeHints%", + "description": "%configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineEnumMemberValueHints": { + "javascript.inlayHints.includeInlayEnumMemberValueHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineEnumMemberValueHints%", + "description": "%configuration.inlayHints.includeInlayEnumMemberValueHints%", "scope": "resource" }, - "javascript.inlineHints.includeInlineCallChainsHints": { + "javascript.inlayHints.includeInlayCallChainsHints": { "type": "boolean", "default": false, - "description": "%configuration.inlineHints.includeInlineCallChainsHints%", + "description": "%configuration.inlayHints.includeInlayCallChainsHints%", "scope": "resource" }, "javascript.suggest.includeCompletionsForImportStatements": { diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index 7e88eb8126ab0..f6f26ded083cd 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -74,16 +74,16 @@ "configuration.implicitProjectConfig.strictFunctionTypes": "Enable/disable [strict function types](https://www.typescriptlang.org/tsconfig#strictFunctionTypes) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.suggest.jsdoc.generateReturns": "Enable/disable generating `@return` annotations for JSDoc templates. Requires using TypeScript 4.2+ in the workspace.", "configuration.suggest.autoImports": "Enable/disable auto import suggestions.", - "configuration.inlineHints.includeInlineParameterNameHints": "Enable/disable inline hints of parameter name.", - "configuration.inlineHints.includeInlineFunctionParameterTypeHints": "Enable/disable inline hints of function parameter name.", - "configuration.inlineHints.includeInlineVariableTypeHints": "Enable/disable inline hints of variable type.", - "configuration.inlineHints.includeInlineNonLiteralParameterNameHints": "Enable/disable inline hints of non literal argument.", - "configuration.inlineHints.includeInlineDuplicatedParameterNameHints": "Enable/disable inline hints of duplicated argument.", - "configuration.inlineHints.includeInlineRequireAssignedVariableTypeHints": "Enable/disable inline hints of require assigned variable.", - "configuration.inlineHints.includeInlinePropertyDeclarationTypeHints": "Enable/disable inline hints of property declaration.", - "configuration.inlineHints.includeInlineFunctionLikeReturnTypeHints": "Enable/disable inline hints of return type for function like.", - "configuration.inlineHints.includeInlineEnumMemberValueHints": "Enable/disable inline hints of enum member.", - "configuration.inlineHints.includeInlineCallChainsHints": "Enable/disable inline hints of call chains.", + "configuration.inlayHints.includeInlayParameterNameHints": "Enable/disable inlay hints of parameter name.", + "configuration.inlayHints.includeInlayFunctionParameterTypeHints": "Enable/disable inlay hints of function parameter name.", + "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable type.", + "configuration.inlayHints.includeInlayNonLiteralParameterNameHints": "Enable/disable inlay hints of non literal argument.", + "configuration.inlayHints.includeInlayDuplicatedParameterNameHints": "Enable/disable inlay hints of duplicated argument.", + "configuration.inlayHints.includeInlayRequireAssignedVariableTypeHints": "Enable/disable inlay hints of require assigned variable.", + "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declaration.", + "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function like.", + "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member.", + "configuration.inlayHints.includeInlayCallChainsHints": "Enable/disable inlay hints of call chains.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index fb205d8626e26..c573d205dd3b9 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -17,16 +17,16 @@ namespace ExperimentalProto { export interface UserPreferences extends Proto.UserPreferences { displayPartsForJSDoc: true - includeInlineParameterNameHints?: boolean; - includeInlineFunctionParameterTypeHints?: boolean; - includeInlineVariableTypeHints?: boolean; - includeInlineNonLiteralParameterNameHints?: boolean; - includeInlineDuplicatedParameterNameHints?: boolean; - includeInlineRequireAssignedVariableTypeHints?: boolean; - includeInlinePropertyDeclarationTypeHints?: boolean; - includeInlineFunctionLikeReturnTypeHints?: boolean; - includeInlineEnumMemberValueHints?: boolean; - includeInlineCallChainsHints?: boolean; + includeInlayParameterNameHints?: boolean; + includeInlayFunctionParameterTypeHints?: boolean; + includeInlayVariableTypeHints?: boolean; + includeInlayNonLiteralParameterNameHints?: boolean; + includeInlayDuplicatedParameterNameHints?: boolean; + includeInlayRequireAssignedVariableTypeHints?: boolean; + includeInlayPropertyDeclarationTypeHints?: boolean; + includeInlayFunctionLikeReturnTypeHints?: boolean; + includeInlayEnumMemberValueHints?: boolean; + includeInlayCallChainsHints?: boolean; } } @@ -203,7 +203,7 @@ export default class FileConfigurationManager extends Disposable { includeCompletionsForImportStatements: config.get('suggest.includeCompletionsForImportStatements', true), includeCompletionsWithSnippetText: config.get('suggest.includeCompletionsWithSnippetText', true), displayPartsForJSDoc: true, - ...getInlineHintsPreferences(config), + ...getInlayHintsPreferences(config), }; return preferences; @@ -218,18 +218,18 @@ export default class FileConfigurationManager extends Disposable { } } -export function getInlineHintsPreferences(config: vscode.WorkspaceConfiguration) { +export function getInlayHintsPreferences(config: vscode.WorkspaceConfiguration) { return { - includeInlineParameterNameHints: config.get('inlineHints.includeInlineParameterNameHints', false), - includeInlineFunctionParameterTypeHints: config.get('inlineHints.includeInlineFunctionParameterTypeHints', false), - includeInlineVariableTypeHints: config.get('inlineHints.includeInlineVariableTypeHints', false), - includeInlineNonLiteralParameterNameHints: config.get('inlineHints.includeInlineNonLiteralParameterNameHints', false), - includeInlineDuplicatedParameterNameHints: config.get('inlineHints.includeInlineDuplicatedParameterNameHints', false), - includeInlineRequireAssignedVariableTypeHints: config.get('inlineHints.includeInlineRequireAssignedVariableTypeHints', false), - includeInlinePropertyDeclarationTypeHints: config.get('inlineHints.includeInlinePropertyDeclarationTypeHints', false), - includeInlineFunctionLikeReturnTypeHints: config.get('inlineHints.includeInlineFunctionLikeReturnTypeHints', false), - includeInlineEnumMemberValueHints: config.get('inlineHints.includeInlineEnumMemberValueHints', false), - includeInlineCallChainsHints: config.get('inlineHints.includeInlineCallChainsHints', false) + includeInlayParameterNameHints: config.get('inlayHints.includeInlayParameterNameHints', false), + includeInlayFunctionParameterTypeHints: config.get('inlayHints.includeInlayFunctionParameterTypeHints', false), + includeInlayVariableTypeHints: config.get('inlayHints.includeInlayVariableTypeHints', false), + includeInlayNonLiteralParameterNameHints: config.get('inlayHints.includeInlayNonLiteralParameterNameHints', false), + includeInlayDuplicatedParameterNameHints: config.get('inlayHints.includeInlayDuplicatedParameterNameHints', false), + includeInlayRequireAssignedVariableTypeHints: config.get('inlayHints.includeInlayRequireAssignedVariableTypeHints', false), + includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.includeInlayPropertyDeclarationTypeHints', false), + includeInlayFunctionLikeReturnTypeHints: config.get('inlayHints.includeInlayFunctionLikeReturnTypeHints', false), + includeInlayEnumMemberValueHints: config.get('inlayHints.includeInlayEnumMemberValueHints', false), + includeInlayCallChainsHints: config.get('inlayHints.includeInlayCallChainsHints', false) }; } diff --git a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts similarity index 61% rename from extensions/typescript-language-features/src/languageFeatures/inlineHints.ts rename to extensions/typescript-language-features/src/languageFeatures/inlayHints.ts index c41a9e5d74491..09ed33ffc1931 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlineHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts @@ -8,17 +8,17 @@ import * as Proto from '../protocol'; import { DocumentSelector } from '../utils/documentSelector'; import { ClientCapability, ITypeScriptServiceClient, ServerResponse, ExecConfig } from '../typescriptService'; import { conditionalRegistration, requireMinVersion, requireSomeCapability } from '../utils/dependentRegistration'; -import { Range } from '../utils/typeConverters'; -import FileConfigurationManager, { getInlineHintsPreferences } from './fileConfigurationManager'; +import { Position } from '../utils/typeConverters'; +import FileConfigurationManager, { getInlayHintsPreferences } from './fileConfigurationManager'; import API from '../utils/api'; import { isTypeScriptDocument } from '../utils/languageModeIds'; namespace ExperimentalProto { export const enum CommandTypes { - ProvideInlineHints = 'ProvideInlineHints' + ProvideInlineHints = 'ProvideInlayHints' } - export interface ProvideInlineHintsArgs extends Proto.FileRequestArgs { + export interface ProvideInlayHintsArgs extends Proto.FileRequestArgs { /** * Start position of the span. */ @@ -31,19 +31,25 @@ namespace ExperimentalProto { export interface ProvideInlineHintsRequest extends Proto.Request { command: CommandTypes.ProvideInlineHints; - arguments: ProvideInlineHintsArgs; + arguments: ProvideInlayHintsArgs; } - interface HintItem { + export enum InlayHintKind { + Other = 0, + Type = 1, + Parameter = 2, + } + + interface InlayHintItem { text: string; - range: Proto.TextSpan; - hoverMessage?: string; + position: Proto.Location; + kind?: InlayHintKind; whitespaceBefore?: boolean; whitespaceAfter?: boolean; } - export interface ProvideInlineHintsResponse extends Proto.Response { - body?: HintItem[]; + export interface ProvideInlayHintsResponse extends Proto.Response { + body?: InlayHintItem[]; } export interface IExtendedTypeScriptServiceClient { @@ -56,19 +62,19 @@ namespace ExperimentalProto { } export interface ExtendedTsServerRequests { - 'provideInlineHints': [ProvideInlineHintsArgs, ProvideInlineHintsResponse]; + 'provideInlayHints': [ProvideInlayHintsArgs, ProvideInlayHintsResponse]; } } -class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { - public static readonly minVersion = API.v420; +class TypeScriptInlayHintsProvider implements vscode.InlayHintsProvider { + public static readonly minVersion = API.v440; constructor( private readonly client: ITypeScriptServiceClient, private readonly fileConfigurationManager: FileConfigurationManager ) { } - async provideInlineHints(model: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): Promise { + async provideInlayHints(model: vscode.TextDocument, range: vscode.Range, token: vscode.CancellationToken): Promise { const filepath = this.client.toOpenedFilePath(model); if (!filepath) { return []; @@ -76,24 +82,29 @@ class TypeScriptInlineHintsProvider implements vscode.InlineHintsProvider { await this.fileConfigurationManager.ensureConfigurationForDocument(model, token); - if (!this.someInlineHintsEnabled(model)) { + if (!this.someInlayHintsEnabled(model)) { return []; } const start = model.offsetAt(range.start); const length = model.offsetAt(range.end) - start; - const response = await (this.client as ExperimentalProto.IExtendedTypeScriptServiceClient).execute('provideInlineHints', { file: filepath, start, length }, token); + const response = await (this.client as ExperimentalProto.IExtendedTypeScriptServiceClient).execute('provideInlayHints', { file: filepath, start, length }, token); if (response.type !== 'response' || !response.success || !response.body) { return []; } - return response.body.map(hint => new vscode.InlineHint(hint.text, Range.fromTextSpan(hint.range), hint.hoverMessage, hint.whitespaceBefore, hint.whitespaceAfter)); + return response.body.map(hint => { + const result = new vscode.InlayHint(hint.text, Position.fromLocation(hint.position), hint.kind); + result.whitespaceBefore = hint.whitespaceBefore; + result.whitespaceAfter = hint.whitespaceAfter; + return result; + }); } - private someInlineHintsEnabled(model: vscode.TextDocument) { + private someInlayHintsEnabled(model: vscode.TextDocument) { const config = vscode.workspace.getConfiguration(isTypeScriptDocument(model) ? 'typescript' : 'javascript', model.uri); - const preferences = getInlineHintsPreferences(config); + const preferences = getInlayHintsPreferences(config); return Object.values(preferences).some(Boolean); } } @@ -104,10 +115,10 @@ export function register( fileConfigurationManager: FileConfigurationManager ) { return conditionalRegistration([ - requireMinVersion(client, TypeScriptInlineHintsProvider.minVersion), + requireMinVersion(client, TypeScriptInlayHintsProvider.minVersion), requireSomeCapability(client, ClientCapability.Semantic), ], () => { - return vscode.languages.registerInlineHintsProvider(selector.semantic, - new TypeScriptInlineHintsProvider(client, fileConfigurationManager)); + return vscode.languages.registerInlayHintsProvider(selector.semantic, + new TypeScriptInlayHintsProvider(client, fileConfigurationManager)); }); } diff --git a/extensions/typescript-language-features/src/languageProvider.ts b/extensions/typescript-language-features/src/languageProvider.ts index 585f7853c8455..1fd7baf91d8d5 100644 --- a/extensions/typescript-language-features/src/languageProvider.ts +++ b/extensions/typescript-language-features/src/languageProvider.ts @@ -83,7 +83,7 @@ export default class LanguageProvider extends Disposable { import('./languageFeatures/smartSelect').then(provider => this._register(provider.register(selector, this.client))), import('./languageFeatures/tagClosing').then(provider => this._register(provider.register(selector, this.description.id, this.client))), import('./languageFeatures/typeDefinitions').then(provider => this._register(provider.register(selector, this.client))), - import('./languageFeatures/inlineHints').then(provider => this._register(provider.register(selector, this.client, this.fileConfigurationManager))), + import('./languageFeatures/inlayHints').then(provider => this._register(provider.register(selector, this.client, this.fileConfigurationManager))), ]); } diff --git a/extensions/typescript-language-features/src/utils/api.ts b/extensions/typescript-language-features/src/utils/api.ts index 5ff6572be29fb..61d9801ca710b 100644 --- a/extensions/typescript-language-features/src/utils/api.ts +++ b/extensions/typescript-language-features/src/utils/api.ts @@ -36,6 +36,7 @@ export default class API { public static readonly v401 = API.fromSimpleString('4.0.1'); public static readonly v420 = API.fromSimpleString('4.2.0'); public static readonly v430 = API.fromSimpleString('4.3.0'); + public static readonly v440 = API.fromSimpleString('4.4.0'); public static fromVersionString(versionString: string): API { let version = semver.valid(versionString); From b24a241ed9fa530133808386577df8c9d5075fe2 Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Thu, 10 Jun 2021 15:43:11 +0800 Subject: [PATCH 09/16] Avoid call chain hints --- extensions/typescript-language-features/package.json | 12 ------------ .../typescript-language-features/package.nls.json | 1 - .../src/languageFeatures/fileConfigurationManager.ts | 2 -- 3 files changed, 15 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index 0456f0d1cf7cf..4633b88e49802 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -324,12 +324,6 @@ "description": "%configuration.inlayHints.includeInlayEnumMemberValueHints%", "scope": "resource" }, - "typescript.inlayHints.includeInlayCallChainsHints": { - "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayCallChainsHints%", - "scope": "resource" - }, "javascript.inlayHints.includeInlayParameterNameHints": { "type": "boolean", "default": false, @@ -384,12 +378,6 @@ "description": "%configuration.inlayHints.includeInlayEnumMemberValueHints%", "scope": "resource" }, - "javascript.inlayHints.includeInlayCallChainsHints": { - "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayCallChainsHints%", - "scope": "resource" - }, "javascript.suggest.includeCompletionsForImportStatements": { "type": "boolean", "default": true, diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index f6f26ded083cd..786d6f7dd9174 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -83,7 +83,6 @@ "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declaration.", "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function like.", "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member.", - "configuration.inlayHints.includeInlayCallChainsHints": "Enable/disable inlay hints of call chains.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index c573d205dd3b9..e29e2800402e1 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -26,7 +26,6 @@ namespace ExperimentalProto { includeInlayPropertyDeclarationTypeHints?: boolean; includeInlayFunctionLikeReturnTypeHints?: boolean; includeInlayEnumMemberValueHints?: boolean; - includeInlayCallChainsHints?: boolean; } } @@ -229,7 +228,6 @@ export function getInlayHintsPreferences(config: vscode.WorkspaceConfiguration) includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.includeInlayPropertyDeclarationTypeHints', false), includeInlayFunctionLikeReturnTypeHints: config.get('inlayHints.includeInlayFunctionLikeReturnTypeHints', false), includeInlayEnumMemberValueHints: config.get('inlayHints.includeInlayEnumMemberValueHints', false), - includeInlayCallChainsHints: config.get('inlayHints.includeInlayCallChainsHints', false) }; } From b914b0b2e8bcf9d66887f2d81ecdc611cff8fa7e Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Tue, 15 Jun 2021 14:34:55 +0800 Subject: [PATCH 10/16] Avoid more option --- extensions/typescript-language-features/package.json | 12 ------------ .../typescript-language-features/package.nls.json | 1 - .../src/languageFeatures/fileConfigurationManager.ts | 2 -- 3 files changed, 15 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index 4633b88e49802..39c8d66becd9b 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -300,12 +300,6 @@ "description": "%configuration.inlayHints.includeInlayDuplicatedParameterNameHints%", "scope": "resource" }, - "typescript.inlayHints.includeInlayRequireAssignedVariableTypeHints": { - "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayRequireAssignedVariableTypeHints%", - "scope": "resource" - }, "typescript.inlayHints.includeInlayPropertyDeclarationTypeHints": { "type": "boolean", "default": false, @@ -354,12 +348,6 @@ "description": "%configuration.inlayHints.includeInlayDuplicatedParameterNameHints%", "scope": "resource" }, - "javascript.inlayHints.includeInlayRequireAssignedVariableTypeHints": { - "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayRequireAssignedVariableTypeHints%", - "scope": "resource" - }, "javascript.inlayHints.includeInlayPropertyDeclarationTypeHints": { "type": "boolean", "default": false, diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index 786d6f7dd9174..ebbcb4bbb2727 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -79,7 +79,6 @@ "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable type.", "configuration.inlayHints.includeInlayNonLiteralParameterNameHints": "Enable/disable inlay hints of non literal argument.", "configuration.inlayHints.includeInlayDuplicatedParameterNameHints": "Enable/disable inlay hints of duplicated argument.", - "configuration.inlayHints.includeInlayRequireAssignedVariableTypeHints": "Enable/disable inlay hints of require assigned variable.", "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declaration.", "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function like.", "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index e29e2800402e1..428607511bb2d 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -22,7 +22,6 @@ namespace ExperimentalProto { includeInlayVariableTypeHints?: boolean; includeInlayNonLiteralParameterNameHints?: boolean; includeInlayDuplicatedParameterNameHints?: boolean; - includeInlayRequireAssignedVariableTypeHints?: boolean; includeInlayPropertyDeclarationTypeHints?: boolean; includeInlayFunctionLikeReturnTypeHints?: boolean; includeInlayEnumMemberValueHints?: boolean; @@ -224,7 +223,6 @@ export function getInlayHintsPreferences(config: vscode.WorkspaceConfiguration) includeInlayVariableTypeHints: config.get('inlayHints.includeInlayVariableTypeHints', false), includeInlayNonLiteralParameterNameHints: config.get('inlayHints.includeInlayNonLiteralParameterNameHints', false), includeInlayDuplicatedParameterNameHints: config.get('inlayHints.includeInlayDuplicatedParameterNameHints', false), - includeInlayRequireAssignedVariableTypeHints: config.get('inlayHints.includeInlayRequireAssignedVariableTypeHints', false), includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.includeInlayPropertyDeclarationTypeHints', false), includeInlayFunctionLikeReturnTypeHints: config.get('inlayHints.includeInlayFunctionLikeReturnTypeHints', false), includeInlayEnumMemberValueHints: config.get('inlayHints.includeInlayEnumMemberValueHints', false), From 4b0e10120f42c97a82c96f5efaaec4a4edce4af5 Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Fri, 25 Jun 2021 15:24:32 +0800 Subject: [PATCH 11/16] Update protos --- .../typescript-language-features/package.json | 38 +++++++++---------- .../package.nls.json | 3 +- .../fileConfigurationManager.ts | 21 ++++++---- .../src/languageFeatures/inlayHints.ts | 37 +++++++++++++----- 4 files changed, 61 insertions(+), 38 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index cc3baf0a8690e..28181c4af15f4 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -271,8 +271,13 @@ "scope": "resource" }, "typescript.inlayHints.includeInlayParameterNameHints": { - "type": "boolean", - "default": false, + "type": "string", + "enum": [ + "none", + "literals", + "all" + ], + "default": "none", "description": "%configuration.inlayHints.includeInlayParameterNameHints%", "scope": "resource" }, @@ -288,16 +293,10 @@ "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", "scope": "resource" }, - "typescript.inlayHints.includeInlayNonLiteralParameterNameHints": { - "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayNonLiteralParameterNameHints%", - "scope": "resource" - }, - "typescript.inlayHints.includeInlayDuplicatedParameterNameHints": { + "typescript.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayDuplicatedParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName%", "scope": "resource" }, "typescript.inlayHints.includeInlayPropertyDeclarationTypeHints": { @@ -319,8 +318,13 @@ "scope": "resource" }, "javascript.inlayHints.includeInlayParameterNameHints": { - "type": "boolean", - "default": false, + "type": "string", + "enum": [ + "none", + "literals", + "all" + ], + "default": "none", "description": "%configuration.inlayHints.includeInlayParameterNameHints%", "scope": "resource" }, @@ -336,16 +340,10 @@ "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", "scope": "resource" }, - "javascript.inlayHints.includeInlayNonLiteralParameterNameHints": { - "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayNonLiteralParameterNameHints%", - "scope": "resource" - }, - "javascript.inlayHints.includeInlayDuplicatedParameterNameHints": { + "javascript.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayDuplicatedParameterNameHints%", + "description": "%configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName%", "scope": "resource" }, "javascript.inlayHints.includeInlayPropertyDeclarationTypeHints": { diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index ebbcb4bbb2727..6af4e3165835e 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -77,8 +77,7 @@ "configuration.inlayHints.includeInlayParameterNameHints": "Enable/disable inlay hints of parameter name.", "configuration.inlayHints.includeInlayFunctionParameterTypeHints": "Enable/disable inlay hints of function parameter name.", "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable type.", - "configuration.inlayHints.includeInlayNonLiteralParameterNameHints": "Enable/disable inlay hints of non literal argument.", - "configuration.inlayHints.includeInlayDuplicatedParameterNameHints": "Enable/disable inlay hints of duplicated argument.", + "configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": "Enable/disable inlay hints when argument matchs the parameter name.", "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declaration.", "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function like.", "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index 428607511bb2d..52f675cde3817 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -17,11 +17,10 @@ namespace ExperimentalProto { export interface UserPreferences extends Proto.UserPreferences { displayPartsForJSDoc: true - includeInlayParameterNameHints?: boolean; + includeInlayParameterNameHints?: 'none' | 'literals' | 'all'; + includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean; includeInlayFunctionParameterTypeHints?: boolean; includeInlayVariableTypeHints?: boolean; - includeInlayNonLiteralParameterNameHints?: boolean; - includeInlayDuplicatedParameterNameHints?: boolean; includeInlayPropertyDeclarationTypeHints?: boolean; includeInlayFunctionLikeReturnTypeHints?: boolean; includeInlayEnumMemberValueHints?: boolean; @@ -218,15 +217,23 @@ export default class FileConfigurationManager extends Disposable { export function getInlayHintsPreferences(config: vscode.WorkspaceConfiguration) { return { - includeInlayParameterNameHints: config.get('inlayHints.includeInlayParameterNameHints', false), + includeInlayParameterNameHints: getInlayParameterNameHintsPreference(config), + includeInlayParameterNameHintsWhenArgumentMatchesName: config.get('inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName', false), includeInlayFunctionParameterTypeHints: config.get('inlayHints.includeInlayFunctionParameterTypeHints', false), includeInlayVariableTypeHints: config.get('inlayHints.includeInlayVariableTypeHints', false), - includeInlayNonLiteralParameterNameHints: config.get('inlayHints.includeInlayNonLiteralParameterNameHints', false), - includeInlayDuplicatedParameterNameHints: config.get('inlayHints.includeInlayDuplicatedParameterNameHints', false), includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.includeInlayPropertyDeclarationTypeHints', false), includeInlayFunctionLikeReturnTypeHints: config.get('inlayHints.includeInlayFunctionLikeReturnTypeHints', false), includeInlayEnumMemberValueHints: config.get('inlayHints.includeInlayEnumMemberValueHints', false), - }; + } as const; +} + +function getInlayParameterNameHintsPreference(config: vscode.WorkspaceConfiguration) { + switch (config.get('inlayHints.includeInlayParameterNameHints')) { + case 'none': return 'none'; + case 'literals': return 'literals'; + case 'all': return 'all'; + default: return undefined; + } } function getImportModuleSpecifierPreference(config: vscode.WorkspaceConfiguration) { diff --git a/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts index 09ed33ffc1931..4b7a7962a42e3 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts @@ -18,7 +18,7 @@ namespace ExperimentalProto { ProvideInlineHints = 'ProvideInlayHints' } - export interface ProvideInlayHintsArgs extends Proto.FileRequestArgs { + export interface InlayHintsArgs extends Proto.FileRequestArgs { /** * Start position of the span. */ @@ -29,15 +29,15 @@ namespace ExperimentalProto { length: number; } - export interface ProvideInlineHintsRequest extends Proto.Request { + export interface InlineHintsRequest extends Proto.Request { command: CommandTypes.ProvideInlineHints; - arguments: ProvideInlayHintsArgs; + arguments: InlayHintsArgs; } export enum InlayHintKind { - Other = 0, - Type = 1, - Parameter = 2, + Type = 'Type', + Parameter = 'Parameter', + Enum = 'Enum' } interface InlayHintItem { @@ -48,7 +48,7 @@ namespace ExperimentalProto { whitespaceAfter?: boolean; } - export interface ProvideInlayHintsResponse extends Proto.Response { + export interface InlayHintsResponse extends Proto.Response { body?: InlayHintItem[]; } @@ -62,7 +62,22 @@ namespace ExperimentalProto { } export interface ExtendedTsServerRequests { - 'provideInlayHints': [ProvideInlayHintsArgs, ProvideInlayHintsResponse]; + 'provideInlayHints': [InlayHintsArgs, InlayHintsResponse]; + } + + export namespace InlayHintKind { + export function fromProtocolInlayHintKind(kind: InlayHintKind): vscode.InlayHintKind { + switch (kind) { + case InlayHintKind.Parameter: + return vscode.InlayHintKind.Parameter; + case InlayHintKind.Type: + return vscode.InlayHintKind.Type; + case InlayHintKind.Enum: + return vscode.InlayHintKind.Other; + default: + return vscode.InlayHintKind.Other; + } + } } } @@ -95,7 +110,11 @@ class TypeScriptInlayHintsProvider implements vscode.InlayHintsProvider { } return response.body.map(hint => { - const result = new vscode.InlayHint(hint.text, Position.fromLocation(hint.position), hint.kind); + const result = new vscode.InlayHint( + hint.text, + Position.fromLocation(hint.position), + hint.kind && ExperimentalProto.InlayHintKind.fromProtocolInlayHintKind(hint.kind) + ); result.whitespaceBefore = hint.whitespaceBefore; result.whitespaceAfter = hint.whitespaceAfter; return result; From bf6579ed099e1257a1decc0f5f6718f232e1cc68 Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Thu, 1 Jul 2021 14:28:05 +0800 Subject: [PATCH 12/16] Update extensions/typescript-language-features/package.nls.json Co-authored-by: Daniel Rosenwasser --- .../typescript-language-features/package.nls.json | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index 6af4e3165835e..95f3f64ce0554 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -74,13 +74,13 @@ "configuration.implicitProjectConfig.strictFunctionTypes": "Enable/disable [strict function types](https://www.typescriptlang.org/tsconfig#strictFunctionTypes) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.suggest.jsdoc.generateReturns": "Enable/disable generating `@return` annotations for JSDoc templates. Requires using TypeScript 4.2+ in the workspace.", "configuration.suggest.autoImports": "Enable/disable auto import suggestions.", - "configuration.inlayHints.includeInlayParameterNameHints": "Enable/disable inlay hints of parameter name.", - "configuration.inlayHints.includeInlayFunctionParameterTypeHints": "Enable/disable inlay hints of function parameter name.", - "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable type.", - "configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": "Enable/disable inlay hints when argument matchs the parameter name.", - "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declaration.", - "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function like.", - "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member.", + "configuration.inlayHints.includeInlayParameterNameHints": "Enable/disable inlay hints of parameter names.", + "configuration.inlayHints.includeInlayFunctionParameterTypeHints": "Enable/disable inlay hints of function parameter types.", + "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable types.", + "configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": "Enable/disable inlay hints when argument matches the parameter names.", + "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declarations.", + "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function signatures.", + "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member values.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", From c4856473e974ee2024fbcdff578c25fdd87fcaac Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Thu, 1 Jul 2021 15:08:22 +0800 Subject: [PATCH 13/16] Use suppress for some option --- extensions/typescript-language-features/package.json | 12 ++++++------ .../typescript-language-features/package.nls.json | 2 +- .../src/languageFeatures/fileConfigurationManager.ts | 2 +- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index 28181c4af15f4..d40944e4baba8 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -293,10 +293,10 @@ "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", "scope": "resource" }, - "typescript.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": { + "typescript.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName": { "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName%", + "default": true, + "description": "%configuration.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName%", "scope": "resource" }, "typescript.inlayHints.includeInlayPropertyDeclarationTypeHints": { @@ -340,10 +340,10 @@ "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", "scope": "resource" }, - "javascript.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": { + "javascript.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName": { "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName%", + "default": true, + "description": "%configuration.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName%", "scope": "resource" }, "javascript.inlayHints.includeInlayPropertyDeclarationTypeHints": { diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index 95f3f64ce0554..e621fd4942fe0 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -77,7 +77,7 @@ "configuration.inlayHints.includeInlayParameterNameHints": "Enable/disable inlay hints of parameter names.", "configuration.inlayHints.includeInlayFunctionParameterTypeHints": "Enable/disable inlay hints of function parameter types.", "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable types.", - "configuration.inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName": "Enable/disable inlay hints when argument matches the parameter names.", + "configuration.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName": "Suppress parameter name hints on arguments whose text is identical to the parameter name.", "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declarations.", "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function signatures.", "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member values.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index 52f675cde3817..dbec6be5b5ffa 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -218,7 +218,7 @@ export default class FileConfigurationManager extends Disposable { export function getInlayHintsPreferences(config: vscode.WorkspaceConfiguration) { return { includeInlayParameterNameHints: getInlayParameterNameHintsPreference(config), - includeInlayParameterNameHintsWhenArgumentMatchesName: config.get('inlayHints.includeInlayParameterNameHintsWhenArgumentMatchesName', false), + includeInlayParameterNameHintsWhenArgumentMatchesName: !config.get('inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName', true), includeInlayFunctionParameterTypeHints: config.get('inlayHints.includeInlayFunctionParameterTypeHints', false), includeInlayVariableTypeHints: config.get('inlayHints.includeInlayVariableTypeHints', false), includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.includeInlayPropertyDeclarationTypeHints', false), From 2a6f9da56bbc31a0ca3f22096f332df7ccce35c2 Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Wed, 7 Jul 2021 12:39:42 +0800 Subject: [PATCH 14/16] Update CR issues --- .../typescript-language-features/package.json | 75 +++++++++++-------- .../package.nls.json | 17 +++-- .../fileConfigurationManager.ts | 14 ++-- .../src/languageFeatures/inlayHints.ts | 33 +++++--- .../src/languageProvider.ts | 2 +- 5 files changed, 83 insertions(+), 58 deletions(-) diff --git a/extensions/typescript-language-features/package.json b/extensions/typescript-language-features/package.json index d40944e4baba8..f8f974df25b08 100644 --- a/extensions/typescript-language-features/package.json +++ b/extensions/typescript-language-features/package.json @@ -270,98 +270,109 @@ "description": "%configuration.suggest.includeAutomaticOptionalChainCompletions%", "scope": "resource" }, - "typescript.inlayHints.includeInlayParameterNameHints": { + "typescript.inlayHints.parameterNames.enabled": { "type": "string", "enum": [ "none", "literals", "all" ], + "enumDescriptions": [ + "%inlayHints.parameterNames.none%", + "%inlayHints.parameterNames.literals%", + "%inlayHints.parameterNames.all%" + ], "default": "none", - "description": "%configuration.inlayHints.includeInlayParameterNameHints%", + "description": "%configuration.inlayHints.parameterNames.enabled%", "scope": "resource" }, - "typescript.inlayHints.includeInlayFunctionParameterTypeHints": { + "typescript.inlayHints.parameterNames.suppressWhenArgumentMatchesName": { "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayFunctionParameterTypeHints%", + "default": true, + "description": "%configuration.inlayHints.parameterNames.suppressWhenArgumentMatchesName%", "scope": "resource" }, - "typescript.inlayHints.includeInlayVariableTypeHints": { + "typescript.inlayHints.parameterTypes.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", + "description": "%configuration.inlayHints.parameterTypes.enabled%", "scope": "resource" }, - "typescript.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName": { + "typescript.inlayHints.variableTypes.enabled": { "type": "boolean", - "default": true, - "description": "%configuration.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName%", + "default": false, + "description": "%configuration.inlayHints.variableTypes.enabled%", "scope": "resource" }, - "typescript.inlayHints.includeInlayPropertyDeclarationTypeHints": { + + "typescript.inlayHints.propertyDeclarationTypes.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayPropertyDeclarationTypeHints%", + "description": "%configuration.inlayHints.propertyDeclarationTypes.enabled%", "scope": "resource" }, - "typescript.inlayHints.includeInlayFunctionLikeReturnTypeHints": { + "typescript.inlayHints.functionLikeReturnTypes.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints%", + "description": "%configuration.inlayHints.functionLikeReturnTypes.enabled%", "scope": "resource" }, - "typescript.inlayHints.includeInlayEnumMemberValueHints": { + "typescript.inlayHints.enumMemberValues.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayEnumMemberValueHints%", + "description": "%configuration.inlayHints.enumMemberValues.enabled%", "scope": "resource" }, - "javascript.inlayHints.includeInlayParameterNameHints": { + "javascript.inlayHints.parameterNames.enabled": { "type": "string", "enum": [ "none", "literals", "all" ], + "enumDescriptions": [ + "%inlayHints.parameterNames.none%", + "%inlayHints.parameterNames.literals%", + "%inlayHints.parameterNames.all%" + ], "default": "none", - "description": "%configuration.inlayHints.includeInlayParameterNameHints%", + "description": "%configuration.inlayHints.parameterNames.enabled%", "scope": "resource" }, - "javascript.inlayHints.includeInlayFunctionParameterTypeHints": { + "javascript.inlayHints.parameterNames.suppressWhenArgumentMatchesName": { "type": "boolean", - "default": false, - "description": "%configuration.inlayHints.includeInlayFunctionParameterTypeHints%", + "default": true, + "description": "%configuration.inlayHints.parameterNames.suppressWhenArgumentMatchesName%", "scope": "resource" }, - "javascript.inlayHints.includeInlayVariableTypeHints": { + "javascript.inlayHints.parameterTypes.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayVariableTypeHints%", + "description": "%configuration.inlayHints.parameterTypes.enabled%", "scope": "resource" }, - "javascript.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName": { + "javascript.inlayHints.variableTypes.enabled": { "type": "boolean", - "default": true, - "description": "%configuration.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName%", + "default": false, + "description": "%configuration.inlayHints.variableTypes.enabled%", "scope": "resource" }, - "javascript.inlayHints.includeInlayPropertyDeclarationTypeHints": { + "javascript.inlayHints.propertyDeclarationTypes.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayPropertyDeclarationTypeHints%", + "description": "%configuration.inlayHints.propertyDeclarationTypes.enabled%", "scope": "resource" }, - "javascript.inlayHints.includeInlayFunctionLikeReturnTypeHints": { + "javascript.inlayHints.functionLikeReturnTypes.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints%", + "description": "%configuration.inlayHints.functionLikeReturnTypes.enabled%", "scope": "resource" }, - "javascript.inlayHints.includeInlayEnumMemberValueHints": { + "javascript.inlayHints.enumMemberValues.enabled": { "type": "boolean", "default": false, - "description": "%configuration.inlayHints.includeInlayEnumMemberValueHints%", + "description": "%configuration.inlayHints.enumMemberValues.enabled%", "scope": "resource" }, "javascript.suggest.includeCompletionsForImportStatements": { diff --git a/extensions/typescript-language-features/package.nls.json b/extensions/typescript-language-features/package.nls.json index e621fd4942fe0..7340a1ef8a91d 100644 --- a/extensions/typescript-language-features/package.nls.json +++ b/extensions/typescript-language-features/package.nls.json @@ -74,13 +74,16 @@ "configuration.implicitProjectConfig.strictFunctionTypes": "Enable/disable [strict function types](https://www.typescriptlang.org/tsconfig#strictFunctionTypes) in JavaScript and TypeScript files that are not part of a project. Existing `jsconfig.json` or `tsconfig.json` files override this setting.", "configuration.suggest.jsdoc.generateReturns": "Enable/disable generating `@return` annotations for JSDoc templates. Requires using TypeScript 4.2+ in the workspace.", "configuration.suggest.autoImports": "Enable/disable auto import suggestions.", - "configuration.inlayHints.includeInlayParameterNameHints": "Enable/disable inlay hints of parameter names.", - "configuration.inlayHints.includeInlayFunctionParameterTypeHints": "Enable/disable inlay hints of function parameter types.", - "configuration.inlayHints.includeInlayVariableTypeHints": "Enable/disable inlay hints of variable types.", - "configuration.inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName": "Suppress parameter name hints on arguments whose text is identical to the parameter name.", - "configuration.inlayHints.includeInlayPropertyDeclarationTypeHints": "Enable/disable inlay hints of property declarations.", - "configuration.inlayHints.includeInlayFunctionLikeReturnTypeHints": "Enable/disable inlay hints of return type for function signatures.", - "configuration.inlayHints.includeInlayEnumMemberValueHints": "Enable/disable inlay hints of enum member values.", + "inlayHints.parameterNames.none": "Disable parameter name hints.", + "inlayHints.parameterNames.literals": "Enable parameter name hints only for literal arguments.", + "inlayHints.parameterNames.all": "Enable parameter name hints for literal and non-literal arguments.", + "configuration.inlayHints.parameterNames.enabled": "Enable/disable inlay hints of parameter names.", + "configuration.inlayHints.parameterNames.suppressWhenArgumentMatchesName": "Suppress parameter name hints on arguments whose text is identical to the parameter name.", + "configuration.inlayHints.parameterTypes.enabled": "Enable/disable inlay hints of parameter types.", + "configuration.inlayHints.variableTypes.enabled": "Enable/disable inlay hints of variable types.", + "configuration.inlayHints.propertyDeclarationTypes.enabled": "Enable/disable inlay hints of property declarations.", + "configuration.inlayHints.functionLikeReturnTypes.enabled": "Enable/disable inlay hints of return type for function signatures.", + "configuration.inlayHints.enumMemberValues.enabled": "Enable/disable inlay hints of enum member values.", "taskDefinition.tsconfig.description": "The tsconfig file that defines the TS build.", "javascript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for JavaScript files in the editor.", "typescript.suggestionActions.enabled": "Enable/disable suggestion diagnostics for TypeScript files in the editor.", diff --git a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts index dbec6be5b5ffa..8d522047cc63a 100644 --- a/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts +++ b/extensions/typescript-language-features/src/languageFeatures/fileConfigurationManager.ts @@ -218,17 +218,17 @@ export default class FileConfigurationManager extends Disposable { export function getInlayHintsPreferences(config: vscode.WorkspaceConfiguration) { return { includeInlayParameterNameHints: getInlayParameterNameHintsPreference(config), - includeInlayParameterNameHintsWhenArgumentMatchesName: !config.get('inlayHints.suppressInlayParameterNameHintsWhenArgumentMatchesName', true), - includeInlayFunctionParameterTypeHints: config.get('inlayHints.includeInlayFunctionParameterTypeHints', false), - includeInlayVariableTypeHints: config.get('inlayHints.includeInlayVariableTypeHints', false), - includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.includeInlayPropertyDeclarationTypeHints', false), - includeInlayFunctionLikeReturnTypeHints: config.get('inlayHints.includeInlayFunctionLikeReturnTypeHints', false), - includeInlayEnumMemberValueHints: config.get('inlayHints.includeInlayEnumMemberValueHints', false), + includeInlayParameterNameHintsWhenArgumentMatchesName: !config.get('inlayHints.parameterNames.suppressWhenArgumentMatchesName', true), + includeInlayFunctionParameterTypeHints: config.get('inlayHints.parameterTypes.enabled', false), + includeInlayVariableTypeHints: config.get('inlayHints.variableTypes.enabled', false), + includeInlayPropertyDeclarationTypeHints: config.get('inlayHints.propertyDeclarationTypes.enabled', false), + includeInlayFunctionLikeReturnTypeHints: config.get('inlayHints.functionLikeReturnTypes.enabled', false), + includeInlayEnumMemberValueHints: config.get('inlayHints.enumMemberValues.enabled', false), } as const; } function getInlayParameterNameHintsPreference(config: vscode.WorkspaceConfiguration) { - switch (config.get('inlayHints.includeInlayParameterNameHints')) { + switch (config.get('inlayHints.parameterNames.enabled')) { case 'none': return 'none'; case 'literals': return 'literals'; case 'all': return 'all'; diff --git a/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts b/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts index 4b7a7962a42e3..c2039e9646b6f 100644 --- a/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts +++ b/extensions/typescript-language-features/src/languageFeatures/inlayHints.ts @@ -7,11 +7,10 @@ import * as vscode from 'vscode'; import * as Proto from '../protocol'; import { DocumentSelector } from '../utils/documentSelector'; import { ClientCapability, ITypeScriptServiceClient, ServerResponse, ExecConfig } from '../typescriptService'; -import { conditionalRegistration, requireMinVersion, requireSomeCapability } from '../utils/dependentRegistration'; +import { Condition, conditionalRegistration, requireMinVersion, requireSomeCapability } from '../utils/dependentRegistration'; import { Position } from '../utils/typeConverters'; import FileConfigurationManager, { getInlayHintsPreferences } from './fileConfigurationManager'; import API from '../utils/api'; -import { isTypeScriptDocument } from '../utils/languageModeIds'; namespace ExperimentalProto { export const enum CommandTypes { @@ -97,10 +96,6 @@ class TypeScriptInlayHintsProvider implements vscode.InlayHintsProvider { await this.fileConfigurationManager.ensureConfigurationForDocument(model, token); - if (!this.someInlayHintsEnabled(model)) { - return []; - } - const start = model.offsetAt(range.start); const length = model.offsetAt(range.end) - start; @@ -120,20 +115,36 @@ class TypeScriptInlayHintsProvider implements vscode.InlayHintsProvider { return result; }); } +} - private someInlayHintsEnabled(model: vscode.TextDocument) { - const config = vscode.workspace.getConfiguration(isTypeScriptDocument(model) ? 'typescript' : 'javascript', model.uri); - const preferences = getInlayHintsPreferences(config); - return Object.values(preferences).some(Boolean); - } +export function requireInlayHintsConfiguration( + language: string +) { + return new Condition( + () => { + const config = vscode.workspace.getConfiguration(language, null); + const preferences = getInlayHintsPreferences(config); + + return preferences.includeInlayParameterNameHints === 'literals' || + preferences.includeInlayParameterNameHints === 'all' || + preferences.includeInlayEnumMemberValueHints || + preferences.includeInlayFunctionLikeReturnTypeHints || + preferences.includeInlayFunctionParameterTypeHints || + preferences.includeInlayPropertyDeclarationTypeHints || + preferences.includeInlayVariableTypeHints; + }, + vscode.workspace.onDidChangeConfiguration + ); } export function register( selector: DocumentSelector, + modeId: string, client: ITypeScriptServiceClient, fileConfigurationManager: FileConfigurationManager ) { return conditionalRegistration([ + requireInlayHintsConfiguration(modeId), requireMinVersion(client, TypeScriptInlayHintsProvider.minVersion), requireSomeCapability(client, ClientCapability.Semantic), ], () => { diff --git a/extensions/typescript-language-features/src/languageProvider.ts b/extensions/typescript-language-features/src/languageProvider.ts index 1fd7baf91d8d5..3159af1a4d603 100644 --- a/extensions/typescript-language-features/src/languageProvider.ts +++ b/extensions/typescript-language-features/src/languageProvider.ts @@ -83,7 +83,7 @@ export default class LanguageProvider extends Disposable { import('./languageFeatures/smartSelect').then(provider => this._register(provider.register(selector, this.client))), import('./languageFeatures/tagClosing').then(provider => this._register(provider.register(selector, this.description.id, this.client))), import('./languageFeatures/typeDefinitions').then(provider => this._register(provider.register(selector, this.client))), - import('./languageFeatures/inlayHints').then(provider => this._register(provider.register(selector, this.client, this.fileConfigurationManager))), + import('./languageFeatures/inlayHints').then(provider => this._register(provider.register(selector, this.description.id, this.client, this.fileConfigurationManager))), ]); } From af1b51aa3d5ca984f4703a3ab052ef6c35ae818e Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Wed, 7 Jul 2021 12:43:57 +0800 Subject: [PATCH 15/16] Fix missing typedef --- .../src/typescriptServiceClient.ts | 17 +++++++---------- 1 file changed, 7 insertions(+), 10 deletions(-) diff --git a/extensions/typescript-language-features/src/typescriptServiceClient.ts b/extensions/typescript-language-features/src/typescriptServiceClient.ts index f76870178363c..de35fd503b022 100644 --- a/extensions/typescript-language-features/src/typescriptServiceClient.ts +++ b/extensions/typescript-language-features/src/typescriptServiceClient.ts @@ -32,16 +32,13 @@ import { inferredProjectCompilerOptions, ProjectType } from './utils/tsconfig'; namespace ExperimentalProto { export interface UserPreferences extends Proto.UserPreferences { - includeInlineParameterNameHints?: boolean; - includeInlineFunctionParameterTypeHints?: boolean; - includeInlineVariableTypeHints?: boolean; - includeInlineNonLiteralParameterNameHints?: boolean; - includeInlineDuplicatedParameterNameHints?: boolean; - includeInlineRequireAssignedVariableTypeHints?: boolean; - includeInlinePropertyDeclarationTypeHints?: boolean; - includeInlineFunctionLikeReturnTypeHints?: boolean; - includeInlineEnumMemberValueHints?: boolean; - includeInlineCallChainsHints?: boolean; + includeInlayParameterNameHints?: 'none' | 'literals' | 'all'; + includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean; + includeInlayFunctionParameterTypeHints?: boolean; + includeInlayVariableTypeHints?: boolean; + includeInlayPropertyDeclarationTypeHints?: boolean; + includeInlayFunctionLikeReturnTypeHints?: boolean; + includeInlayEnumMemberValueHints?: boolean; } export interface ConfigureRequestArguments extends Proto.ConfigureRequestArguments { From 16b2ff1c51eac773472bcbe4f37d43dbc505b68d Mon Sep 17 00:00:00 2001 From: Wenlu Wang Date: Wed, 7 Jul 2021 12:44:50 +0800 Subject: [PATCH 16/16] Avoid changes --- .../src/typescriptServiceClient.ts | 18 +----------------- 1 file changed, 1 insertion(+), 17 deletions(-) diff --git a/extensions/typescript-language-features/src/typescriptServiceClient.ts b/extensions/typescript-language-features/src/typescriptServiceClient.ts index de35fd503b022..c6ae3c5b0a059 100644 --- a/extensions/typescript-language-features/src/typescriptServiceClient.ts +++ b/extensions/typescript-language-features/src/typescriptServiceClient.ts @@ -30,22 +30,6 @@ import { TelemetryProperties, TelemetryReporter, VSCodeTelemetryReporter } from import Tracer from './utils/tracer'; import { inferredProjectCompilerOptions, ProjectType } from './utils/tsconfig'; -namespace ExperimentalProto { - export interface UserPreferences extends Proto.UserPreferences { - includeInlayParameterNameHints?: 'none' | 'literals' | 'all'; - includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean; - includeInlayFunctionParameterTypeHints?: boolean; - includeInlayVariableTypeHints?: boolean; - includeInlayPropertyDeclarationTypeHints?: boolean; - includeInlayFunctionLikeReturnTypeHints?: boolean; - includeInlayEnumMemberValueHints?: boolean; - } - - export interface ConfigureRequestArguments extends Proto.ConfigureRequestArguments { - preferences?: UserPreferences; - } -} - const localize = nls.loadMessageBundle(); export interface TsDiagnostics { @@ -554,7 +538,7 @@ export default class TypeScriptServiceClient extends Disposable implements IType ? this.configuration.watchOptions : undefined; - const configureOptions: ExperimentalProto.ConfigureRequestArguments = { + const configureOptions: Proto.ConfigureRequestArguments = { hostInfo: 'vscode', preferences: { providePrefixAndSuffixTextForRename: true,