diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 63e02b9b82677..60afaf9e4c5e7 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4997,7 +4997,7 @@ namespace ts {
         function getInstantiatedConstructorsForTypeArguments(type: Type, typeArgumentNodes: ReadonlyArray<TypeNode>, location: Node): Signature[] {
             const signatures = getConstructorsForTypeArguments(type, typeArgumentNodes, location);
             const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
-            return sameMap(signatures, sig => some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, isInJavaScriptFile(location)) : sig);
+            return sameMap(signatures, sig => some(sig.typeParameters) ? getSignatureInstantiation(sig, typeArguments, isInJavaScriptFile(location), /*errorArityLocation*/ undefined) : sig);
         }
 
         /**
@@ -5799,17 +5799,13 @@ namespace ts {
             const baseTypeNode = getBaseTypeNodeOfClass(classType);
             const isJavaScript = isInJavaScriptFile(baseTypeNode);
             const typeArguments = typeArgumentsFromTypeReferenceNode(baseTypeNode);
-            const typeArgCount = length(typeArguments);
             const result: Signature[] = [];
             for (const baseSig of baseSignatures) {
-                const minTypeArgumentCount = getMinTypeArgumentCount(baseSig.typeParameters);
                 const typeParamCount = length(baseSig.typeParameters);
-                if (isJavaScript || (typeArgCount >= minTypeArgumentCount && typeArgCount <= typeParamCount)) {
-                    const sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, minTypeArgumentCount, isJavaScript)) : cloneSignature(baseSig);
-                    sig.typeParameters = classType.localTypeParameters;
-                    sig.resolvedReturnType = classType;
-                    result.push(sig);
-                }
+                const sig = typeParamCount ? createSignatureInstantiation(baseSig, fillMissingTypeArguments(typeArguments, baseSig.typeParameters, isJavaScript)) : cloneSignature(baseSig);
+                sig.typeParameters = classType.localTypeParameters;
+                sig.resolvedReturnType = classType;
+                result.push(sig);
             }
             return result;
         }
@@ -6700,32 +6696,39 @@ namespace ts {
          * @param typeArguments The supplied type arguments.
          * @param typeParameters The requested type parameters.
          * @param minTypeArgumentCount The minimum number of required type arguments.
+         * @param isJs Should JS-specific behaviors be used for missing type arguments (eg, `any` instead of `{}`)
+         * @param generateDiagnistic Callback which, if present, is called to add an error for an arity error
          */
-        function fillMissingTypeArguments(typeArguments: Type[] | undefined, typeParameters: TypeParameter[] | undefined, minTypeArgumentCount: number, isJavaScriptImplicitAny: boolean) {
+        function fillMissingTypeArguments(typeArguments: Type[] | undefined, typeParameters: TypeParameter[] | undefined, isJs: boolean, generateDiagnostic?: (minTypeArgCount: number, typeParameterLength: number) => void) {
             const numTypeParameters = length(typeParameters);
-            if (numTypeParameters) {
+            const numTypeArguments = length(typeArguments);
+            if (typeParameters && generateDiagnostic) {
                 const numTypeArguments = length(typeArguments);
-                if (isJavaScriptImplicitAny || (numTypeArguments >= minTypeArgumentCount && numTypeArguments <= numTypeParameters)) {
-                    if (!typeArguments) {
-                        typeArguments = [];
-                    }
+                const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
+                if (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length) {
+                    generateDiagnostic(minTypeArgumentCount, numTypeParameters);
+                }
+            }
+            if (numTypeParameters) {
+                if (!typeArguments) {
+                    typeArguments = [];
+                }
 
-                    // Map an unsatisfied type parameter with a default type.
-                    // If a type parameter does not have a default type, or if the default type
-                    // is a forward reference, the empty object type is used.
-                    for (let i = numTypeArguments; i < numTypeParameters; i++) {
-                        typeArguments[i] = getDefaultTypeArgumentType(isJavaScriptImplicitAny);
-                    }
-                    for (let i = numTypeArguments; i < numTypeParameters; i++) {
-                        const mapper = createTypeMapper(typeParameters, typeArguments);
-                        let defaultType = getDefaultFromTypeParameter(typeParameters[i]);
-                        if (defaultType && isTypeIdenticalTo(defaultType, emptyObjectType) && isJavaScriptImplicitAny) {
-                            defaultType = anyType;
-                        }
-                        typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : getDefaultTypeArgumentType(isJavaScriptImplicitAny);
+                // Map an unsatisfied type parameter with a default type.
+                // If a type parameter does not have a default type, or if the default type
+                // is a forward reference, the empty object type is used.
+                for (let i = numTypeArguments; i < numTypeParameters; i++) {
+                    typeArguments[i] = getDefaultTypeArgumentType(isJs);
+                }
+                for (let i = numTypeArguments; i < numTypeParameters; i++) {
+                    const mapper = createTypeMapper(typeParameters, typeArguments);
+                    let defaultType = getDefaultFromTypeParameter(typeParameters[i]);
+                    if (defaultType && isTypeIdenticalTo(defaultType, emptyObjectType) && isJs) {
+                        defaultType = anyType;
                     }
-                    typeArguments.length = typeParameters.length;
+                    typeArguments[i] = defaultType ? instantiateType(defaultType, mapper) : getDefaultTypeArgumentType(isJs);
                 }
+                typeArguments.length = typeParameters.length;
             }
             return typeArguments;
         }
@@ -6980,8 +6983,14 @@ namespace ts {
             return anyType;
         }
 
-        function getSignatureInstantiation(signature: Signature, typeArguments: Type[], isJavascript: boolean): Signature {
-            typeArguments = fillMissingTypeArguments(typeArguments, signature.typeParameters, getMinTypeArgumentCount(signature.typeParameters), isJavascript);
+        function getSignatureInstantiation(signature: Signature, typeArguments: Type[], isJavascript: boolean, arityErrorLocation: Node | undefined): Signature {
+            typeArguments = fillMissingTypeArguments(typeArguments, signature.typeParameters, isJavascript, arityErrorLocation ? (min, max) => {
+                const diag = min === max
+                    ? Diagnostics.Generic_type_0_requires_1_type_argument_s
+                    : Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments;
+                    const s = symbolToString(signature.declaration.symbol);
+                error(arityErrorLocation, diag, s, min, max);
+            } : undefined);
             const instantiations = signature.instantiations || (signature.instantiations = createMap<Signature>());
             const id = getTypeListId(typeArguments);
             let instantiation = instantiations.get(id);
@@ -7022,7 +7031,9 @@ namespace ts {
             return getSignatureInstantiation(
                 signature,
                 map(signature.typeParameters, tp => tp.target && !getConstraintOfTypeParameter(tp.target) ? tp.target : tp),
-                isInJavaScriptFile(signature.declaration));
+                isInJavaScriptFile(signature.declaration),
+                signature.declaration
+            );
         }
 
         function getBaseSignature(signature: Signature) {
@@ -7181,11 +7192,10 @@ namespace ts {
             const type = <InterfaceType>getDeclaredTypeOfSymbol(getMergedSymbol(symbol));
             const typeParameters = type.localTypeParameters;
             if (typeParameters) {
-                const numTypeArguments = length(node.typeArguments);
                 const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
                 const isJs = isInJavaScriptFile(node);
                 const isJsImplicitAny = !noImplicitAny && isJs;
-                if (!isJsImplicitAny && (numTypeArguments < minTypeArgumentCount || numTypeArguments > typeParameters.length)) {
+                const generateDiagnistic = !isJsImplicitAny ? (min: number, max: number) => {
                     const missingAugmentsTag = isJs && node.parent.kind !== SyntaxKind.JSDocAugmentsTag;
                     const diag = minTypeArgumentCount === typeParameters.length
                         ? missingAugmentsTag
@@ -7195,16 +7205,12 @@ namespace ts {
                             ? Diagnostics.Expected_0_1_type_arguments_provide_these_with_an_extends_tag
                             : Diagnostics.Generic_type_0_requires_between_1_and_2_type_arguments;
                     const typeStr = typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType);
-                    error(node, diag, typeStr, minTypeArgumentCount, typeParameters.length);
-                    if (!isJs) {
-                        // TODO: Adopt same permissive behavior in TS as in JS to reduce follow-on editing experience failures (requires editing fillMissingTypeArguments)
-                        return unknownType;
-                    }
-                }
+                    error(node, diag, typeStr, min, max);
+                } : undefined;
                 // In a type reference, the outer type parameters of the referenced class or interface are automatically
                 // supplied as type arguments and the type reference only specifies arguments for the local type parameters
                 // of the class or interface.
-                const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgs, typeParameters, minTypeArgumentCount, isJs));
+                const typeArguments = concatenate(type.outerTypeParameters, fillMissingTypeArguments(typeArgs, typeParameters, isJs, generateDiagnistic));
                 return createTypeReference(<GenericType>type, typeArguments);
             }
             if (node.typeArguments) {
@@ -7221,7 +7227,7 @@ namespace ts {
             const id = getTypeListId(typeArguments);
             let instantiation = links.instantiations.get(id);
             if (!instantiation) {
-                links.instantiations.set(id, instantiation = instantiateType(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, getMinTypeArgumentCount(typeParameters), isInJavaScriptFile(symbol.valueDeclaration)))));
+                links.instantiations.set(id, instantiation = instantiateType(type, createTypeMapper(typeParameters, fillMissingTypeArguments(typeArguments, typeParameters, isInJavaScriptFile(symbol.valueDeclaration)))));
             }
             return instantiation;
         }
@@ -14876,8 +14882,7 @@ namespace ts {
             for (const signature of signatures) {
                 if (signature.typeParameters) {
                     const isJavascript = isInJavaScriptFile(node);
-                    const typeArguments = fillMissingTypeArguments(/*typeArguments*/ undefined, signature.typeParameters, /*minTypeArgumentCount*/ 0, isJavascript);
-                    instantiatedSignatures.push(getSignatureInstantiation(signature, typeArguments, isJavascript));
+                    instantiatedSignatures.push(getSignatureInstantiation(signature, /*typeArguments*/ undefined, isJavascript, /**/ undefined));
                 }
                 else {
                     instantiatedSignatures.push(signature);
@@ -16184,7 +16189,7 @@ namespace ts {
             if (!contextualMapper) {
                 inferTypes(context.inferences, getReturnTypeOfSignature(contextualSignature), getReturnTypeOfSignature(signature), InferencePriority.ReturnType);
             }
-            return getSignatureInstantiation(signature, getInferredTypes(context), isInJavaScriptFile(contextualSignature.declaration));
+            return getSignatureInstantiation(signature, getInferredTypes(context), isInJavaScriptFile(contextualSignature.declaration), /*arityErrorLocation*/ undefined);
         }
 
         function inferTypeArguments(node: CallLikeExpression, signature: Signature, args: ReadonlyArray<Expression>, excludeArgument: boolean[], context: InferenceContext): Type[] {
@@ -16219,7 +16224,7 @@ namespace ts {
                     // Above, the type of the 'value' parameter is inferred to be 'A'.
                     const contextualSignature = getSingleCallSignature(instantiatedType);
                     const inferenceSourceType = contextualSignature && contextualSignature.typeParameters ?
-                        getOrCreateTypeFromSignature(getSignatureInstantiation(contextualSignature, contextualSignature.typeParameters, isInJavaScriptFile(node))) :
+                        getOrCreateTypeFromSignature(getSignatureInstantiation(contextualSignature, contextualSignature.typeParameters, isInJavaScriptFile(node), /*arityErrorLocation*/ undefined)) :
                         instantiatedType;
                     const inferenceTargetType = getReturnTypeOfSignature(signature);
                      // Inferences made from return types have lower priority than all other inferences.
@@ -16278,7 +16283,8 @@ namespace ts {
         function checkTypeArguments(signature: Signature, typeArgumentNodes: ReadonlyArray<TypeNode>, reportErrors: boolean, headMessage?: DiagnosticMessage): Type[] | false {
             const isJavascript = isInJavaScriptFile(signature.declaration);
             const typeParameters = signature.typeParameters;
-            const typeArgumentTypes = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isJavascript);
+            const typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
+            const typeArgumentTypes = fillMissingTypeArguments(typeArguments, typeParameters, isJavascript);
             let mapper: TypeMapper;
             for (let i = 0; i < typeArgumentNodes.length; i++) {
                 Debug.assert(typeParameters[i] !== undefined, "Should not call checkTypeArguments with too many type arguments");
@@ -16949,7 +16955,7 @@ namespace ts {
                                 typeArgumentTypes = inferTypeArguments(node, candidate, args, excludeArgument, inferenceContext);
                             }
                             const isJavascript = isInJavaScriptFile(candidate.declaration);
-                            candidate = getSignatureInstantiation(candidate, typeArgumentTypes, isJavascript);
+                            candidate = getSignatureInstantiation(candidate, typeArgumentTypes, isJavascript, /*arityErrorLocation*/ undefined);
                         }
                         if (!checkApplicableSignature(node, args, candidate, relation, excludeArgument, /*reportErrors*/ false)) {
                             candidateForArgumentError = candidate;
@@ -16999,7 +17005,16 @@ namespace ts {
                     // with the type arguments specified in the extends clause.
                     const baseTypeNode = getClassExtendsHeritageClauseElement(getContainingClass(node));
                     if (baseTypeNode) {
-                        const baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
+                        let baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments, baseTypeNode);
+                        if (!some(baseConstructors)) {
+                            // Attempt some graceful error recovery if there are no constructors of appropriate arity by falling back to a different arity
+                            baseConstructors = sameMap(
+                                getSignaturesOfType(superType, SignatureKind.Construct),
+                                sig => some(sig.typeParameters)
+                                    ? getSignatureInstantiation(sig, map(baseTypeNode.typeArguments, getTypeFromTypeNode), isInJavaScriptFile(baseTypeNode), /*errorArityLocation*/ undefined)
+                                    : sig
+                            );
+                        }
                         return resolveCall(node, baseConstructors, candidatesOutArray);
                     }
                 }
@@ -19747,15 +19762,14 @@ namespace ts {
         }
 
         function checkTypeArgumentConstraints(typeParameters: TypeParameter[], typeArgumentNodes: ReadonlyArray<TypeNode>): boolean {
-            const minTypeArgumentCount = getMinTypeArgumentCount(typeParameters);
             let typeArguments: Type[];
             let mapper: TypeMapper;
             let result = true;
-            for (let i = 0; i < typeParameters.length; i++) {
+            for (let i = 0; i < length(typeParameters); i++) {
                 const constraint = getConstraintOfTypeParameter(typeParameters[i]);
                 if (constraint) {
                     if (!typeArguments) {
-                        typeArguments = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, minTypeArgumentCount, isInJavaScriptFile(typeArgumentNodes[i]));
+                        typeArguments = fillMissingTypeArguments(map(typeArgumentNodes, getTypeFromTypeNode), typeParameters, isInJavaScriptFile(typeArgumentNodes[i]));
                         mapper = createTypeMapper(typeParameters, typeArguments);
                     }
                     const typeArgument = typeArguments[i];
@@ -22451,7 +22465,7 @@ namespace ts {
                     checkSourceElement(baseTypeNode.expression);
                     if (some(baseTypeNode.typeArguments)) {
                         forEach(baseTypeNode.typeArguments, checkSourceElement);
-                        for (const constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments, baseTypeNode)) {
+                        for (const constructor of getSignaturesOfType(staticBaseType, SignatureKind.Construct)) {
                             if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) {
                                 break;
                             }
diff --git a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types
index ea4803c024475..e033172925dc5 100644
--- a/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types
+++ b/tests/baselines/reference/arrayLiteralAndArrayConstructorEquivalence1.types
@@ -11,7 +11,7 @@ var myCars3 = new Array({});
 >{} : {}
 
 var myCars4: Array; // error
->myCars4 : any
+>myCars4 : {}[]
 >Array : T[]
 
 var myCars5: Array<any>[];
@@ -24,9 +24,9 @@ myCars = myCars3;
 >myCars3 : {}[]
 
 myCars = myCars4;
->myCars = myCars4 : any
+>myCars = myCars4 : {}[]
 >myCars : any[]
->myCars4 : any
+>myCars4 : {}[]
 
 myCars = myCars5;
 >myCars = myCars5 : any[][]
@@ -39,9 +39,9 @@ myCars3 = myCars;
 >myCars : any[]
 
 myCars3 = myCars4;
->myCars3 = myCars4 : any
+>myCars3 = myCars4 : {}[]
 >myCars3 : {}[]
->myCars4 : any
+>myCars4 : {}[]
 
 myCars3 = myCars5;   
 >myCars3 = myCars5 : any[][]
diff --git a/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types b/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types
index a4931c1c2cc30..5d803ae7a9432 100644
--- a/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types
+++ b/tests/baselines/reference/arrayReferenceWithoutTypeArgs.types
@@ -3,7 +3,7 @@ class X {
 >X : X
 
     public f(a: Array) { }
->f : (a: any) => void
->a : any
+>f : (a: {}[]) => void
+>a : {}[]
 >Array : T[]
 }
diff --git a/tests/baselines/reference/emptyGenericParamList.types b/tests/baselines/reference/emptyGenericParamList.types
index 9a225d07cc0c4..7fc61eb824b0e 100644
--- a/tests/baselines/reference/emptyGenericParamList.types
+++ b/tests/baselines/reference/emptyGenericParamList.types
@@ -4,6 +4,6 @@ class I<T> {}
 >T : T
 
 var x: I<>;
->x : any
+>x : I<{}>
 >I : I<T>
 
diff --git a/tests/baselines/reference/externalModuleExportingGenericClass.types b/tests/baselines/reference/externalModuleExportingGenericClass.types
index 77dbb393d180f..3778fb38dd571 100644
--- a/tests/baselines/reference/externalModuleExportingGenericClass.types
+++ b/tests/baselines/reference/externalModuleExportingGenericClass.types
@@ -3,7 +3,7 @@ import a = require('./externalModuleExportingGenericClass_file0');
 >a : typeof a
 
 var v: a; // this should report error
->v : any
+>v : a<{}>
 >a : a<T>
 
 var v2: any = (new a()).foo;
diff --git a/tests/baselines/reference/genericArrayAssignmentCompatErrors.types b/tests/baselines/reference/genericArrayAssignmentCompatErrors.types
index 2db5f4a28aecb..ebd58b588a722 100644
--- a/tests/baselines/reference/genericArrayAssignmentCompatErrors.types
+++ b/tests/baselines/reference/genericArrayAssignmentCompatErrors.types
@@ -16,7 +16,7 @@ var myCars3 = new Array({});
 >{} : {}
 
 var myCars4: Array; // error
->myCars4 : any
+>myCars4 : {}[]
 >Array : T[]
 
 var myCars5: Array<any>[];
@@ -34,9 +34,9 @@ myCars = myCars3;
 >myCars3 : {}[]
 
 myCars = myCars4;
->myCars = myCars4 : any
+>myCars = myCars4 : {}[]
 >myCars : any[]
->myCars4 : any
+>myCars4 : {}[]
 
 myCars = myCars5;
 >myCars = myCars5 : any[][]
@@ -54,9 +54,9 @@ myCars2 = myCars3;
 >myCars3 : {}[]
 
 myCars2 = myCars4;
->myCars2 = myCars4 : any
+>myCars2 = myCars4 : {}[]
 >myCars2 : any
->myCars4 : any
+>myCars4 : {}[]
 
 myCars2 = myCars5;
 >myCars2 = myCars5 : any[][]
@@ -74,9 +74,9 @@ myCars3 = myCars2;
 >myCars2 : any
 
 myCars3 = myCars4;
->myCars3 = myCars4 : any
+>myCars3 = myCars4 : {}[]
 >myCars3 : {}[]
->myCars4 : any
+>myCars4 : {}[]
 
 myCars3 = myCars5;   
 >myCars3 = myCars5 : any[][]
diff --git a/tests/baselines/reference/genericArrayWithoutTypeAnnotation.types b/tests/baselines/reference/genericArrayWithoutTypeAnnotation.types
index 28342eccc2054..349de2c0279ff 100644
--- a/tests/baselines/reference/genericArrayWithoutTypeAnnotation.types
+++ b/tests/baselines/reference/genericArrayWithoutTypeAnnotation.types
@@ -7,8 +7,8 @@ class Bar {
 >Bar : Bar
 
     public getBar(foo: IFoo[]) {
->getBar : (foo: any[]) => void
->foo : any[]
+>getBar : (foo: IFoo<{}>[]) => void
+>foo : IFoo<{}>[]
 >IFoo : IFoo<T>
     }
 }
diff --git a/tests/baselines/reference/genericCloduleInModule2.symbols b/tests/baselines/reference/genericCloduleInModule2.symbols
index 88d81d654d9e6..c6d0032091f07 100644
--- a/tests/baselines/reference/genericCloduleInModule2.symbols
+++ b/tests/baselines/reference/genericCloduleInModule2.symbols
@@ -31,5 +31,7 @@ var b: A.B;
 >B : Symbol(A.B, Decl(genericCloduleInModule2.ts, 0, 10), Decl(genericCloduleInModule2.ts, 7, 10))
 
 b.foo();
+>b.foo : Symbol(A.B.foo, Decl(genericCloduleInModule2.ts, 1, 23))
 >b : Symbol(b, Decl(genericCloduleInModule2.ts, 13, 3))
+>foo : Symbol(A.B.foo, Decl(genericCloduleInModule2.ts, 1, 23))
 
diff --git a/tests/baselines/reference/genericCloduleInModule2.types b/tests/baselines/reference/genericCloduleInModule2.types
index 94352d1f5759d..595c34df5a1a1 100644
--- a/tests/baselines/reference/genericCloduleInModule2.types
+++ b/tests/baselines/reference/genericCloduleInModule2.types
@@ -27,13 +27,13 @@ module A {
 }
 
 var b: A.B;
->b : any
+>b : A.B<{}>
 >A : any
 >B : A.B<T>
 
 b.foo();
->b.foo() : any
->b.foo : any
->b : any
->foo : any
+>b.foo() : void
+>b.foo : () => void
+>b : A.B<{}>
+>foo : () => void
 
diff --git a/tests/baselines/reference/genericDefaultsErrors.types b/tests/baselines/reference/genericDefaultsErrors.types
index 87e9af0bb072c..46687adbef1ec 100644
--- a/tests/baselines/reference/genericDefaultsErrors.types
+++ b/tests/baselines/reference/genericDefaultsErrors.types
@@ -117,11 +117,11 @@ interface i09<T, U, V = number> { }
 >V : V
 
 type i09t00 = i09; // error
->i09t00 : any
+>i09t00 : i09<{}, {}, number>
 >i09 : i09<T, U, V>
 
 type i09t01 = i09<1>; // error
->i09t01 : any
+>i09t01 : i09<1, {}, number>
 >i09 : i09<T, U, V>
 
 type i09t02 = i09<1, 2>; // ok
@@ -133,7 +133,7 @@ type i09t03 = i09<1, 2, 3>; // ok
 >i09 : i09<T, U, V>
 
 type i09t04 = i09<1, 2, 3, 4>; // error
->i09t04 : any
+>i09t04 : i09<1, 2, 3>
 >i09 : i09<T, U, V>
 
 interface i10 { x: T; } // error
diff --git a/tests/baselines/reference/genericGetter2.types b/tests/baselines/reference/genericGetter2.types
index 99bb6109cd2ff..ed9857b4a8617 100644
--- a/tests/baselines/reference/genericGetter2.types
+++ b/tests/baselines/reference/genericGetter2.types
@@ -13,7 +13,7 @@ class C<T> {
 >T : T
 
     get x(): A {
->x : any
+>x : A<{}>
 >A : A<T>
 
         return this.data;
diff --git a/tests/baselines/reference/genericInterfacesWithoutTypeArguments.types b/tests/baselines/reference/genericInterfacesWithoutTypeArguments.types
index bbce478c7dc1a..2626b165c5e4d 100644
--- a/tests/baselines/reference/genericInterfacesWithoutTypeArguments.types
+++ b/tests/baselines/reference/genericInterfacesWithoutTypeArguments.types
@@ -8,11 +8,11 @@ class C<T> { }
 >T : T
 
 var i: I;
->i : any
+>i : I<{}>
 >I : I<T>
 
 var c: C<I>;
->c : C<any>
+>c : C<I<{}>>
 >C : C<T>
 >I : I<T>
 
diff --git a/tests/baselines/reference/genericLambaArgWithoutTypeArguments.symbols b/tests/baselines/reference/genericLambaArgWithoutTypeArguments.symbols
index a2cdceddcc478..7a15730dc91dc 100644
--- a/tests/baselines/reference/genericLambaArgWithoutTypeArguments.symbols
+++ b/tests/baselines/reference/genericLambaArgWithoutTypeArguments.symbols
@@ -17,5 +17,7 @@ foo((arg: Foo) => { return arg.x; });
 >foo : Symbol(foo, Decl(genericLambaArgWithoutTypeArguments.ts, 2, 1))
 >arg : Symbol(arg, Decl(genericLambaArgWithoutTypeArguments.ts, 6, 5))
 >Foo : Symbol(Foo, Decl(genericLambaArgWithoutTypeArguments.ts, 0, 0))
+>arg.x : Symbol(Foo.x, Decl(genericLambaArgWithoutTypeArguments.ts, 0, 18))
 >arg : Symbol(arg, Decl(genericLambaArgWithoutTypeArguments.ts, 6, 5))
+>x : Symbol(Foo.x, Decl(genericLambaArgWithoutTypeArguments.ts, 0, 18))
 
diff --git a/tests/baselines/reference/genericLambaArgWithoutTypeArguments.types b/tests/baselines/reference/genericLambaArgWithoutTypeArguments.types
index 85b8dab9dd0d9..4795e41fcb0c4 100644
--- a/tests/baselines/reference/genericLambaArgWithoutTypeArguments.types
+++ b/tests/baselines/reference/genericLambaArgWithoutTypeArguments.types
@@ -17,10 +17,10 @@ function foo(a) {
 foo((arg: Foo) => { return arg.x; });
 >foo((arg: Foo) => { return arg.x; }) : any
 >foo : (a: any) => any
->(arg: Foo) => { return arg.x; } : (arg: any) => any
->arg : any
+>(arg: Foo) => { return arg.x; } : (arg: Foo<{}>) => {}
+>arg : Foo<{}>
 >Foo : Foo<T>
->arg.x : any
->arg : any
->x : any
+>arg.x : {}
+>arg : Foo<{}>
+>x : {}
 
diff --git a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors1.types b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors1.types
index d281e1bde0601..e6b4c2877ee05 100644
--- a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors1.types
+++ b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors1.types
@@ -48,7 +48,7 @@ export declare module TypeScript {
 >A : A
 >B : B
 >C : C
->PullTypeSymbol : typeof PullTypeSymbol
+>PullTypeSymbol : PullTypeSymbol<{}, {}, {}>
   }
 }
  
diff --git a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.errors.txt b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.errors.txt
index 1a04e356296c9..2f35e71f86235 100644
--- a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.errors.txt
+++ b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.errors.txt
@@ -1,18 +1,24 @@
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(3,66): error TS2314: Generic type 'MemberName<A, B, C>' requires 3 type argument(s).
+tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(3,66): error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(10,22): error TS2314: Generic type 'PullTypeSymbol<A, B, C>' requires 3 type argument(s).
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(12,48): error TS2314: Generic type 'PullSymbol<A, B, C>' requires 3 type argument(s).
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(13,31): error TS2314: Generic type 'PullTypeSymbol<A, B, C>' requires 3 type argument(s).
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(14,46): error TS2314: Generic type 'PullSymbol<A, B, C>' requires 3 type argument(s).
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(18,53): error TS2314: Generic type 'PullSymbol<A, B, C>' requires 3 type argument(s).
 tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(19,22): error TS2339: Property 'isArray' does not exist on type 'PullTypeSymbol<A, B, C>'.
+tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(21,36): error TS2339: Property 'isArray' does not exist on type 'PullTypeSymbol<{}, {}, {}>'.
+tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(21,67): error TS2339: Property 'isNamedTypeSymbol' does not exist on type 'PullTypeSymbol<{}, {}, {}>'.
+tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(23,35): error TS2339: Property 'getMemberTypeNameEx' does not exist on type 'PullTypeSymbol<{}, {}, {}>'.
 
 
-==== tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts (7 errors) ====
+==== tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts (11 errors) ====
     module TypeScript {
         export class MemberName <A,B,C>{
             static create<A,B,C>(arg1: any, arg2?: any, arg3?: any): MemberName {
                                                                      ~~~~~~~~~~
 !!! error TS2314: Generic type 'MemberName<A, B, C>' requires 3 type argument(s).
+                                                                     ~~~~~~~~~~
+!!! error TS2355: A function whose declared type is neither 'void' nor 'any' must return a value.
             }
         }
     }
@@ -43,8 +49,14 @@ tests/cases/compiler/genericRecursiveImplicitConstructorErrors3.ts(19,22): error
 !!! error TS2339: Property 'isArray' does not exist on type 'PullTypeSymbol<A, B, C>'.
                     var elementMemberName = this._elementType ?
                     (this._elementType.isArray() || this._elementType.isNamedTypeSymbol() ?
+                                       ~~~~~~~
+!!! error TS2339: Property 'isArray' does not exist on type 'PullTypeSymbol<{}, {}, {}>'.
+                                                                      ~~~~~~~~~~~~~~~~~
+!!! error TS2339: Property 'isNamedTypeSymbol' does not exist on type 'PullTypeSymbol<{}, {}, {}>'.
                     this._elementType.getScopedNameEx(scopeSymbol, false, getPrettyTypeName, getTypeParamMarkerInfo) :
                     this._elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : 1
+                                      ~~~~~~~~~~~~~~~~~~~
+!!! error TS2339: Property 'getMemberTypeNameEx' does not exist on type 'PullTypeSymbol<{}, {}, {}>'.
                     return MemberName.create(elementMemberName, "", "[]");
                 }
             }
diff --git a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.symbols b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.symbols
index eefe80742d301..7efe3a912241d 100644
--- a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.symbols
+++ b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.symbols
@@ -94,9 +94,11 @@ module TypeScript {
 >_elementType : Symbol(PullTypeSymbol._elementType, Decl(genericRecursiveImplicitConstructorErrors3.ts, 11, 59))
 
                 this._elementType.getScopedNameEx(scopeSymbol, false, getPrettyTypeName, getTypeParamMarkerInfo) :
+>this._elementType.getScopedNameEx : Symbol(PullTypeSymbol.getScopedNameEx, Decl(genericRecursiveImplicitConstructorErrors3.ts, 16, 9))
 >this._elementType : Symbol(PullTypeSymbol._elementType, Decl(genericRecursiveImplicitConstructorErrors3.ts, 11, 59))
 >this : Symbol(PullTypeSymbol, Decl(genericRecursiveImplicitConstructorErrors3.ts, 10, 5))
 >_elementType : Symbol(PullTypeSymbol._elementType, Decl(genericRecursiveImplicitConstructorErrors3.ts, 11, 59))
+>getScopedNameEx : Symbol(PullTypeSymbol.getScopedNameEx, Decl(genericRecursiveImplicitConstructorErrors3.ts, 16, 9))
 >scopeSymbol : Symbol(scopeSymbol, Decl(genericRecursiveImplicitConstructorErrors3.ts, 17, 38))
 >getPrettyTypeName : Symbol(getPrettyTypeName, Decl(genericRecursiveImplicitConstructorErrors3.ts, 17, 94))
 >getTypeParamMarkerInfo : Symbol(getTypeParamMarkerInfo, Decl(genericRecursiveImplicitConstructorErrors3.ts, 17, 123))
diff --git a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.types b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.types
index 06df335b66de5..2579ea47e35b6 100644
--- a/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.types
+++ b/tests/baselines/reference/genericRecursiveImplicitConstructorErrors3.types
@@ -9,7 +9,7 @@ module TypeScript {
 >C : C
 
         static create<A,B,C>(arg1: any, arg2?: any, arg3?: any): MemberName {
->create : <A, B, C>(arg1: any, arg2?: any, arg3?: any) => any
+>create : <A, B, C>(arg1: any, arg2?: any, arg3?: any) => MemberName<{}, {}, {}>
 >A : A
 >B : B
 >C : C
@@ -31,7 +31,7 @@ module TypeScript {
 >C : C
 
         public type: PullTypeSymbol = null;
->type : any
+>type : PullTypeSymbol<{}, {}, {}>
 >PullTypeSymbol : PullTypeSymbol<A, B, C>
 >null : null
     }
@@ -40,19 +40,19 @@ module TypeScript {
 >A : A
 >B : B
 >C : C
->PullSymbol : typeof PullSymbol
+>PullSymbol : PullSymbol<{}, {}, {}>
 
         private _elementType: PullTypeSymbol = null;
->_elementType : any
+>_elementType : PullTypeSymbol<{}, {}, {}>
 >PullTypeSymbol : PullTypeSymbol<A, B, C>
 >null : null
 
         public toString<A,B,C>(scopeSymbol?: PullSymbol, useConstraintInName?: boolean) {
->toString : <A, B, C>(scopeSymbol?: any, useConstraintInName?: boolean) => any
+>toString : <A, B, C>(scopeSymbol?: PullSymbol<{}, {}, {}>, useConstraintInName?: boolean) => any
 >A : A
 >B : B
 >C : C
->scopeSymbol : any
+>scopeSymbol : PullSymbol<{}, {}, {}>
 >PullSymbol : PullSymbol<A, B, C>
 >useConstraintInName : boolean
 
@@ -61,10 +61,10 @@ module TypeScript {
 >this.getScopedNameEx(scopeSymbol, useConstraintInName).toString() : any
 >this.getScopedNameEx(scopeSymbol, useConstraintInName).toString : any
 >this.getScopedNameEx(scopeSymbol, useConstraintInName) : any
->this.getScopedNameEx : <A, B, C>(scopeSymbol?: any, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
+>this.getScopedNameEx : <A, B, C>(scopeSymbol?: PullSymbol<{}, {}, {}>, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
 >this : this
->getScopedNameEx : <A, B, C>(scopeSymbol?: any, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
->scopeSymbol : any
+>getScopedNameEx : <A, B, C>(scopeSymbol?: PullSymbol<{}, {}, {}>, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
+>scopeSymbol : PullSymbol<{}, {}, {}>
 >useConstraintInName : boolean
 >toString : any
 
@@ -72,11 +72,11 @@ module TypeScript {
 >s : any
         }
         public getScopedNameEx<A,B,C>(scopeSymbol?: PullSymbol, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) {
->getScopedNameEx : <A, B, C>(scopeSymbol?: any, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
+>getScopedNameEx : <A, B, C>(scopeSymbol?: PullSymbol<{}, {}, {}>, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
 >A : A
 >B : B
 >C : C
->scopeSymbol : any
+>scopeSymbol : PullSymbol<{}, {}, {}>
 >PullSymbol : PullSymbol<A, B, C>
 >useConstraintInName : boolean
 >getPrettyTypeName : boolean
@@ -91,9 +91,9 @@ module TypeScript {
                 var elementMemberName = this._elementType ?
 >elementMemberName : any
 >this._elementType ?                (this._elementType.isArray() || this._elementType.isNamedTypeSymbol() ?                this._elementType.getScopedNameEx(scopeSymbol, false, getPrettyTypeName, getTypeParamMarkerInfo) :                this._elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : 1 : any
->this._elementType : any
+>this._elementType : PullTypeSymbol<{}, {}, {}>
 >this : this
->_elementType : any
+>_elementType : PullTypeSymbol<{}, {}, {}>
 
                 (this._elementType.isArray() || this._elementType.isNamedTypeSymbol() ?
 >(this._elementType.isArray() || this._elementType.isNamedTypeSymbol() ?                this._elementType.getScopedNameEx(scopeSymbol, false, getPrettyTypeName, getTypeParamMarkerInfo) :                this._elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : any
@@ -101,25 +101,25 @@ module TypeScript {
 >this._elementType.isArray() || this._elementType.isNamedTypeSymbol() : any
 >this._elementType.isArray() : any
 >this._elementType.isArray : any
->this._elementType : any
+>this._elementType : PullTypeSymbol<{}, {}, {}>
 >this : this
->_elementType : any
+>_elementType : PullTypeSymbol<{}, {}, {}>
 >isArray : any
 >this._elementType.isNamedTypeSymbol() : any
 >this._elementType.isNamedTypeSymbol : any
->this._elementType : any
+>this._elementType : PullTypeSymbol<{}, {}, {}>
 >this : this
->_elementType : any
+>_elementType : PullTypeSymbol<{}, {}, {}>
 >isNamedTypeSymbol : any
 
                 this._elementType.getScopedNameEx(scopeSymbol, false, getPrettyTypeName, getTypeParamMarkerInfo) :
 >this._elementType.getScopedNameEx(scopeSymbol, false, getPrettyTypeName, getTypeParamMarkerInfo) : any
->this._elementType.getScopedNameEx : any
->this._elementType : any
+>this._elementType.getScopedNameEx : <A, B, C>(scopeSymbol?: PullSymbol<{}, {}, {}>, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
+>this._elementType : PullTypeSymbol<{}, {}, {}>
 >this : this
->_elementType : any
->getScopedNameEx : any
->scopeSymbol : any
+>_elementType : PullTypeSymbol<{}, {}, {}>
+>getScopedNameEx : <A, B, C>(scopeSymbol?: PullSymbol<{}, {}, {}>, useConstraintInName?: boolean, getPrettyTypeName?: boolean, getTypeParamMarkerInfo?: boolean) => any
+>scopeSymbol : PullSymbol<{}, {}, {}>
 >false : false
 >getPrettyTypeName : boolean
 >getTypeParamMarkerInfo : boolean
@@ -127,20 +127,20 @@ module TypeScript {
                 this._elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName)) : 1
 >this._elementType.getMemberTypeNameEx(false, scopeSymbol, getPrettyTypeName) : any
 >this._elementType.getMemberTypeNameEx : any
->this._elementType : any
+>this._elementType : PullTypeSymbol<{}, {}, {}>
 >this : this
->_elementType : any
+>_elementType : PullTypeSymbol<{}, {}, {}>
 >getMemberTypeNameEx : any
 >false : false
->scopeSymbol : any
+>scopeSymbol : PullSymbol<{}, {}, {}>
 >getPrettyTypeName : boolean
 >1 : 1
 
                 return MemberName.create(elementMemberName, "", "[]");
->MemberName.create(elementMemberName, "", "[]") : any
->MemberName.create : <A, B, C>(arg1: any, arg2?: any, arg3?: any) => any
+>MemberName.create(elementMemberName, "", "[]") : MemberName<{}, {}, {}>
+>MemberName.create : <A, B, C>(arg1: any, arg2?: any, arg3?: any) => MemberName<{}, {}, {}>
 >MemberName : typeof MemberName
->create : <A, B, C>(arg1: any, arg2?: any, arg3?: any) => any
+>create : <A, B, C>(arg1: any, arg2?: any, arg3?: any) => MemberName<{}, {}, {}>
 >elementMemberName : any
 >"" : ""
 >"[]" : "[]"
diff --git a/tests/baselines/reference/genericReturnTypeFromGetter1.types b/tests/baselines/reference/genericReturnTypeFromGetter1.types
index 0d0655605d293..f4ba9e3f6012e 100644
--- a/tests/baselines/reference/genericReturnTypeFromGetter1.types
+++ b/tests/baselines/reference/genericReturnTypeFromGetter1.types
@@ -14,13 +14,13 @@ export class DbSet<T> {
 >T : T
 
     _entityType: A;
->_entityType : any
+>_entityType : A<{}>
 >A : A<T>
 
   get entityType() { return this._entityType; }  // used to ICE without return type annotation
->entityType : any
->this._entityType : any
+>entityType : A<{}>
+>this._entityType : A<{}>
 >this : this
->_entityType : any
+>_entityType : A<{}>
 }
 
diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.types b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.types
index b056107e4ead7..35d86e98dbfe4 100644
--- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.types
+++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.types
@@ -12,35 +12,35 @@ declare class C<T> {
 }
 
 declare var c: C;
->c : any
+>c : C<{}>
 >C : C<T>
 
 declare var a: { x: C };
->a : { x: any; }
->x : any
+>a : { x: C<{}>; }
+>x : C<{}>
 >C : C<T>
 
 declare var b: { (x: C): C };
->b : (x: any) => any
->x : any
+>b : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 declare var d: { [x: C]: C };
 >d : {}
->x : any
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 declare function f(x: C): C;
->f : (x: any) => any
->x : any
+>f : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 declare class D extends C {}
 >D : D
->C : typeof C
+>C : C<{}>
 
 declare module M {
 >M : typeof M
@@ -65,14 +65,14 @@ declare class D3<T extends M.E> { }
 >E : M.E<T>
 
 declare function h<T extends C>(x: T);
->h : <T extends any>(x: T) => any
+>h : <T extends C<{}>>(x: T) => any
 >T : T
 >C : C<T>
 >x : T
 >T : T
 
 declare function i<T extends M.E>(x: T);
->i : <T extends any>(x: T) => any
+>i : <T extends M.E<{}>>(x: T) => any
 >T : T
 >M : any
 >E : M.E<T>
diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.types b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.types
index ebf3e5dde955c..e2e744a9e09c5 100644
--- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.types
+++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.types
@@ -12,58 +12,58 @@ class C<T> {
 }
 
 var c: C;
->c : any
+>c : C<{}>
 >C : C<T>
 
 var a: { x: C };
->a : { x: any; }
->x : any
+>a : { x: C<{}>; }
+>x : C<{}>
 >C : C<T>
 
 var b: { (x: C): C };
->b : (x: any) => any
->x : any
+>b : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 var d: { [x: C]: C };
 >d : {}
->x : any
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 var e = (x: C) => { var y: C; return y; }
->e : (x: any) => any
->(x: C) => { var y: C; return y; } : (x: any) => any
->x : any
+>e : (x: C<{}>) => C<{}>
+>(x: C) => { var y: C; return y; } : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
->y : any
+>y : C<{}>
 >C : C<T>
->y : any
+>y : C<{}>
 
 function f(x: C): C { var y: C; return y; }
->f : (x: any) => any
->x : any
+>f : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
->y : any
+>y : C<{}>
 >C : C<T>
->y : any
+>y : C<{}>
 
 var g = function f(x: C): C { var y: C; return y; }
->g : (x: any) => any
->function f(x: C): C { var y: C; return y; } : (x: any) => any
->f : (x: any) => any
->x : any
+>g : (x: C<{}>) => C<{}>
+>function f(x: C): C { var y: C; return y; } : (x: C<{}>) => C<{}>
+>f : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
->y : any
+>y : C<{}>
 >C : C<T>
->y : any
+>y : C<{}>
 
 class D extends C {
 >D : D
->C : typeof C
+>C : C<{}>
 }
 
 interface I extends C {}
@@ -82,7 +82,7 @@ module M {
 
 class D2 extends M.E { }
 >D2 : D2
->M.E : typeof M.E
+>M.E : M.E<{}>
 >M : typeof M
 >E : typeof M.E
 
@@ -99,14 +99,14 @@ interface I2 extends M.E { }
 >E : M.E<T>
 
 function h<T extends C>(x: T) { }
->h : <T extends any>(x: T) => void
+>h : <T extends C<{}>>(x: T) => void
 >T : T
 >C : C<T>
 >x : T
 >T : T
 
 function i<T extends M.E>(x: T) { }
->i : <T extends any>(x: T) => void
+>i : <T extends M.E<{}>>(x: T) => void
 >T : T
 >M : any
 >E : M.E<T>
@@ -114,14 +114,14 @@ function i<T extends M.E>(x: T) { }
 >T : T
 
 var j = <C>null;
->j : any
-><C>null : any
+>j : C<{}>
+><C>null : C<{}>
 >C : C<T>
 >null : null
 
 var k = <M.E>null;
->k : any
-><M.E>null : any
+>k : M.E<{}>
+><M.E>null : M.E<{}>
 >M : any
 >E : M.E<T>
 >null : null
diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.types b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.types
index f6563470de596..3946be21af10b 100644
--- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.types
+++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.types
@@ -12,54 +12,54 @@ interface I<T> {
 }
 
 var c: I;
->c : any
+>c : I<{}>
 >I : I<T>
 
 var a: { x: I };
->a : { x: any; }
->x : any
+>a : { x: I<{}>; }
+>x : I<{}>
 >I : I<T>
 
 var b: { (x: I): I };
->b : (x: any) => any
->x : any
+>b : (x: I<{}>) => I<{}>
+>x : I<{}>
 >I : I<T>
 >I : I<T>
 
 var d: { [x: I]: I };
 >d : {}
->x : any
+>x : I<{}>
 >I : I<T>
 >I : I<T>
 
 var e = (x: I) => { var y: I; return y; }
->e : (x: any) => any
->(x: I) => { var y: I; return y; } : (x: any) => any
->x : any
+>e : (x: I<{}>) => I<{}>
+>(x: I) => { var y: I; return y; } : (x: I<{}>) => I<{}>
+>x : I<{}>
 >I : I<T>
->y : any
+>y : I<{}>
 >I : I<T>
->y : any
+>y : I<{}>
 
 function f(x: I): I { var y: I; return y; }
->f : (x: any) => any
->x : any
+>f : (x: I<{}>) => I<{}>
+>x : I<{}>
 >I : I<T>
 >I : I<T>
->y : any
+>y : I<{}>
 >I : I<T>
->y : any
+>y : I<{}>
 
 var g = function f(x: I): I { var y: I; return y; }
->g : (x: any) => any
->function f(x: I): I { var y: I; return y; } : (x: any) => any
->f : (x: any) => any
->x : any
+>g : (x: I<{}>) => I<{}>
+>function f(x: I): I { var y: I; return y; } : (x: I<{}>) => I<{}>
+>f : (x: I<{}>) => I<{}>
+>x : I<{}>
 >I : I<T>
 >I : I<T>
->y : any
+>y : I<{}>
 >I : I<T>
->y : any
+>y : I<{}>
 
 class D extends I {
 >D : D
@@ -99,14 +99,14 @@ interface I2 extends M.C { }
 >C : No type information available!
 
 function h<T extends I>(x: T) { }
->h : <T extends any>(x: T) => void
+>h : <T extends I<{}>>(x: T) => void
 >T : T
 >I : I<T>
 >x : T
 >T : T
 
 function i<T extends M.E>(x: T) { }
->i : <T extends any>(x: T) => void
+>i : <T extends M.E<{}>>(x: T) => void
 >T : T
 >M : any
 >E : M.E<T>
@@ -120,8 +120,8 @@ var j = <C>null;
 >null : null
 
 var k = <M.E>null;
->k : any
-><M.E>null : any
+>k : M.E<{}>
+><M.E>null : M.E<{}>
 >M : any
 >E : M.E<T>
 >null : null
diff --git a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.types b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.types
index 3a1ebb10a03bb..8efa318da1cf1 100644
--- a/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.types
+++ b/tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.types
@@ -12,35 +12,35 @@ declare class C<T> {
 }
 
 declare var c: C;
->c : any
+>c : C<{}>
 >C : C<T>
 
 declare var a: { x: C };
->a : { x: any; }
->x : any
+>a : { x: C<{}>; }
+>x : C<{}>
 >C : C<T>
 
 declare var b: { (x: C): C };
->b : (x: any) => any
->x : any
+>b : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 declare var d: { [x: C]: C };
 >d : {}
->x : any
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 declare function f(x: C): C;
->f : (x: any) => any
->x : any
+>f : (x: C<{}>) => C<{}>
+>x : C<{}>
 >C : C<T>
 >C : C<T>
 
 declare class D extends C {}
 >D : D
->C : typeof C
+>C : C<{}>
 
 declare module M {
 >M : typeof M
@@ -65,14 +65,14 @@ declare class D3<T extends M.E> { }
 >E : M.E<T>
 
 declare function h<T extends C>(x: T);
->h : <T extends any>(x: T) => any
+>h : <T extends C<{}>>(x: T) => any
 >T : T
 >C : C<T>
 >x : T
 >T : T
 
 declare function i<T extends M.E>(x: T);
->i : <T extends any>(x: T) => any
+>i : <T extends M.E<{}>>(x: T) => any
 >T : T
 >M : any
 >E : M.E<T>
diff --git a/tests/baselines/reference/genericTypeReferencesRequireTypeArgs.types b/tests/baselines/reference/genericTypeReferencesRequireTypeArgs.types
index 4a250f2dbea0f..d0fb51974f56a 100644
--- a/tests/baselines/reference/genericTypeReferencesRequireTypeArgs.types
+++ b/tests/baselines/reference/genericTypeReferencesRequireTypeArgs.types
@@ -17,20 +17,20 @@ interface I<T> {
 >T : T
 }
 var c1: C; // error
->c1 : any
+>c1 : C<{}>
 >C : C<T>
 
 var i1: I; // error
->i1 : any
+>i1 : I<{}>
 >I : I<T>
 
 var c2: C<I>; // should be an error
->c2 : C<any>
+>c2 : C<I<{}>>
 >C : C<T>
 >I : I<T>
 
 var i2: I<C>; // should be an error
->i2 : I<any>
+>i2 : I<C<{}>>
 >I : I<T>
 >C : C<T>
 
diff --git a/tests/baselines/reference/generics1.types b/tests/baselines/reference/generics1.types
index 0132725cfed5e..f69dcb8eb7a84 100644
--- a/tests/baselines/reference/generics1.types
+++ b/tests/baselines/reference/generics1.types
@@ -58,10 +58,10 @@ var v5: G<any, any>;           // Error, any does not satisfy constraint B
 >G : G<T, U>
 
 var v6: G<any>;                // Error, wrong number of arguments
->v6 : any
+>v6 : G<any, {}>
 >G : G<T, U>
 
 var v7: G;                     // Error, no type arguments
->v7 : any
+>v7 : G<{}, {}>
 >G : G<T, U>
 
diff --git a/tests/baselines/reference/generics2.types b/tests/baselines/reference/generics2.types
index dd7955d87a178..a472c74dc02e6 100644
--- a/tests/baselines/reference/generics2.types
+++ b/tests/baselines/reference/generics2.types
@@ -70,10 +70,10 @@ var v5: G<any, any>;           // Error, any does not satisfy constraint B
 >G : G<T, U>
 
 var v6: G<any>;                // Error, wrong number of arguments
->v6 : any
+>v6 : G<any, {}>
 >G : G<T, U>
 
 var v7: G;                     // Error, no type arguments
->v7 : any
+>v7 : G<{}, {}>
 >G : G<T, U>
 
diff --git a/tests/baselines/reference/genericsWithoutTypeParameters1.types b/tests/baselines/reference/genericsWithoutTypeParameters1.types
index 0888be41d1168..422bd72184b09 100644
--- a/tests/baselines/reference/genericsWithoutTypeParameters1.types
+++ b/tests/baselines/reference/genericsWithoutTypeParameters1.types
@@ -19,42 +19,42 @@ interface I<T> {
 }
 
 var c1: C;
->c1 : any
+>c1 : C<{}>
 >C : C<T>
 
 var i1: I;
->i1 : any
+>i1 : I<{}>
 >I : I<T>
 
 var c2: C<I>;
->c2 : C<any>
+>c2 : C<I<{}>>
 >C : C<T>
 >I : I<T>
 
 var i2: I<C>;
->i2 : I<any>
+>i2 : I<C<{}>>
 >I : I<T>
 >C : C<T>
 
 function foo(x: C, y: I) { }
->foo : (x: any, y: any) => void
->x : any
+>foo : (x: C<{}>, y: I<{}>) => void
+>x : C<{}>
 >C : C<T>
->y : any
+>y : I<{}>
 >I : I<T>
 
 function foo2(x: C<I>, y: I<C>) { }
->foo2 : (x: C<any>, y: I<any>) => void
->x : C<any>
+>foo2 : (x: C<I<{}>>, y: I<C<{}>>) => void
+>x : C<I<{}>>
 >C : C<T>
 >I : I<T>
->y : I<any>
+>y : I<C<{}>>
 >I : I<T>
 >C : C<T>
 
 var x: { a: C } = { a: new C<number>() };
->x : { a: any; }
->a : any
+>x : { a: C<{}>; }
+>a : C<{}>
 >C : C<T>
 >{ a: new C<number>() } : { a: C<number>; }
 >a : C<number>
@@ -62,8 +62,8 @@ var x: { a: C } = { a: new C<number>() };
 >C : typeof C
 
 var x2: { a: I } = { a: { bar() { return 1 } } };
->x2 : { a: any; }
->a : any
+>x2 : { a: I<{}>; }
+>a : I<{}>
 >I : I<T>
 >{ a: { bar() { return 1 } } } : { a: { bar(): number; }; }
 >a : { bar(): number; }
@@ -76,11 +76,11 @@ class D<T> {
 >T : T
 
     x: C;
->x : any
+>x : C<{}>
 >C : C<T>
 
     y: D;
->y : any
+>y : D<{}>
 >D : D<T>
 }
 
@@ -89,11 +89,11 @@ interface J<T> {
 >T : T
 
     x: I;
->x : any
+>x : I<{}>
 >I : I<T>
 
     y: J;
->y : any
+>y : J<{}>
 >J : J<T>
 }
 
@@ -102,7 +102,7 @@ class A<T> { }
 >T : T
 
 function f<T>(x: T): A {
->f : <T>(x: T) => any
+>f : <T>(x: T) => A<{}>
 >T : T
 >x : T
 >T : T
diff --git a/tests/baselines/reference/missingTypeArguments1.types b/tests/baselines/reference/missingTypeArguments1.types
index b9a372e8cb52c..ce3c40f82cd7c 100644
--- a/tests/baselines/reference/missingTypeArguments1.types
+++ b/tests/baselines/reference/missingTypeArguments1.types
@@ -12,7 +12,7 @@ class X<T> {
 >T : T
 
     p1: () => X;
->p1 : () => any
+>p1 : () => X<{}>
 >X : X<T>
 }
 var a: X<number>;
@@ -24,7 +24,7 @@ class X2<T> {
 >T : T
 
     p2: { [idx: number]: X2 } 
->p2 : { [idx: number]: any; }
+>p2 : { [idx: number]: X2<{}>; }
 >idx : number
 >X2 : X2<T>
 }
@@ -37,7 +37,7 @@ class X3<T> {
 >T : T
 
     p3: X3[]
->p3 : any[]
+>p3 : X3<{}>[]
 >X3 : X3<T>
 }
 var a3: X3<number>;
@@ -49,7 +49,7 @@ class X4<T> {
 >T : T
 
     p4: I<X4>
->p4 : I<any>
+>p4 : I<X4<{}>>
 >I : I<T>
 >X4 : X4<T>
 }
@@ -62,7 +62,7 @@ class X5<T> {
 >T : T
 
     p5: X5
->p5 : any
+>p5 : X5<{}>
 >X5 : X5<T>
 }
 var a5: X5<number>;
@@ -74,7 +74,7 @@ class X6<T> {
 >T : T
 
     p6: () => Y;
->p6 : () => any
+>p6 : () => Y<{}>
 >Y : Y<T>
 }
 var a6: X6<number>;
@@ -86,7 +86,7 @@ class X7<T> {
 >T : T
 
     p7: { [idx: number]: Y } 
->p7 : { [idx: number]: any; }
+>p7 : { [idx: number]: Y<{}>; }
 >idx : number
 >Y : Y<T>
 }
@@ -99,7 +99,7 @@ class X8<T> {
 >T : T
 
     p8: Y[]
->p8 : any[]
+>p8 : Y<{}>[]
 >Y : Y<T>
 }
 var a8: X8<number>;
@@ -111,7 +111,7 @@ class X9<T> {
 >T : T
 
     p9: I<Y>
->p9 : I<any>
+>p9 : I<Y<{}>>
 >I : I<T>
 >Y : Y<T>
 }
@@ -124,7 +124,7 @@ class X10<T> {
 >T : T
 
     pa: Y
->pa : any
+>pa : Y<{}>
 >Y : Y<T>
 }
 var a10: X10<number>;
diff --git a/tests/baselines/reference/missingTypeArguments2.types b/tests/baselines/reference/missingTypeArguments2.types
index eeab431571079..b5c5589a58c1d 100644
--- a/tests/baselines/reference/missingTypeArguments2.types
+++ b/tests/baselines/reference/missingTypeArguments2.types
@@ -4,21 +4,21 @@ class A<T> { }
 >T : T
 
 var x: () => A;
->x : () => any
+>x : () => A<{}>
 >A : A<T>
 
 (a: A) => { };
->(a: A) => { } : (a: any) => void
->a : any
+>(a: A) => { } : (a: A<{}>) => void
+>a : A<{}>
 >A : A<T>
 
 var y: A<A>;
->y : A<any>
+>y : A<A<{}>>
 >A : A<T>
 >A : A<T>
 
 (): A => null;
->(): A => null : () => any
+>(): A => null : () => A<{}>
 >A : A<T>
 >null : null
 
diff --git a/tests/baselines/reference/noTypeArgumentOnReturnType1.types b/tests/baselines/reference/noTypeArgumentOnReturnType1.types
index 438d265606803..5e234d42f8984 100644
--- a/tests/baselines/reference/noTypeArgumentOnReturnType1.types
+++ b/tests/baselines/reference/noTypeArgumentOnReturnType1.types
@@ -4,7 +4,7 @@ class A<T>{
 >T : T
  
  foo(): A{
->foo : () => any
+>foo : () => A<{}>
 >A : A<T>
 
   return null;
diff --git a/tests/baselines/reference/recursiveBaseConstructorCreation3.errors.txt b/tests/baselines/reference/recursiveBaseConstructorCreation3.errors.txt
index bd39249289984..c6d88e1099dd0 100644
--- a/tests/baselines/reference/recursiveBaseConstructorCreation3.errors.txt
+++ b/tests/baselines/reference/recursiveBaseConstructorCreation3.errors.txt
@@ -1,8 +1,7 @@
 tests/cases/compiler/recursiveBaseConstructorCreation3.ts(6,27): error TS2314: Generic type 'abc<T>' requires 1 type argument(s).
-tests/cases/compiler/recursiveBaseConstructorCreation3.ts(9,11): error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
 
 
-==== tests/cases/compiler/recursiveBaseConstructorCreation3.ts (2 errors) ====
+==== tests/cases/compiler/recursiveBaseConstructorCreation3.ts (1 errors) ====
     declare class base<T> {
     }
     declare class abc<T> extends base<T> {
@@ -14,6 +13,4 @@ tests/cases/compiler/recursiveBaseConstructorCreation3.ts(9,11): error TS2351: C
     }
     
     var bar = new xyz(); // Error: Invalid 'new' expression.
-              ~~~~~~~~~
-!!! error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
     var r: xyz = bar.foo;
\ No newline at end of file
diff --git a/tests/baselines/reference/recursiveBaseConstructorCreation3.symbols b/tests/baselines/reference/recursiveBaseConstructorCreation3.symbols
index ad9e20f879c21..ecb26c1f6d24b 100644
--- a/tests/baselines/reference/recursiveBaseConstructorCreation3.symbols
+++ b/tests/baselines/reference/recursiveBaseConstructorCreation3.symbols
@@ -25,5 +25,7 @@ var bar = new xyz(); // Error: Invalid 'new' expression.
 var r: xyz = bar.foo;
 >r : Symbol(r, Decl(recursiveBaseConstructorCreation3.ts, 9, 3))
 >xyz : Symbol(xyz, Decl(recursiveBaseConstructorCreation3.ts, 4, 1))
+>bar.foo : Symbol(abc.foo, Decl(recursiveBaseConstructorCreation3.ts, 2, 38))
 >bar : Symbol(bar, Decl(recursiveBaseConstructorCreation3.ts, 8, 3))
+>foo : Symbol(abc.foo, Decl(recursiveBaseConstructorCreation3.ts, 2, 38))
 
diff --git a/tests/baselines/reference/recursiveBaseConstructorCreation3.types b/tests/baselines/reference/recursiveBaseConstructorCreation3.types
index 0be0a49dba0ba..d6064be13fe4d 100644
--- a/tests/baselines/reference/recursiveBaseConstructorCreation3.types
+++ b/tests/baselines/reference/recursiveBaseConstructorCreation3.types
@@ -15,18 +15,18 @@ declare class abc<T> extends base<T> {
 }
 declare class xyz extends abc {
 >xyz : xyz
->abc : typeof abc
+>abc : abc<{}>
 }
 
 var bar = new xyz(); // Error: Invalid 'new' expression.
->bar : any
->new xyz() : any
+>bar : xyz
+>new xyz() : xyz
 >xyz : typeof xyz
 
 var r: xyz = bar.foo;
 >r : xyz
 >xyz : xyz
->bar.foo : any
->bar : any
->foo : any
+>bar.foo : xyz
+>bar : xyz
+>foo : xyz
 
diff --git a/tests/baselines/reference/returnTypeTypeArguments.types b/tests/baselines/reference/returnTypeTypeArguments.types
index 17b7324db7639..9a708c5f64fc6 100644
--- a/tests/baselines/reference/returnTypeTypeArguments.types
+++ b/tests/baselines/reference/returnTypeTypeArguments.types
@@ -40,32 +40,32 @@ class Three<T, U, V>{
 }
 
 function A1(): One { return null; }
->A1 : () => any
+>A1 : () => One<{}>
 >One : One<T>
 >null : null
 
 function A2(): Two { return null; }
->A2 : () => any
+>A2 : () => Two<{}, {}>
 >Two : Two<T, U>
 >null : null
 
 function A3(): Three { return null; }
->A3 : () => any
+>A3 : () => Three<{}, {}, {}>
 >Three : Three<T, U, V>
 >null : null
 
 function B1(): Two<number> { return null; }
->B1 : () => any
+>B1 : () => Two<number, {}>
 >Two : Two<T, U>
 >null : null
 
 function B2(): Three<string> { return null; }
->B2 : () => any
+>B2 : () => Three<string, {}, {}>
 >Three : Three<T, U, V>
 >null : null
 
 function B3(): Three<string, number> { return null; }
->B3 : () => any
+>B3 : () => Three<string, number, {}>
 >Three : Three<T, U, V>
 >null : null
 
@@ -73,32 +73,32 @@ class C {
 >C : C
 
     A1(): One { return null; }
->A1 : () => any
+>A1 : () => One<{}>
 >One : One<T>
 >null : null
 
     A2(): Two { return null; }
->A2 : () => any
+>A2 : () => Two<{}, {}>
 >Two : Two<T, U>
 >null : null
 
     A3(): Three { return null; }
->A3 : () => any
+>A3 : () => Three<{}, {}, {}>
 >Three : Three<T, U, V>
 >null : null
 
     B1(): Two<number> { return null; }
->B1 : () => any
+>B1 : () => Two<number, {}>
 >Two : Two<T, U>
 >null : null
 
     B2(): Three<string> { return null; }
->B2 : () => any
+>B2 : () => Three<string, {}, {}>
 >Three : Three<T, U, V>
 >null : null
 
     B3(): Three<string, number> { return null; }
->B3 : () => any
+>B3 : () => Three<string, number, {}>
 >Three : Three<T, U, V>
 >null : null
 }
@@ -108,31 +108,31 @@ class D<T> {
 >T : T
 
     A2(): Two<T> { return null; }
->A2 : () => any
+>A2 : () => Two<T, {}>
 >Two : Two<T, U>
 >T : T
 >null : null
 
     A3(): Three<T> { return null; }
->A3 : () => any
+>A3 : () => Three<T, {}, {}>
 >Three : Three<T, U, V>
 >T : T
 >null : null
 
     B1(): Two<T> { return null; }
->B1 : () => any
+>B1 : () => Two<T, {}>
 >Two : Two<T, U>
 >T : T
 >null : null
 
     B2(): Three<T> { return null; }
->B2 : () => any
+>B2 : () => Three<T, {}, {}>
 >Three : Three<T, U, V>
 >T : T
 >null : null
 
     B3(): Three<string, T> { return null; }
->B3 : () => any
+>B3 : () => Three<string, T, {}>
 >Three : Three<T, U, V>
 >T : T
 >null : null
@@ -161,95 +161,95 @@ class X<T>
 >T : T
 {
     p1: () => X;
->p1 : () => any
+>p1 : () => X<{}>
 >X : X<T>
 
     p2: { [idx: number]: X }
->p2 : { [idx: number]: any; }
+>p2 : { [idx: number]: X<{}>; }
 >idx : number
 >X : X<T>
 
     p3: X[]
->p3 : any[]
+>p3 : X<{}>[]
 >X : X<T>
 
     p4: I<X>
->p4 : I<any>
+>p4 : I<X<{}>>
 >I : I<T>
 >X : X<T>
 
     p5: X
->p5 : any
+>p5 : X<{}>
 >X : X<T>
 
     p6: () => Y;
->p6 : () => any
+>p6 : () => Y<{}>
 >Y : Y<T>
 
     p7: { [idx: number]: Y }
->p7 : { [idx: number]: any; }
+>p7 : { [idx: number]: Y<{}>; }
 >idx : number
 >Y : Y<T>
 
     p8: Y[]
->p8 : any[]
+>p8 : Y<{}>[]
 >Y : Y<T>
 
     p9: I<Y>
->p9 : I<any>
+>p9 : I<Y<{}>>
 >I : I<T>
 >Y : Y<T>
 
     pa: Y
->pa : any
+>pa : Y<{}>
 >Y : Y<T>
 }
 
 declare var a: {
->a : { p1: () => any; p2: { [idx: number]: any; }; p3: any[]; p4: I<any>; p5: any; p6: () => any; p7: { [idx: number]: any; }; p8: any[]; p9: I<any>; pa: any; }
+>a : { p1: () => X<{}>; p2: { [idx: number]: X<{}>; }; p3: X<{}>[]; p4: I<X<{}>>; p5: X<{}>; p6: () => Y<{}>; p7: { [idx: number]: Y<{}>; }; p8: Y<{}>[]; p9: I<Y<{}>>; pa: Y<{}>; }
 
     p1: () => X;
->p1 : () => any
+>p1 : () => X<{}>
 >X : X<T>
 
     p2: { [idx: number]: X }
->p2 : { [idx: number]: any; }
+>p2 : { [idx: number]: X<{}>; }
 >idx : number
 >X : X<T>
 
     p3: X[]
->p3 : any[]
+>p3 : X<{}>[]
 >X : X<T>
 
     p4: I<X>
->p4 : I<any>
+>p4 : I<X<{}>>
 >I : I<T>
 >X : X<T>
 
     p5: X
->p5 : any
+>p5 : X<{}>
 >X : X<T>
 
     p6: () => Y;
->p6 : () => any
+>p6 : () => Y<{}>
 >Y : Y<T>
 
     p7: { [idx: number]: Y }
->p7 : { [idx: number]: any; }
+>p7 : { [idx: number]: Y<{}>; }
 >idx : number
 >Y : Y<T>
 
     p8: Y[]
->p8 : any[]
+>p8 : Y<{}>[]
 >Y : Y<T>
 
     p9: I<Y>
->p9 : I<any>
+>p9 : I<Y<{}>>
 >I : I<T>
 >Y : Y<T>
 
     pa: Y
->pa : any
+>pa : Y<{}>
 >Y : Y<T>
 
 };
diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.symbols b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.symbols
index fb7e13ab74485..aa39c984c5f0b 100644
--- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.symbols
+++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.symbols
@@ -18,6 +18,7 @@ class B extends A<number> {
 >A : Symbol(A, Decl(superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts, 0, 0))
 
     constructor() { super(value => String(value)); }
+>super : Symbol(A, Decl(superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts, 0, 0))
 >value : Symbol(value, Decl(superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts, 7, 26))
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >value : Symbol(value, Decl(superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.ts, 7, 26))
diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.types b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.types
index a446a8c23770f..31fe163cbee46 100644
--- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.types
+++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithIncorrectNumberOfTypeArguments1.types
@@ -15,14 +15,14 @@ class A<T1, T2> {
 
 class B extends A<number> {
 >B : B
->A : typeof A
+>A : A<number, {}>
 
     constructor() { super(value => String(value)); }
 >super(value => String(value)) : void
->super : any
->value => String(value) : (value: any) => string
->value : any
+>super : typeof A
+>value => String(value) : (value: number) => string
+>value : number
 >String(value) : string
 >String : StringConstructor
->value : any
+>value : number
 }
diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.symbols b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.symbols
index 304eb38622a6e..7c7f769659d1c 100644
--- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.symbols
+++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.symbols
@@ -18,6 +18,7 @@ class B extends A {
 >A : Symbol(A, Decl(superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts, 0, 0))
 
     constructor() { super(value => String(value)); }
+>super : Symbol(A, Decl(superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts, 0, 0))
 >value : Symbol(value, Decl(superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts, 7, 26))
 >String : Symbol(String, Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --), Decl(lib.d.ts, --, --))
 >value : Symbol(value, Decl(superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.ts, 7, 26))
diff --git a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.types b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.types
index 0e415e998ec48..66d517344ad49 100644
--- a/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.types
+++ b/tests/baselines/reference/superCallFromClassThatDerivesFromGenericTypeButWithNoTypeArguments1.types
@@ -15,14 +15,14 @@ class A<T1, T2> {
 
 class B extends A {
 >B : B
->A : typeof A
+>A : A<{}, {}>
 
     constructor() { super(value => String(value)); }
 >super(value => String(value)) : void
->super : any
->value => String(value) : (value: any) => string
->value : any
+>super : typeof A
+>value => String(value) : (value: {}) => string
+>value : {}
 >String(value) : string
 >String : StringConstructor
->value : any
+>value : {}
 }
diff --git a/tests/baselines/reference/tooManyTypeParameters1.types b/tests/baselines/reference/tooManyTypeParameters1.types
index 3fd5e574923f7..d4928b3f5f603 100644
--- a/tests/baselines/reference/tooManyTypeParameters1.types
+++ b/tests/baselines/reference/tooManyTypeParameters1.types
@@ -32,6 +32,6 @@ interface I<T> {}
 >T : T
 
 var i: I<number,number>;
->i : any
+>i : I<number>
 >I : I<T>
 
diff --git a/tests/cases/fourslash/codeFixClassImplementInterfaceTypeParamInstantiation.ts b/tests/cases/fourslash/codeFixClassImplementInterfaceTypeParamInstantiation.ts
index 226aee4783390..791b341ac8d8d 100644
--- a/tests/cases/fourslash/codeFixClassImplementInterfaceTypeParamInstantiation.ts
+++ b/tests/cases/fourslash/codeFixClassImplementInterfaceTypeParamInstantiation.ts
@@ -6,4 +6,8 @@
 ////
 //// class C implements I { } 
 
-verify.not.codeFixAvailable();
\ No newline at end of file
+/**
+ * The code fix is available despite the error in the the class extends clause file,
+ *  since I is instantiated as I<{}> (in TS) or I<any> (in JS)
+ */
+verify.codeFixAvailable();
\ No newline at end of file
diff --git a/tests/cases/fourslash/genericCombinators1.ts b/tests/cases/fourslash/genericCombinators1.ts
index 53c40aa0013f6..cb58e3d52fed4 100644
--- a/tests/cases/fourslash/genericCombinators1.ts
+++ b/tests/cases/fourslash/genericCombinators1.ts
@@ -58,7 +58,7 @@ verify.quickInfos({
     5: "(parameter) x: number",
     6: "var c3: Collection<Collection<number>>",
     7: "(parameter) x: A",
-    8: "(parameter) x: any", // Specialized to any because no type argument was specified
+    8: "(parameter) x: B<{}>", // Instantiated as B<{}> because no type argument was specified
     9: "var r1a: Collection<string>",
     10: "var r1b: Collection<string>",
     11: "var r2a: Collection<number>",
diff --git a/tests/cases/fourslash/genericCombinators2.ts b/tests/cases/fourslash/genericCombinators2.ts
index aedadfa301e0a..20d4fee240972 100644
--- a/tests/cases/fourslash/genericCombinators2.ts
+++ b/tests/cases/fourslash/genericCombinators2.ts
@@ -70,7 +70,7 @@ verify.quickInfos({
     "7a": "(parameter) x: number",
     "7b": "(parameter) y: A",
     "8a": "(parameter) x: number",
-    "8b": "(parameter) y: any", // Specialized to any because no type argument was specified
+    "8b": "(parameter) y: B<{}>", // Has fallen back to filled signature due to error from no type argument
     9: "var r1a: Collection<number, string>",
     10: "var r1b: Collection<number, string>",
     11: "var r2a: Collection<Collection<number, number>, number>",
diff --git a/tests/cases/fourslash/noTypeParameterInLHS.ts b/tests/cases/fourslash/noTypeParameterInLHS.ts
index 091226ff1cf00..bc8385976f189 100644
--- a/tests/cases/fourslash/noTypeParameterInLHS.ts
+++ b/tests/cases/fourslash/noTypeParameterInLHS.ts
@@ -7,5 +7,5 @@
 
 verify.quickInfos({
     1: "var i: I<any>",
-    2: "var c: C<any>"
+    2: "var c: C<I<{}>>" // I is missing a type argument, so is instantiated as I<{}> and marked as an error
 });