add settings to disable each type of inlay hint

Author: DetachHead

docs/configuration/inlayHints.callArgumentNames.png

@@ -30,6 +30,22 @@ The basedpyright language server honors the following settings.
 !!! note "a note about `python.venvPath`"
     if your venv path is the same for all users working on your project (which should be the case if you're using [uv](https://docs.astral.sh/uv/pip/compatibility/#virtual-environments-by-default) or [pdm](https://pdm-project.org/en/latest/usage/venv/#virtualenv-auto-creation)), we recommend configuring `venvPath` in [a config file](./config-files.md) instead. see [discouraged settings](#discouraged-settings) below for more information.
 
+## based settings
+
+the following settings are exclusive to basedpyright
+
+**basedpyright.inlayHints.variableTypes** [boolean]: Whether to show inlay hints on assignments to variables. Defaults to `true`:
+
+![](inlayHints.variableTypes.png)
+
+**basedpyright.inlayHints.callArgumentNames** [boolean]: Whether to show inlay hints on function arguments. Defaults to `true`:
+
+![](inlayHints.callArgumentNames.png)
+
+**basedpyright.inlayHints.functionReturnTypes** [boolean]: Whether to show inlay hints on function return types. Defaults to `true`:
+
+![](inlayHints.functionReturnTypes.png)
+
 ## discouraged settings
 
 these options can also be configured [using a config file](./config-files.md). it's recommended to use either a `pyproject.toml` or `pyrightconfig.json` file instead of the language server to configure type checking for the following reasons:

docs/configuration/inlayHints.functionReturnTypes.png

@@ -18,6 +18,7 @@ import { TextRange } from '../common/textRange';
 import { convertRangeToTextRange } from '../common/positionUtils';
 import { Uri } from '../common/uri/uri';
 import { ParseFileResults } from '../parser/parser';
+import { InlayHintSettings } from '../common/languageServerInterface';
 
 export type TypeInlayHintsItemType = {
     inlayHintType: 'variable' | 'functionReturn' | 'parameter';
@@ -84,7 +85,12 @@ export class TypeInlayHintsWalker extends ParseTreeWalker {
     parseResults?: ParseFileResults;
     private _range: TextRange | undefined;
 
-    constructor(private readonly _program: ProgramView, fileUri: Uri, range?: Range) {
+    constructor(
+        private readonly _program: ProgramView,
+        private _settings: InlayHintSettings,
+        fileUri: Uri,
+        range?: Range
+    ) {
         super();
         this.parseResults = this._program.getParseResults(fileUri);
         if (this.parseResults) {
@@ -97,6 +103,7 @@ export class TypeInlayHintsWalker extends ParseTreeWalker {
 
     override visitName(node: NameNode): boolean {
         if (
+            this._settings.variableTypes &&
             this._checkInRange(node) &&
             isLeftSideOfAssignment(node) &&
             !isDunderName(node.d.value) &&
@@ -129,14 +136,14 @@ export class TypeInlayHintsWalker extends ParseTreeWalker {
     }
 
     override visitCall(node: CallNode): boolean {
-        if (this._checkInRange(node)) {
+        if (this._settings.callArgumentNames && this._checkInRange(node)) {
             this._generateHintsForCallNode(node);
         }
         return super.visitCall(node);
     }
 
     override visitFunction(node: FunctionNode): boolean {
-        if (this._checkInRange(node)) {
+        if (this._settings.functionReturnTypes && this._checkInRange(node)) {
             const evaluator = this._program.evaluator;
             const functionType = evaluator?.getTypeOfFunction(node)?.functionType;
             if (functionType !== undefined && !functionType.shared.declaredReturnType) {

docs/configuration/inlayHints.variableTypes.png

@@ -21,6 +21,17 @@ import { ServiceProvider } from './serviceProvider';
 import { Uri } from './uri/uri';
 import { FileDiagnostics } from './diagnosticSink';
 
+// if adding a new inlay hint type here, make sure you update onInlayHints where it checks if all of them are false
+export interface InlayHintSettings {
+    /**
+     * pylance's version of this option supports 3 settings: `"all" | "partial" | "off"`. `"all"` shows inlay hints
+     * for positional only arguments which i think is dumb so we don't support it
+     */
+    callArgumentNames: boolean;
+    functionReturnTypes: boolean;
+    variableTypes: boolean;
+}
+
 export interface ServerSettings {
     venvPath?: Uri | undefined;
     pythonPath?: Uri | undefined;
@@ -49,6 +60,7 @@ export interface ServerSettings {
     ignoreFileSpecs?: string[];
     taskListTokens?: TaskListToken[];
     functionSignatureDisplay?: SignatureDisplayType | undefined;
+    inlayHints?: InlayHintSettings;
 }
 
 export interface MessageAction {

docs/configuration/language-server-settings.md

@@ -998,11 +998,23 @@ export abstract class LanguageServerBase implements LanguageServerInterface, Dis
         const uri = Uri.parse(params.textDocument.uri, this.serviceProvider);
         const workspace = await this.getWorkspaceForFile(uri);
 
-        if (workspace.disableLanguageServices) {
+        const inlayHintSettings = (await this.getSettings(workspace)).inlayHints;
+        if (
+            workspace.disableLanguageServices ||
+            // don't bother creating the inlay hint provider if all the inlay hint settings are off
+            (inlayHintSettings &&
+                !inlayHintSettings.callArgumentNames &&
+                !inlayHintSettings.functionReturnTypes &&
+                !inlayHintSettings.variableTypes)
+        ) {
             return null;
         }
         return workspace.service.run((program) => {
-            return new InlayHintsProvider(program, uri, params.range).onInlayHints();
+            return new InlayHintsProvider(program, uri, params.range, {
+                callArgumentNames: inlayHintSettings?.callArgumentNames ?? true,
+                functionReturnTypes: inlayHintSettings?.functionReturnTypes ?? true,
+                variableTypes: inlayHintSettings?.variableTypes ?? true,
+            }).onInlayHints();
         }, token);
     }
 

packages/pyright-internal/src/analyzer/typeInlayHintsWalker.ts

@@ -5,12 +5,13 @@ import { convertOffsetToPosition } from '../common/positionUtils';
 import { TypeInlayHintsWalker } from '../analyzer/typeInlayHintsWalker';
 import { Uri } from '../common/uri/uri';
 import { Range } from 'vscode-languageserver-types';
+import { InlayHintSettings } from '../common/languageServerInterface';
 
 export class InlayHintsProvider {
     private readonly _walker: TypeInlayHintsWalker;
 
-    constructor(private _program: ProgramView, fileUri: Uri, range: Range) {
-        this._walker = new TypeInlayHintsWalker(this._program, fileUri, range);
+    constructor(private _program: ProgramView, fileUri: Uri, range: Range, inlayHintSettings: InlayHintSettings) {
+        this._walker = new TypeInlayHintsWalker(this._program, inlayHintSettings, fileUri, range);
     }
 
     async onInlayHints(): Promise<InlayHint[] | null> {

packages/pyright-internal/src/common/languageServerInterface.ts

@@ -102,6 +102,7 @@ export abstract class RealLanguageServer extends LanguageServerBase {
             logLevel: LogLevel.Info,
             autoImportCompletions: true,
             functionSignatureDisplay: SignatureDisplayType.formatted,
+            inlayHints: { callArgumentNames: true, functionReturnTypes: true, variableTypes: true },
         };
 
         try {
@@ -193,6 +194,11 @@ export abstract class RealLanguageServer extends LanguageServerBase {
                 serverSettings.autoSearchPaths = true;
             }
 
+            const inlayHintSection = await this.getConfiguration(workspace.rootUri, 'basedpyright.inlayHints');
+            if (inlayHintSection) {
+                serverSettings.inlayHints = { ...serverSettings.inlayHints, ...inlayHintSection };
+            }
+
             const pyrightSection = await this.getConfiguration(workspace.rootUri, 'basedpyright');
             if (pyrightSection) {
                 if (pyrightSection.openFilesOnly !== undefined) {

packages/pyright-internal/src/languageServerBase.ts

@@ -151,7 +151,12 @@ export const inlayHintSampleFile = (fileName: string, range?: Range): TypeInlayH
     const program = createProgram();
     const fileUri = UriEx.file(resolveSampleFilePath(path.join('inlay_hints', fileName)));
     program.setTrackedFiles([fileUri]);
-    const walker = new TypeInlayHintsWalker(program, fileUri, range);
+    const walker = new TypeInlayHintsWalker(
+        program,
+        { callArgumentNames: true, functionReturnTypes: true, variableTypes: true },
+        fileUri,
+        range
+    );
     walker.walk(program.getParseResults(fileUri)!.parserOutput.parseTree);
     program.dispose();
     return walker.featureItems;