Discussion: Parameter type inference from function body

src/compiler/checker.ts

@@ -4298,7 +4298,7 @@ namespace ts {
                     type = getContextualThisParameterType(func);
                 }
                 else {
-                    type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration);
+                    type = getContextuallyTypedParameterType(<ParameterDeclaration>declaration)
                 }
                 if (type) {
                     return addOptionality(type, /*optional*/ declaration.questionToken && includeOptionality);
@@ -4327,6 +4327,12 @@ namespace ts {
                 return getTypeFromBindingPattern(<BindingPattern>declaration.name, /*includePatternInType*/ false, /*reportErrors*/ true);
             }
 
+            // Important to do this *after* attempt has been made to resolve via initializer
+            if (declaration.kind === SyntaxKind.Parameter) {
+                const inferredType = getParameterTypeFromBody(<ParameterDeclaration>declaration)
+                if (inferredType) return inferredType
+            }
+
             // No type specified and nothing can be inferred
             return undefined;
         }
@@ -12798,6 +12804,20 @@ namespace ts {
             return undefined;
         }
 
+        function getParameterTypeFromBody(parameter: ParameterDeclaration): Type {
+            const func = <FunctionLikeDeclaration>parameter.parent
+            if (!func.body) {
+                return unknownType;
+            }
+
+            let type: Type;
+            let types: Type[];
+            types = checkAndAggregateParameterExpressionTypes(parameter)
+            type = types ? getWidenedType(getIntersectionType(types)) : undefined;
+
+            return type;
+        }
+
         // Return contextual type of parameter or undefined if no contextual type is available
         function getContextuallyTypedParameterType(parameter: ParameterDeclaration): Type {
             const func = parameter.parent;
@@ -16729,6 +16749,24 @@ namespace ts {
             return true;
         }
 
+        function checkAndAggregateParameterExpressionTypes(parameter: ParameterDeclaration): Type[] {
+            const func = <FunctionLikeDeclaration>parameter.parent
+            const usageTypes: Type[] = []
+            forEachInvocation(<Block>func.body, invocation => {
+                const usages = invocation.arguments
+                    .map((arg, i) => ({ arg, symbol: getSymbolAtLocation(arg), i }))
+                    .filter(({ symbol }) => symbol && symbol.valueDeclaration === parameter)
+                if (!usages.length) return
+                const funcSymbol = getSymbolAtLocation(invocation.expression)
+                if (!funcSymbol) return
+                const sig = getSignatureFromDeclaration(funcSymbol.valueDeclaration as FunctionLikeDeclaration)
+                const parameterTypes = sig.parameters.map(getTypeOfParameter)
+                const argumentTypes = usages.map(({ i }) => parameterTypes[i])
+                usageTypes.splice(0, 0, ...argumentTypes);
+            });
+            return usageTypes.length ? usageTypes : undefined;
+        }
+
         function checkAndAggregateReturnExpressionTypes(func: FunctionLikeDeclaration, checkMode: CheckMode): Type[] {
             const functionFlags = getFunctionFlags(func);
             const aggregatedTypes: Type[] = [];

src/compiler/utilities.ts

@@ -757,6 +757,20 @@ namespace ts {
         return false;
     }
 
+    export function forEachInvocation<T>(body: Block, visitor: (stmt: CallExpression) => T): T {
+
+        return traverse(body);
+
+        function traverse(node: Node): T {
+            switch (node.kind) {
+                case SyntaxKind.CallExpression:
+                    return visitor(<CallExpression>node)
+                default:
+                    return forEachChild(node, traverse);
+            }
+        }
+    }
+
     // Warning: This has the same semantics as the forEach family of functions,
     //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
     export function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {

tests/cases/compiler/parameterInference.ts

@@ -0,0 +1,22 @@
+// CASE 1
+function foo(s) {
+    Math.sqrt(s)
+}
+
+// CASE 2
+declare function swapNumberString(n: string): number;
+declare function swapNumberString(n: number): string;
+
+// Should have identical signature to swapNumberString
+function subs(s) {
+  return swapNumberString(s);
+}
+
+// CASE 3
+function f(x: number){
+   return x;
+}
+
+function g(x){ return x};
+
+function h(x){ return f(x); };