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