JavaScriptBench
diff --git a/Collapse file
‎src/compiler/checker.ts‎
Copy file name to clipboardExpand all lines: src/compiler/checker.ts
+12-4Lines changed: 12 additions & 4 deletions b/Collapse file
‎src/compiler/checker.ts‎
Copy file name to clipboardExpand all lines: src/compiler/checker.ts
+12-4Lines changed: 12 additions & 4 deletions
diff --git a/Collapse file
‎src/compiler/core.ts‎
Copy file name to clipboardExpand all lines: src/compiler/core.ts
+4Lines changed: 4 additions & 0 deletions b/Collapse file
‎src/compiler/core.ts‎
Copy file name to clipboardExpand all lines: src/compiler/core.ts
+4Lines changed: 4 additions & 0 deletions
diff --git a/Collapse file
‎src/compiler/types.ts‎
Copy file name to clipboardExpand all lines: src/compiler/types.ts
+4-1Lines changed: 4 additions & 1 deletion b/Collapse file
‎src/compiler/types.ts‎
Copy file name to clipboardExpand all lines: src/compiler/types.ts
+4-1Lines changed: 4 additions & 1 deletion
@@ -4326,10 +4326,13 @@ namespace ts {
 
         function getTypeWithThisArgument(type: Type, thisArgument?: Type): Type {
             if (getObjectFlags(type) & ObjectFlags.Reference) {
-                return createTypeReference((<TypeReference>type).target,
-                    concatenate((<TypeReference>type).typeArguments, [thisArgument || (<TypeReference>type).target.thisType]));
+                const target = (<TypeReference>type).target;
+                const typeArguments = (<TypeReference>type).typeArguments;
+                if (length(target.typeParameters) === length(typeArguments)) {
+                    return createTypeReference(target, concatenate(typeArguments, [thisArgument || target.thisType]));
+                }
             }
-            if (type.flags & TypeFlags.Intersection) {
+            else if (type.flags & TypeFlags.Intersection) {
                 return getIntersectionType(map((<IntersectionType>type).types, t => getTypeWithThisArgument(t, thisArgument)));
             }
             return type;
@@ -4858,14 +4861,19 @@ namespace ts {
             }
         }
 
+        function getApparentTypeOfIntersectionType(type: IntersectionType) {
+            return type.resolvedIndexType || (type.resolvedApparentType = getTypeWithThisArgument(type, type));
+        }
+
         /**
          * For a type parameter, return the base constraint of the type parameter. For the string, number,
          * boolean, and symbol primitive types, return the corresponding object types. Otherwise return the
          * type itself. Note that the apparent type of a union type is the union type itself.
          */
         function getApparentType(type: Type): Type {
             const t = type.flags & TypeFlags.TypeVariable ? getBaseConstraintOfType(<TypeVariable>type) || emptyObjectType : type;
-            return t.flags & TypeFlags.StringLike ? globalStringType :
+            return t.flags & TypeFlags.Intersection ? getApparentTypeOfIntersectionType(<IntersectionType>type) :
+                t.flags & TypeFlags.StringLike ? globalStringType :
                 t.flags & TypeFlags.NumberLike ? globalNumberType :
                 t.flags & TypeFlags.BooleanLike ? globalBooleanType :
                 t.flags & TypeFlags.ESSymbol ? getGlobalESSymbolType() :
 
@@ -202,6 +202,10 @@ namespace ts {
         GreaterThan = 1
     }
 
+    export function length(array: any[]) {
+        return array ? array.length : 0;
+    }
+
     /**
      * Iterates through 'array' by index and performs the callback on each element of array until the callback
      * returns a truthy value, then returns that value.
 
@@ -2961,7 +2961,10 @@
 
     export interface UnionType extends UnionOrIntersectionType { }
 
-    export interface IntersectionType extends UnionOrIntersectionType { }
+    export interface IntersectionType extends UnionOrIntersectionType {
+        /* @internal */
+        resolvedApparentType: Type;
+    }
 
     export type StructuredType = ObjectType | UnionType | IntersectionType;