Only contextually type expressions of calls

Also allocate once instead of twice.

Author: sandersn

src/compiler/checker.ts

@@ -8525,9 +8525,13 @@ namespace ts {
                     const indexOfParameter = indexOf(func.parameters, parameter);
                     if (iife.arguments && indexOfParameter < iife.arguments.length) {
                         if (parameter.dotDotDotToken) {
-                            return createArrayType(getUnionType(map(iife.arguments.slice(indexOfParameter), getTypeOfExpression)));
+                            const restTypes: Type[] = [];
+                            for (let i = indexOfParameter; i < iife.arguments.length; i++) {
+                                restTypes.push(getTypeOfExpression(iife.arguments[i]));
+                            }
+                            return createArrayType(getUnionType(restTypes));
                         }
-                        return checkExpression(iife.arguments[indexOfParameter], identityMapper);
+                        return checkExpression(iife.arguments[indexOfParameter]);
                     }
                 }
                 const contextualSignature = getContextualSignature(func);
@@ -8552,11 +8556,13 @@ namespace ts {
 
         function getImmediatelyInvokedFunctionExpression(func: FunctionExpression | MethodDeclaration) {
             if (isFunctionExpressionOrArrowFunction(func)) {
-                let parent = func.parent;
+                let prev: Node = func;
+                let parent: Node = func.parent;
                 while (parent.kind === SyntaxKind.ParenthesizedExpression) {
+                    prev = parent;
                     parent = parent.parent;
                 }
-                if (parent.kind === SyntaxKind.CallExpression) {
+                if (parent.kind === SyntaxKind.CallExpression && (parent as CallExpression).expression === prev) {
                     return parent as CallExpression;
                 }
             }

tests/baselines/reference/contextuallyTypedIife.types

@@ -223,26 +223,26 @@
 let twelve = (f => f(12))(i => i);
 >twelve : any
 >(f => f(12))(i => i) : any
->(f => f(12)) : (f: {}) => any
->f => f(12) : (f: {}) => any
->f : {}
+>(f => f(12)) : (f: (i: any) => any) => any
+>f => f(12) : (f: (i: any) => any) => any
+>f : (i: any) => any
 >f(12) : any
->f : {}
+>f : (i: any) => any
 >12 : number
->i => i : (i: {}) => {}
->i : {}
->i : {}
+>i => i : (i: any) => any
+>i : any
+>i : any
 
 let eleven = (o => o.a(11))({ a: function(n) { return n; } });
 >eleven : any
 >(o => o.a(11))({ a: function(n) { return n; } }) : any
->(o => o.a(11)) : (o: { a: {}; }) => any
->o => o.a(11) : (o: { a: {}; }) => any
->o : { a: {}; }
+>(o => o.a(11)) : (o: { a: (n: any) => any; }) => any
+>o => o.a(11) : (o: { a: (n: any) => any; }) => any
+>o : { a: (n: any) => any; }
 >o.a(11) : any
->o.a : {}
->o : { a: {}; }
->a : {}
+>o.a : (n: any) => any
+>o : { a: (n: any) => any; }
+>a : (n: any) => any
 >11 : number
 >{ a: function(n) { return n; } } : { a: (n: any) => any; }
 >a : (n: any) => any