Bad callsite inferences fall back to body usage (microsoft#28235)

sandersn · web-flow · commit 0481d44501c4 · 2018-10-30T13:25:24.000-07:00
For parameters, the infer-from-usage codefix uses a substantially
different codepath that previously only looked at call site uses. When
this resulted in no inferences, or bad inferences, for a single
parameter, the codefix would just use any. Only if no usages of a
function were found would the codefix use the body-inference
code.

This commit makes parameter inference fall back to body-inference code
for individual parameters when there is no inference or inference to
any.
diff --git a/src/services/codefixes/inferFromUsage.ts b/src/services/codefixes/inferFromUsage.ts
@@ -349,7 +349,7 @@ namespace ts.codefix {
                     findChildOfKind<Token<SyntaxKind.ConstructorKeyword>>(containingFunction, SyntaxKind.ConstructorKeyword, sourceFile) :
                     containingFunction.name;
                 if (searchToken) {
-                    return InferFromReference.inferTypeForParametersFromReferences(getReferences(searchToken, program, cancellationToken), containingFunction, program.getTypeChecker(), cancellationToken);
+                    return InferFromReference.inferTypeForParametersFromReferences(getReferences(searchToken, program, cancellationToken), containingFunction, program, cancellationToken);
                 }
         }
     }
@@ -387,7 +387,8 @@ namespace ts.codefix {
             return getTypeFromUsageContext(usageContext, checker) || checker.getAnyType();
         }
 
-        export function inferTypeForParametersFromReferences(references: ReadonlyArray<Identifier>, declaration: FunctionLikeDeclaration, checker: TypeChecker, cancellationToken: CancellationToken): ParameterInference[] | undefined {
+        export function inferTypeForParametersFromReferences(references: ReadonlyArray<Identifier>, declaration: FunctionLikeDeclaration, program: Program, cancellationToken: CancellationToken): ParameterInference[] | undefined {
+            const checker = program.getTypeChecker();
             if (references.length === 0) {
                 return undefined;
             }
@@ -422,10 +423,14 @@ namespace ts.codefix {
                         types.push(checker.getBaseTypeOfLiteralType(callContext.argumentTypes[parameterIndex]));
                     }
                 }
-                if (!types.length) {
-                    return { declaration: parameter, type: checker.getAnyType() };
+
+                let type = types.length && checker.getWidenedType(checker.getUnionType(types, UnionReduction.Subtype));
+                if ((!type || type.flags & TypeFlags.Any) && isIdentifier(parameter.name)) {
+                    type = inferTypeForVariableFromUsage(parameter.name, program, cancellationToken);
+                }
+                if (!type) {
+                    type = checker.getAnyType();
                 }
-                const type = checker.getWidenedType(checker.getUnionType(types, UnionReduction.Subtype));
                 return {
                     type: isRest ? checker.createArrayType(type) : type,
                     isOptional: isOptional && !isRest,
diff --git a/tests/cases/fourslash/codeFixInferFromUsageCallBodyPriority.ts b/tests/cases/fourslash/codeFixInferFromUsageCallBodyPriority.ts
@@ -0,0 +1,18 @@
+/// <reference path='fourslash.ts' />
+// based on acorn
+
+////function isIdentifierStart([|code, astral |]) {
+////  if (code < 65) { return code === 36 }
+////  if (code < 91) { return true }
+////  if (code < 97) { return code === 95 }
+////  if (code < 123) { return true }
+////  if (code <= 0xffff) { return code >= 0xaa }
+////  if (astral === false) { return false }
+////}
+////
+////function isLet(nextCh: any) {
+////    return isIdentifierStart(nextCh, true)
+////};
+
+
+verify.rangeAfterCodeFix("code: number, astral: boolean",/*includeWhiteSpace*/ undefined, /*errorCode*/ undefined, 0);

Original file line number	Diff line number	Diff line change
`@@ -349,7 +349,7 @@ namespace ts.codefix {`
`349`	`349`	`findChildOfKind<Token<SyntaxKind.ConstructorKeyword>>(containingFunction, SyntaxKind.ConstructorKeyword, sourceFile) :`
`350`	`350`	`containingFunction.name;`
`351`	`351`	`if (searchToken) {`
`352`		`- return InferFromReference.inferTypeForParametersFromReferences(getReferences(searchToken, program, cancellationToken), containingFunction, program.getTypeChecker(), cancellationToken);`
	`352`	`+ return InferFromReference.inferTypeForParametersFromReferences(getReferences(searchToken, program, cancellationToken), containingFunction, program, cancellationToken);`
`353`	`353`	`}`
`354`	`354`	`}`
`355`	`355`	`}`
`@@ -387,7 +387,8 @@ namespace ts.codefix {`
`387`	`387`	`return getTypeFromUsageContext(usageContext, checker) \|\| checker.getAnyType();`
`388`	`388`	`}`
`389`	`389`
`390`		`- export function inferTypeForParametersFromReferences(references: ReadonlyArray<Identifier>, declaration: FunctionLikeDeclaration, checker: TypeChecker, cancellationToken: CancellationToken): ParameterInference[] \| undefined {`
	`390`	`+ export function inferTypeForParametersFromReferences(references: ReadonlyArray<Identifier>, declaration: FunctionLikeDeclaration, program: Program, cancellationToken: CancellationToken): ParameterInference[] \| undefined {`
	`391`	`+ const checker = program.getTypeChecker();`
`391`	`392`	`if (references.length === 0) {`
`392`	`393`	`return undefined;`
`393`	`394`	`}`
`@@ -422,10 +423,14 @@ namespace ts.codefix {`
`422`	`423`	`types.push(checker.getBaseTypeOfLiteralType(callContext.argumentTypes[parameterIndex]));`
`423`	`424`	`}`
`424`	`425`	`}`
`425`		`- if (!types.length) {`
`426`		`- return { declaration: parameter, type: checker.getAnyType() };`
	`426`	`+`
	`427`	`+ let type = types.length && checker.getWidenedType(checker.getUnionType(types, UnionReduction.Subtype));`
	`428`	`+ if ((!type \|\| type.flags & TypeFlags.Any) && isIdentifier(parameter.name)) {`
	`429`	`+ type = inferTypeForVariableFromUsage(parameter.name, program, cancellationToken);`
	`430`	`+ }`
	`431`	`+ if (!type) {`
	`432`	`+ type = checker.getAnyType();`
`427`	`433`	`}`
`428`		`- const type = checker.getWidenedType(checker.getUnionType(types, UnionReduction.Subtype));`
`429`	`434`	`return {`
`430`	`435`	`type: isRest ? checker.createArrayType(type) : type,`
`431`	`436`	`isOptional: isOptional && !isRest,`