Unhelpful "Did you forget to include 'void' in your type argument to 'Promise'" in JS file

[JacksonKearl]

TS Template added by @mjbvz

TypeScript Version: 4.5.0-dev.20211028

Search Terms

• javascript
• checkjs
• strict

See #46570 (comment) for more minimal repro

---

In minimal-hello-world extension sample, using this code:

// The module 'vscode' contains the VS Code extensibility API
// Import the module and reference it with the alias vscode in your code below
const vscode = require('vscode');

// this method is called when your extension is activated
// your extension is activated the very first time the command is executed

/**
 * @param {vscode.ExtensionContext} context
 */
function activate(context) {
	// Use the console to output diagnostic information (console.log) and errors (console.error)
	// This line of code will only be executed once when your extension is activated
	console.log('Congratulations, your extension "helloworld-minimal-sample" is now active!');

	// The command has been defined in the package.json file
	// Now provide the implementation of the command with  registerCommand
	// The commandId parameter must match the command field in package.json
	let disposable = vscode.commands.registerCommand('extension.helloWorld', async () => {
		// The code you place here will be executed every time your command is executed

		const quickpick = vscode.window.createQuickPick();
		quickpick.items = [{ label: 'step 1' }];

		void (await new Promise(resolve => {
				quickpick.onDidAccept(() => {
						console.log(quickpick.selectedItems.map(i => i.label).join(', '));

						if (quickpick.selectedItems.length === 0) return;

						if (quickpick.selectedItems[0].label === 'step 1') {
								quickpick.value = '';
								quickpick.canSelectMany = true;
								quickpick.items = [{ label: 'a' }, { label: 'b' }, { label: 'c' }];
								// If I uncomment this it will fix the bug
								// quickpick.selectedItems = [];
						}
						else {
								resolve();
						}
				});

				quickpick.show();
		}));

		quickpick.hide();
	});

	context.subscriptions.push(disposable);
}

// this method is called when your extension is deactivated
function deactivate() {}

// eslint-disable-next-line no-undef
module.exports = {
	activate,
	deactivate
}

I see this error:

This isn't really something we should be warning about in JS.

[mjbvz]

Note for repro: this requires setting:

        "strict": true,
        "checkJs": true

In your jsconfig

[mjbvz]

Minimal repo:

new Promise(resolve => resolve());

Can be worked around with a type annotation:

/**
 * @type {Promise<void>}
 */
(new Promise(resolve => resolve()));

[mjbvz]

Moving upstream. The current behavior looks expected for strict mode but I agree the experience is not great.

Looks like there is already a quick fix for it though:

Some other ideas:

• Have JS type checking behave differently than normal TS in this case (being inconsistent might be confusing though)
• Add a better error message that mentions using a type annotation

[JacksonKearl]

Hm interesting, I didn't notice the quick fix, and I see I did have:

"js/ts.implicitProjectConfig.checkJs": true,
"js/ts.implicitProjectConfig.strictNullChecks": true,

globally configured.

So I guess this is pretty reasonable, I'd be fine to just close it out.

[andrewbranch]

This is very much something we have tried / are trying / would like to solve; there's an experiment up at #40466 and design notes at #40505. I do think we should probably modify the error message for JS files though. (But it would be better if we could just not error 😕.)

[andrewbranch]

@DanielRosenwasser @rbuckton what should this message even say in JS? We should at least ditch the “did you forget” language, since what we’re asking JS users to do is pretty weird.

[DanielRosenwasser]

Maybe

Expected 1 arguments but got 0. TypeScript may need a hint that the call to 'new Promise()' produces a 'Promise<void>'.

[andrewbranch]

+JSDoc?

Expected 1 arguments but got 0. TypeScript may need a JSDoc hint that the call to 'new Promise()' produces a 'Promise<void>'.