Merge pull request #3516 from Microsoft/extendsExpressions

Allow expressions in class extends clauses

src/compiler/checker.ts

@@ -2600,56 +2600,127 @@ namespace ts {
             return concatenate(getOuterTypeParametersOfClassOrInterface(symbol), getLocalTypeParametersOfClassOrInterfaceOrTypeAlias(symbol));
         }
 
+        function isConstructorType(type: Type): boolean {
+            return type.flags & TypeFlags.ObjectType && getSignaturesOfType(type, SignatureKind.Construct).length > 0;
+        }
+
+        function getBaseTypeNodeOfClass(type: InterfaceType): ExpressionWithTypeArguments {
+            return getClassExtendsHeritageClauseElement(<ClassLikeDeclaration>type.symbol.valueDeclaration);
+        }
+
+        function getConstructorsForTypeArguments(type: ObjectType, typeArgumentNodes: TypeNode[]): Signature[] {
+            let typeArgCount = typeArgumentNodes ? typeArgumentNodes.length : 0;
+            return filter(getSignaturesOfType(type, SignatureKind.Construct),
+                sig => (sig.typeParameters ? sig.typeParameters.length : 0) === typeArgCount);
+        }
+
+        function getInstantiatedConstructorsForTypeArguments(type: ObjectType, typeArgumentNodes: TypeNode[]): Signature[] {
+            let signatures = getConstructorsForTypeArguments(type, typeArgumentNodes);
+            if (typeArgumentNodes) {
+                let typeArguments = map(typeArgumentNodes, getTypeFromTypeNode);
+                signatures = map(signatures, sig => getSignatureInstantiation(sig, typeArguments));
+            }
+            return signatures;
+        }
+
+        // The base constructor of a class can resolve to
+        // undefinedType if the class has no extends clause,
+        // unknownType if an error occurred during resolution of the extends expression,
+        // nullType if the extends expression is the null value, or
+        // an object type with at least one construct signature.
+        function getBaseConstructorTypeOfClass(type: InterfaceType): ObjectType {
+            if (!type.resolvedBaseConstructorType) {
+                let baseTypeNode = getBaseTypeNodeOfClass(type);
+                if (!baseTypeNode) {
+                    return type.resolvedBaseConstructorType = undefinedType;
+                }
+                if (!pushTypeResolution(type)) {
+                    return unknownType;
+                }
+                let baseConstructorType = checkExpression(baseTypeNode.expression);
+                if (baseConstructorType.flags & TypeFlags.ObjectType) {
+                    // Resolving the members of a class requires us to resolve the base class of that class.
+                    // We force resolution here such that we catch circularities now.
+                    resolveObjectOrUnionTypeMembers(baseConstructorType);
+                }
+                if (!popTypeResolution()) {
+                    error(type.symbol.valueDeclaration, Diagnostics._0_is_referenced_directly_or_indirectly_in_its_own_base_expression, symbolToString(type.symbol));
+                    return type.resolvedBaseConstructorType = unknownType;
+                }
+                if (baseConstructorType !== unknownType && baseConstructorType !== nullType && !isConstructorType(baseConstructorType)) {
+                    error(baseTypeNode.expression, Diagnostics.Type_0_is_not_a_constructor_function_type, typeToString(baseConstructorType));
+                    return type.resolvedBaseConstructorType = unknownType;
+                }
+                type.resolvedBaseConstructorType = baseConstructorType;
+            }
+            return type.resolvedBaseConstructorType;
+        }
+
         function getBaseTypes(type: InterfaceType): ObjectType[] {
-            let typeWithBaseTypes = <InterfaceTypeWithBaseTypes>type;
-            if (!typeWithBaseTypes.baseTypes) {
+            if (!type.resolvedBaseTypes) {
                 if (type.symbol.flags & SymbolFlags.Class) {
-                    resolveBaseTypesOfClass(typeWithBaseTypes);
+                    resolveBaseTypesOfClass(type);
                 }
                 else if (type.symbol.flags & SymbolFlags.Interface) {
-                    resolveBaseTypesOfInterface(typeWithBaseTypes);
+                    resolveBaseTypesOfInterface(type);
                 }
                 else {
                     Debug.fail("type must be class or interface");
                 }
             }
-
-            return typeWithBaseTypes.baseTypes;
+            return type.resolvedBaseTypes;
         }
 
-        function resolveBaseTypesOfClass(type: InterfaceTypeWithBaseTypes): void {
-            type.baseTypes = [];
-            let declaration = <ClassDeclaration>getDeclarationOfKind(type.symbol, SyntaxKind.ClassDeclaration);
-            let baseTypeNode = getClassExtendsHeritageClauseElement(declaration);
-            if (baseTypeNode) {
-                let baseType = getTypeFromTypeNode(baseTypeNode);
-                if (baseType !== unknownType) {
-                    if (getTargetType(baseType).flags & TypeFlags.Class) {
-                        if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
-                            type.baseTypes.push(baseType);
-                        }
-                        else {
-                            error(declaration, Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
-                        }
-                    }
-                    else {
-                        error(baseTypeNode, Diagnostics.A_class_may_only_extend_another_class);
-                    }
-                }
+        function resolveBaseTypesOfClass(type: InterfaceType): void {
+            type.resolvedBaseTypes = emptyArray;
+            let baseContructorType = getBaseConstructorTypeOfClass(type);
+            if (!(baseContructorType.flags & TypeFlags.ObjectType)) {
+                return;
             }
+            let baseTypeNode = getBaseTypeNodeOfClass(type);
+            let baseType: Type;
+            if (baseContructorType.symbol && baseContructorType.symbol.flags & SymbolFlags.Class) {
+                // When base constructor type is a class we know that the constructors all have the same type parameters as the
+                // class and all return the instance type of the class. There is no need for further checks and we can apply the
+                // type arguments in the same manner as a type reference to get the same error reporting experience.
+                baseType = getTypeFromClassOrInterfaceReference(baseTypeNode, baseContructorType.symbol);
+            }
+            else {
+                // The class derives from a "class-like" constructor function, check that we have at least one construct signature
+                // with a matching number of type parameters and use the return type of the first instantiated signature. Elsewhere
+                // we check that all instantiated signatures return the same type.
+                let constructors = getInstantiatedConstructorsForTypeArguments(baseContructorType, baseTypeNode.typeArguments);
+                if (!constructors.length) {
+                    error(baseTypeNode.expression, Diagnostics.No_base_constructor_has_the_specified_number_of_type_arguments);
+                    return;
+                }
+                baseType = getReturnTypeOfSignature(constructors[0]);
+            }
+            if (baseType === unknownType) {
+                return;
+            }
+            if (!(getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface))) {
+                error(baseTypeNode.expression, Diagnostics.Base_constructor_return_type_0_is_not_a_class_or_interface_type, typeToString(baseType));
+                return;
+            }
+            if (type === baseType || hasBaseType(<InterfaceType>baseType, type)) {
+                error(type.symbol.valueDeclaration, Diagnostics.Type_0_recursively_references_itself_as_a_base_type,
+                    typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
+                return;
+            }
+            type.resolvedBaseTypes = [baseType];
         }
 
-        function resolveBaseTypesOfInterface(type: InterfaceTypeWithBaseTypes): void {
-            type.baseTypes = [];
+        function resolveBaseTypesOfInterface(type: InterfaceType): void {
+            type.resolvedBaseTypes = [];
             for (let declaration of type.symbol.declarations) {
                 if (declaration.kind === SyntaxKind.InterfaceDeclaration && getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
                     for (let node of getInterfaceBaseTypeNodes(<InterfaceDeclaration>declaration)) {
                         let baseType = getTypeFromTypeNode(node);
-
                         if (baseType !== unknownType) {
                             if (getTargetType(baseType).flags & (TypeFlags.Class | TypeFlags.Interface)) {
                                 if (type !== baseType && !hasBaseType(<InterfaceType>baseType, type)) {
-                                    type.baseTypes.push(baseType);
+                                    type.resolvedBaseTypes.push(baseType);
                                 }
                                 else {
                                     error(declaration, Diagnostics.Type_0_recursively_references_itself_as_a_base_type, typeToString(type, /*enclosingDeclaration*/ undefined, TypeFormatFlags.WriteArrayAsGenericType));
@@ -2867,20 +2938,26 @@ namespace ts {
                 sig.minArgumentCount, sig.hasRestParameter, sig.hasStringLiterals);
         }
 
-        function getDefaultConstructSignatures(classType: InterfaceType): Signature[]{
-            let baseTypes = getBaseTypes(classType);
-            if (baseTypes.length) {
-                let baseType = baseTypes[0];
-                let baseSignatures = getSignaturesOfType(getTypeOfSymbol(baseType.symbol), SignatureKind.Construct);
-                return map(baseSignatures, baseSignature => {
-                    let signature = baseType.flags & TypeFlags.Reference ?
-                        getSignatureInstantiation(baseSignature, (<TypeReference>baseType).typeArguments) : cloneSignature(baseSignature);
-                    signature.typeParameters = classType.localTypeParameters;
-                    signature.resolvedReturnType = classType;
-                    return signature;
-                });
+        function getDefaultConstructSignatures(classType: InterfaceType): Signature[] {
+            if (!getBaseTypes(classType).length) {
+                return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)];
             }
-            return [createSignature(undefined, classType.localTypeParameters, emptyArray, classType, undefined, 0, false, false)];
+            let baseConstructorType = getBaseConstructorTypeOfClass(classType);
+            let baseSignatures = getSignaturesOfType(baseConstructorType, SignatureKind.Construct);
+            let baseTypeNode = getBaseTypeNodeOfClass(classType);
+            let typeArguments = map(baseTypeNode.typeArguments, getTypeFromTypeNode);
+            let typeArgCount = typeArguments ? typeArguments.length : 0;
+            let result: Signature[] = [];
+            for (let baseSig of baseSignatures) {
+                let typeParamCount = baseSig.typeParameters ? baseSig.typeParameters.length : 0;
+                if (typeParamCount === typeArgCount) {
+                    let sig = typeParamCount ? getSignatureInstantiation(baseSig, typeArguments) : cloneSignature(baseSig);
+                    sig.typeParameters = classType.localTypeParameters;
+                    sig.resolvedReturnType = classType;
+                    result.push(sig);
+                }
+            }
+            return result;
         }
 
         function createTupleTypeMemberSymbols(memberTypes: Type[]): SymbolTable {
@@ -2992,10 +3069,10 @@ namespace ts {
                     if (!constructSignatures.length) {
                         constructSignatures = getDefaultConstructSignatures(classType);
                     }
-                    let baseTypes = getBaseTypes(classType);
-                    if (baseTypes.length) {
+                    let baseConstructorType = getBaseConstructorTypeOfClass(classType);
+                    if (baseConstructorType.flags & TypeFlags.ObjectType) {
                         members = createSymbolTable(getNamedMembers(members));
-                        addInheritedMembers(members, getPropertiesOfObjectType(getTypeOfSymbol(baseTypes[0].symbol)));
+                        addInheritedMembers(members, getPropertiesOfObjectType(baseConstructorType));
                     }
                 }
                 stringIndexType = undefined;
@@ -4127,14 +4204,14 @@ namespace ts {
             return !node.typeParameters && node.parameters.length && !forEach(node.parameters, p => p.type);
         }
 
-        function getTypeWithoutConstructors(type: Type): Type {
+        function getTypeWithoutSignatures(type: Type): Type {
             if (type.flags & TypeFlags.ObjectType) {
                 let resolved = resolveObjectOrUnionTypeMembers(<ObjectType>type);
                 if (resolved.constructSignatures.length) {
                     let result = <ResolvedType>createObjectType(TypeFlags.Anonymous, type.symbol);
                     result.members = resolved.members;
                     result.properties = resolved.properties;
-                    result.callSignatures = resolved.callSignatures;
+                    result.callSignatures = emptyArray;
                     result.constructSignatures = emptyArray;
                     type = result;
                 }
@@ -5881,16 +5958,14 @@ namespace ts {
 
         function checkSuperExpression(node: Node): Type {
             let isCallExpression = node.parent.kind === SyntaxKind.CallExpression && (<CallExpression>node.parent).expression === node;
-            let enclosingClass = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
-            let baseClass: Type;
-            if (enclosingClass && getClassExtendsHeritageClauseElement(enclosingClass)) {
-                let classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(enclosingClass));
-                let baseTypes = getBaseTypes(classType);
-                baseClass = baseTypes.length && baseTypes[0];
-            }
+            let classDeclaration = <ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration);
+            let classType = classDeclaration && <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(classDeclaration));
+            let baseClassType = classType && getBaseTypes(classType)[0];
 
-            if (!baseClass) {
-                error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);
+            if (!baseClassType) {
+                if (!classDeclaration || !getClassExtendsHeritageClauseElement(classDeclaration)) {
+                    error(node, Diagnostics.super_can_only_be_referenced_in_a_derived_class);
+                }
                 return unknownType;
             }
 
@@ -5944,11 +6019,11 @@ namespace ts {
 
                     if ((container.flags & NodeFlags.Static) || isCallExpression) {
                         getNodeLinks(node).flags |= NodeCheckFlags.SuperStatic;
-                        returnType = getTypeOfSymbol(baseClass.symbol);
+                        returnType = getBaseConstructorTypeOfClass(classType);
                     }
                     else {
                         getNodeLinks(node).flags |= NodeCheckFlags.SuperInstance;
-                        returnType = baseClass;
+                        returnType = baseClassType;
                     }
 
                     if (container.kind === SyntaxKind.Constructor && isInConstructorArgumentInitializer(node, container)) {
@@ -7135,35 +7210,13 @@ namespace ts {
             return args;
         }
 
-        /**
-         * In a 'super' call, type arguments are not provided within the CallExpression node itself.
-         * Instead, they must be fetched from the class declaration's base type node.
-         *
-         * If 'node' is a 'super' call (e.g. super(...), new super(...)), then we attempt to fetch
-         * the type arguments off the containing class's first heritage clause (if one exists). Note that if
-         * type arguments are supplied on the 'super' call, they are ignored (though this is syntactically incorrect).
-         *
-         * In all other cases, the call's explicit type arguments are returned.
-         */
-        function getEffectiveTypeArguments(callExpression: CallExpression): TypeNode[] {
-            if (callExpression.expression.kind === SyntaxKind.SuperKeyword) {
-                let containingClass = <ClassDeclaration>getAncestor(callExpression, SyntaxKind.ClassDeclaration);
-                let baseClassTypeNode = containingClass && getClassExtendsHeritageClauseElement(containingClass);
-                return baseClassTypeNode && baseClassTypeNode.typeArguments;
-            }
-            else {
-                // Ordinary case - simple function invocation.
-                return callExpression.typeArguments;
-            }
-        }
-
         function resolveCall(node: CallLikeExpression, signatures: Signature[], candidatesOutArray: Signature[]): Signature {
             let isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
 
             let typeArguments: TypeNode[];
 
             if (!isTaggedTemplate) {
-                typeArguments = getEffectiveTypeArguments(<CallExpression>node);
+                typeArguments = (<CallExpression>node).typeArguments;
 
                 // We already perform checking on the type arguments on the class declaration itself.
                 if ((<CallExpression>node).expression.kind !== SyntaxKind.SuperKeyword) {
@@ -7371,7 +7424,11 @@ namespace ts {
             if (node.expression.kind === SyntaxKind.SuperKeyword) {
                 let superType = checkSuperExpression(node.expression);
                 if (superType !== unknownType) {
-                    return resolveCall(node, getSignaturesOfType(superType, SignatureKind.Construct), candidatesOutArray);
+                    // In super call, the candidate signatures are the matching arity signatures of the base constructor function instantiated
+                    // with the type arguments specified in the extends clause.
+                    let baseTypeNode = getClassExtendsHeritageClauseElement(<ClassDeclaration>getAncestor(node, SyntaxKind.ClassDeclaration));
+                    let baseConstructors = getInstantiatedConstructorsForTypeArguments(superType, baseTypeNode.typeArguments);
+                    return resolveCall(node, baseConstructors, candidatesOutArray);
                 }
                 return resolveUntypedCall(node);
             }
@@ -8916,31 +8973,28 @@ namespace ts {
             checkDecorators(node);
         }
 
-        function checkTypeReferenceNode(node: TypeReferenceNode) {
-            return checkTypeReferenceOrExpressionWithTypeArguments(node);
+        function checkTypeArgumentConstraints(typeParameters: TypeParameter[], typeArguments: TypeNode[]): boolean {
+            let result = true;
+            for (let i = 0; i < typeParameters.length; i++) {
+                let constraint = getConstraintOfTypeParameter(typeParameters[i]);
+                if (constraint) {
+                    let typeArgument = typeArguments[i];
+                    result = result && checkTypeAssignableTo(getTypeFromTypeNode(typeArgument), constraint, typeArgument, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
+                }
+            }
+            return result;
         }
 
-        function checkExpressionWithTypeArguments(node: ExpressionWithTypeArguments) {
-            return checkTypeReferenceOrExpressionWithTypeArguments(node);
-        }
-
-        function checkTypeReferenceOrExpressionWithTypeArguments(node: TypeReferenceNode | ExpressionWithTypeArguments) {
-            // Grammar checking
+        function checkTypeReferenceNode(node: TypeReferenceNode | ExpressionWithTypeArguments) {
             checkGrammarTypeArguments(node, node.typeArguments);
-
             let type = getTypeFromTypeReference(node);
             if (type !== unknownType && node.typeArguments) {
                 // Do type argument local checks only if referenced type is successfully resolved
-                let symbol = getNodeLinks(node).resolvedSymbol;
-                let typeParameters = symbol.flags & SymbolFlags.TypeAlias ? getSymbolLinks(symbol).typeParameters : (<TypeReference>type).target.localTypeParameters;
-                let len = node.typeArguments.length;
-                for (let i = 0; i < len; i++) {
-                    checkSourceElement(node.typeArguments[i]);
-                    let constraint = getConstraintOfTypeParameter(typeParameters[i]);
-                    if (produceDiagnostics && constraint) {
-                        let typeArgument = (<TypeReference>type).typeArguments[i];
-                        checkTypeAssignableTo(typeArgument, constraint, node, Diagnostics.Type_0_does_not_satisfy_the_constraint_1);
-                    }
+                forEach(node.typeArguments, checkSourceElement);
+                if (produceDiagnostics) {
+                    let symbol = getNodeLinks(node).resolvedSymbol;
+                    let typeParameters = symbol.flags & SymbolFlags.TypeAlias ? getSymbolLinks(symbol).typeParameters : (<TypeReference>type).target.localTypeParameters;
+                    checkTypeArgumentConstraints(typeParameters, node.typeArguments);
                 }
             }
         }
@@ -10532,45 +10586,46 @@ namespace ts {
             let symbol = getSymbolOfNode(node);
             let type = <InterfaceType>getDeclaredTypeOfSymbol(symbol);
             let staticType = <ObjectType>getTypeOfSymbol(symbol);
+
             let baseTypeNode = getClassExtendsHeritageClauseElement(node);
             if (baseTypeNode) {
-                if (!isSupportedExpressionWithTypeArguments(baseTypeNode)) {
-                    error(baseTypeNode.expression, Diagnostics.Only_identifiers_Slashqualified_names_with_optional_type_arguments_are_currently_supported_in_a_class_extends_clauses);
-                }
-
                 emitExtends = emitExtends || !isInAmbientContext(node);
-                checkExpressionWithTypeArguments(baseTypeNode);
-            }
-            let baseTypes = getBaseTypes(type);
-            if (baseTypes.length) {
-                if (produceDiagnostics) {
+                let baseTypes = getBaseTypes(type);
+                if (baseTypes.length && produceDiagnostics) {
                     let baseType = baseTypes[0];
+                    let staticBaseType = getBaseConstructorTypeOfClass(type);
+                    if (baseTypeNode.typeArguments) {
+                        forEach(baseTypeNode.typeArguments, checkSourceElement);
+                        for (let constructor of getConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments)) {
+                            if (!checkTypeArgumentConstraints(constructor.typeParameters, baseTypeNode.typeArguments)) {
+                                break;
+                            }
+                        }
+                    }
                     checkTypeAssignableTo(type, baseType, node.name || node, Diagnostics.Class_0_incorrectly_extends_base_class_1);
-                    let staticBaseType = getTypeOfSymbol(baseType.symbol);
-                    checkTypeAssignableTo(staticType, getTypeWithoutConstructors(staticBaseType), node.name || node,
+                    checkTypeAssignableTo(staticType, getTypeWithoutSignatures(staticBaseType), node.name || node,
                         Diagnostics.Class_static_side_0_incorrectly_extends_base_class_static_side_1);
-
-                    if (baseType.symbol !== resolveEntityName(baseTypeNode.expression, SymbolFlags.Value)) {
-                        error(baseTypeNode, Diagnostics.Type_name_0_in_extends_clause_does_not_reference_constructor_function_for_0, typeToString(baseType));
+                    if (!(staticBaseType.symbol && staticBaseType.symbol.flags & SymbolFlags.Class)) {
+                        // When the static base type is a "class-like" constructor function (but not actually a class), we verify
+                        // that all instantiated base constructor signatures return the same type. We can simply compare the type
+                        // references (as opposed to checking the structure of the types) because elsewhere we have already checked
+                        // that the base type is a class or interface type (and not, for example, an anonymous object type).
+                        let constructors = getInstantiatedConstructorsForTypeArguments(staticBaseType, baseTypeNode.typeArguments);
+                        if (forEach(constructors, sig => getReturnTypeOfSignature(sig) !== baseType)) {
+                            error(baseTypeNode.expression, Diagnostics.Base_constructors_must_all_have_the_same_return_type);
+                        }
                     }
-
                     checkKindsOfPropertyMemberOverrides(type, baseType);
                 }
             }
 
-            if (baseTypes.length || (baseTypeNode && compilerOptions.isolatedModules)) {
-                // Check that base type can be evaluated as expression
-                checkExpression(baseTypeNode.expression);
-            }
-
             let implementedTypeNodes = getClassImplementsHeritageClauseElements(node);
             if (implementedTypeNodes) {
                 forEach(implementedTypeNodes, typeRefNode => {
                     if (!isSupportedExpressionWithTypeArguments(typeRefNode)) {
                         error(typeRefNode.expression, Diagnostics.A_class_can_only_implement_an_identifier_Slashqualified_name_with_optional_type_arguments);
                     }
-
-                    checkExpressionWithTypeArguments(typeRefNode);
+                    checkTypeReferenceNode(typeRefNode);
                     if (produceDiagnostics) {
                         let t = getTypeFromTypeNode(typeRefNode);
                         if (t !== unknownType) {
@@ -10770,8 +10825,7 @@ namespace ts {
                 if (!isSupportedExpressionWithTypeArguments(heritageElement)) {
                     error(heritageElement.expression, Diagnostics.An_interface_can_only_extend_an_identifier_Slashqualified_name_with_optional_type_arguments);
                 }
-
-                checkExpressionWithTypeArguments(heritageElement);
+                checkTypeReferenceNode(heritageElement);
             });
             forEach(node.members, checkSourceElement);
 
@@ -11956,6 +12010,12 @@ namespace ts {
                 return getTypeOfExpression(<Expression>node);
             }
 
+            if (isExpressionWithTypeArgumentsInClassExtendsClause(node)) {
+                // A SyntaxKind.ExpressionWithTypeArguments is considered a type node, except when it occurs in the
+                // extends clause of a class. We handle that case here.
+                return getBaseTypes(<InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(node.parent.parent)))[0];
+            }
+
             if (isTypeDeclaration(node)) {
                 // In this case, we call getSymbolOfNode instead of getSymbolInfo because it is a declaration
                 let symbol = getSymbolOfNode(node);

src/compiler/diagnosticInformationMap.generated.ts

@@ -384,6 +384,11 @@ namespace ts {
         Cannot_find_namespace_0: { code: 2503, category: DiagnosticCategory.Error, key: "Cannot find namespace '{0}'." },
         No_best_common_type_exists_among_yield_expressions: { code: 2504, category: DiagnosticCategory.Error, key: "No best common type exists among yield expressions." },
         A_generator_cannot_have_a_void_type_annotation: { code: 2505, category: DiagnosticCategory.Error, key: "A generator cannot have a 'void' type annotation." },
+        _0_is_referenced_directly_or_indirectly_in_its_own_base_expression: { code: 2506, category: DiagnosticCategory.Error, key: "'{0}' is referenced directly or indirectly in its own base expression." },
+        Type_0_is_not_a_constructor_function_type: { code: 2507, category: DiagnosticCategory.Error, key: "Type '{0}' is not a constructor function type." },
+        No_base_constructor_has_the_specified_number_of_type_arguments: { code: 2508, category: DiagnosticCategory.Error, key: "No base constructor has the specified number of type arguments." },
+        Base_constructor_return_type_0_is_not_a_class_or_interface_type: { code: 2509, category: DiagnosticCategory.Error, key: "Base constructor return type '{0}' is not a class or interface type." },
+        Base_constructors_must_all_have_the_same_return_type: { code: 2510, category: DiagnosticCategory.Error, key: "Base constructors must all have the same return type." },
         Import_declaration_0_is_using_private_name_1: { code: 4000, category: DiagnosticCategory.Error, key: "Import declaration '{0}' is using private name '{1}'." },
         Type_parameter_0_of_exported_class_has_or_is_using_private_name_1: { code: 4002, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported class has or is using private name '{1}'." },
         Type_parameter_0_of_exported_interface_has_or_is_using_private_name_1: { code: 4004, category: DiagnosticCategory.Error, key: "Type parameter '{0}' of exported interface has or is using private name '{1}'." },

src/compiler/diagnosticMessages.json

@@ -1525,6 +1525,26 @@
         "category": "Error",
         "code": 2505
     },
+    "'{0}' is referenced directly or indirectly in its own base expression.": {
+        "category": "Error",
+        "code": 2506
+    },
+    "Type '{0}' is not a constructor function type.": {
+        "category": "Error",
+        "code": 2507
+    },
+    "No base constructor has the specified number of type arguments.": {
+        "category": "Error",
+        "code": 2508
+    },
+    "Base constructor return type '{0}' is not a class or interface type.": {
+        "category": "Error",
+        "code": 2509
+    },
+    "Base constructors must all have the same return type.": {
+        "category": "Error",
+        "code": 2510
+    },
 
     "Import declaration '{0}' is using private name '{1}'.": {
         "category": "Error",

src/compiler/types.ts

@@ -1669,10 +1669,8 @@ namespace ts {
         typeParameters: TypeParameter[];           // Type parameters (undefined if non-generic)
         outerTypeParameters: TypeParameter[];      // Outer type parameters (undefined if none)
         localTypeParameters: TypeParameter[];      // Local type parameters (undefined if none)
-    }
-
-    export interface InterfaceTypeWithBaseTypes extends InterfaceType {
-        baseTypes: ObjectType[];
+        resolvedBaseConstructorType?: Type;        // Resolved base constructor type of class
+        resolvedBaseTypes: ObjectType[];           // Resolved base types
     }
 
     export interface InterfaceTypeWithDeclaredMembers extends InterfaceType {

src/compiler/utilities.ts

@@ -426,7 +426,7 @@ namespace ts {
                 // Specialized signatures can have string literals as their parameters' type names
                 return node.parent.kind === SyntaxKind.Parameter;
             case SyntaxKind.ExpressionWithTypeArguments:
-                return true;
+                return !isExpressionWithTypeArgumentsInClassExtendsClause(node);
 
             // Identifiers and qualified names may be type nodes, depending on their context. Climb
             // above them to find the lowest container
@@ -460,7 +460,7 @@ namespace ts {
                 }
                 switch (parent.kind) {
                     case SyntaxKind.ExpressionWithTypeArguments:
-                        return true;
+                        return !isExpressionWithTypeArgumentsInClassExtendsClause(parent);
                     case SyntaxKind.TypeParameter:
                         return node === (<TypeParameterDeclaration>parent).constraint;
                     case SyntaxKind.PropertyDeclaration:
@@ -872,7 +872,6 @@ namespace ts {
                 while (node.parent.kind === SyntaxKind.QualifiedName) {
                     node = node.parent;
                 }
-
                 return node.parent.kind === SyntaxKind.TypeQuery;
             case SyntaxKind.Identifier:
                 if (node.parent.kind === SyntaxKind.TypeQuery) {
@@ -920,6 +919,8 @@ namespace ts {
                         return node === (<ComputedPropertyName>parent).expression;
                     case SyntaxKind.Decorator:
                         return true;
+                    case SyntaxKind.ExpressionWithTypeArguments:
+                        return (<ExpressionWithTypeArguments>parent).expression === node && isExpressionWithTypeArgumentsInClassExtendsClause(parent);
                     default:
                         if (isExpression(parent)) {
                             return true;
@@ -1913,6 +1914,12 @@ namespace ts {
         return token >= SyntaxKind.FirstAssignment && token <= SyntaxKind.LastAssignment;
     }
 
+    export function isExpressionWithTypeArgumentsInClassExtendsClause(node: Node): boolean {
+        return node.kind === SyntaxKind.ExpressionWithTypeArguments &&
+            (<HeritageClause>node.parent).token === SyntaxKind.ExtendsKeyword &&
+            node.parent.parent.kind === SyntaxKind.ClassDeclaration;
+    }
+
     // Returns false if this heritage clause element's expression contains something unsupported
     // (i.e. not a name or dotted name).
     export function isSupportedExpressionWithTypeArguments(node: ExpressionWithTypeArguments): boolean {

src/harness/typeWriter.ts

@@ -41,7 +41,10 @@ class TypeWriterWalker {
         var lineAndCharacter = this.currentSourceFile.getLineAndCharacterOfPosition(actualPos);
         var sourceText = ts.getTextOfNodeFromSourceText(this.currentSourceFile.text, node);
 
-        var type = this.checker.getTypeAtLocation(node);
+        // Workaround to ensure we output 'C' instead of 'typeof C' for base class expressions
+        // var type = this.checker.getTypeAtLocation(node);
+        var type = node.parent && ts.isExpressionWithTypeArgumentsInClassExtendsClause(node.parent) && this.checker.getTypeAtLocation(node.parent) || this.checker.getTypeAtLocation(node);
+
         ts.Debug.assert(type !== undefined, "type doesn't exist");
         var symbol = this.checker.getSymbolAtLocation(node);
 

src/services/services.ts

@@ -5811,7 +5811,8 @@ namespace ts {
                 node = node.parent;
             }
 
-            return node.parent.kind === SyntaxKind.TypeReference || node.parent.kind === SyntaxKind.ExpressionWithTypeArguments;
+            return node.parent.kind === SyntaxKind.TypeReference ||
+                (node.parent.kind === SyntaxKind.ExpressionWithTypeArguments && !isExpressionWithTypeArgumentsInClassExtendsClause(<ExpressionWithTypeArguments>node.parent));
         }
 
         function isNamespaceReference(node: Node): boolean {

tests/baselines/reference/aliasUsageInAccessorsOfClass.types

@@ -53,9 +53,9 @@ import Backbone = require("aliasUsage1_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInArray.types

@@ -41,9 +41,9 @@ import Backbone = require("aliasUsageInArray_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInFunctionExpression.types

@@ -42,9 +42,9 @@ import Backbone = require("aliasUsageInFunctionExpression_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInGenericFunction.types

@@ -57,9 +57,9 @@ import Backbone = require("aliasUsageInGenericFunction_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInIndexerOfClass.types

@@ -50,9 +50,9 @@ import Backbone = require("aliasUsageInIndexerOfClass_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInObjectLiteral.types

@@ -55,9 +55,9 @@ import Backbone = require("aliasUsageInObjectLiteral_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInOrExpression.types

@@ -79,9 +79,9 @@ import Backbone = require("aliasUsageInOrExpression_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInTypeArgumentOfExtendsClause.types

@@ -25,7 +25,7 @@ class C<T extends IHasVisualizationModel> {
 }
 class D extends C<IHasVisualizationModel> {
 >D : D
->C : C<T>
+>C : C<IHasVisualizationModel>
 >IHasVisualizationModel : IHasVisualizationModel
 
     x = moduleA;
@@ -46,9 +46,9 @@ import Backbone = require("aliasUsageInTypeArgumentOfExtendsClause_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/aliasUsageInVarAssignment.types

@@ -37,9 +37,9 @@ import Backbone = require("aliasUsageInVarAssignment_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }

tests/baselines/reference/arrayLiteralsWithRecursiveGenerics.types

@@ -17,7 +17,7 @@ class List<T> {
 class DerivedList<U> extends List<U> {
 >DerivedList : DerivedList<U>
 >U : U
->List : List<T>
+>List : List<U>
 >U : U
 
     foo: U;

tests/baselines/reference/baseTypeWrappingInstantiationChain.types

@@ -2,7 +2,7 @@
 class C<T1> extends CBase<T1> {
 >C : C<T1>
 >T1 : T1
->CBase : CBase<T2>
+>CBase : CBase<T1>
 >T1 : T1
 
     public works() {
@@ -35,7 +35,7 @@ class C<T1> extends CBase<T1> {
 class CBase<T2> extends CBaseBase<Wrapper<T2>> {
 >CBase : CBase<T2>
 >T2 : T2
->CBaseBase : CBaseBase<T3>
+>CBaseBase : CBaseBase<Wrapper<T2>>
 >Wrapper : Wrapper<T5>
 >T2 : T2
 

tests/baselines/reference/checkForObjectTooStrict.errors.txt

@@ -1,40 +0,0 @@
-tests/cases/compiler/checkForObjectTooStrict.ts(22,19): error TS2311: A class may only extend another class.
-tests/cases/compiler/checkForObjectTooStrict.ts(26,9): error TS2335: 'super' can only be referenced in a derived class.
-
-
-==== tests/cases/compiler/checkForObjectTooStrict.ts (2 errors) ====
-    module Foo {
-    
-        export class Object {
-    
-        }
-    
-    }
-    
-     
-    
-    class Bar extends Foo.Object { // should work
-    
-        constructor () {
-    
-            super();
-    
-        }
-    
-    }
-    
-    
-    class Baz extends Object {
-                      ~~~~~~
-!!! error TS2311: A class may only extend another class.
-    
-        constructor () { // ERROR, as expected
-    
-            super();
-            ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
-    
-        }
-    
-    }
-    

tests/baselines/reference/checkForObjectTooStrict.symbols

@@ -0,0 +1,42 @@
+=== tests/cases/compiler/checkForObjectTooStrict.ts ===
+module Foo {
+>Foo : Symbol(Foo, Decl(checkForObjectTooStrict.ts, 0, 0))
+
+    export class Object {
+>Object : Symbol(Object, Decl(checkForObjectTooStrict.ts, 0, 12))
+
+    }
+
+}
+
+ 
+
+class Bar extends Foo.Object { // should work
+>Bar : Symbol(Bar, Decl(checkForObjectTooStrict.ts, 6, 1))
+>Foo.Object : Symbol(Foo.Object, Decl(checkForObjectTooStrict.ts, 0, 12))
+>Foo : Symbol(Foo, Decl(checkForObjectTooStrict.ts, 0, 0))
+>Object : Symbol(Foo.Object, Decl(checkForObjectTooStrict.ts, 0, 12))
+
+    constructor () {
+
+        super();
+>super : Symbol(Foo.Object, Decl(checkForObjectTooStrict.ts, 0, 12))
+
+    }
+
+}
+
+
+class Baz extends Object {
+>Baz : Symbol(Baz, Decl(checkForObjectTooStrict.ts, 18, 1))
+>Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+
+    constructor () { // ERROR, as expected
+
+        super();
+>super : Symbol(ObjectConstructor, Decl(lib.d.ts, 124, 1))
+
+    }
+
+}
+

tests/baselines/reference/checkForObjectTooStrict.types

@@ -0,0 +1,44 @@
+=== tests/cases/compiler/checkForObjectTooStrict.ts ===
+module Foo {
+>Foo : typeof Foo
+
+    export class Object {
+>Object : Object
+
+    }
+
+}
+
+ 
+
+class Bar extends Foo.Object { // should work
+>Bar : Bar
+>Foo.Object : Foo.Object
+>Foo : typeof Foo
+>Object : typeof Foo.Object
+
+    constructor () {
+
+        super();
+>super() : void
+>super : typeof Foo.Object
+
+    }
+
+}
+
+
+class Baz extends Object {
+>Baz : Baz
+>Object : Object
+
+    constructor () { // ERROR, as expected
+
+        super();
+>super() : void
+>super : ObjectConstructor
+
+    }
+
+}
+

tests/baselines/reference/circularImportAlias.types

@@ -10,9 +10,9 @@ module B {
 
     export class D extends a.C {
 >D : D
->a.C : any
+>a.C : a.C
 >a : typeof a
->C : a.C
+>C : typeof a.C
 
         id: number;
 >id : number

tests/baselines/reference/classDeclarationMergedInModuleWithContinuation.types

@@ -19,8 +19,8 @@ module M {
 
     export class O extends M.N {
 >O : O
->M.N : any
+>M.N : N
 >M : typeof M
->N : N
+>N : typeof N
     }
 }

tests/baselines/reference/classExtendingBuiltinType.js

@@ -0,0 +1,89 @@
+//// [classExtendingBuiltinType.ts]
+class C1 extends Object { }
+class C2 extends Function { }
+class C3 extends String { }
+class C4 extends Boolean { }
+class C5 extends Number { }
+class C6 extends Date { }
+class C7 extends RegExp { }
+class C8 extends Error { }
+class C9 extends Array { }
+class C10 extends Array<number> { }
+
+
+//// [classExtendingBuiltinType.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var C1 = (function (_super) {
+    __extends(C1, _super);
+    function C1() {
+        _super.apply(this, arguments);
+    }
+    return C1;
+})(Object);
+var C2 = (function (_super) {
+    __extends(C2, _super);
+    function C2() {
+        _super.apply(this, arguments);
+    }
+    return C2;
+})(Function);
+var C3 = (function (_super) {
+    __extends(C3, _super);
+    function C3() {
+        _super.apply(this, arguments);
+    }
+    return C3;
+})(String);
+var C4 = (function (_super) {
+    __extends(C4, _super);
+    function C4() {
+        _super.apply(this, arguments);
+    }
+    return C4;
+})(Boolean);
+var C5 = (function (_super) {
+    __extends(C5, _super);
+    function C5() {
+        _super.apply(this, arguments);
+    }
+    return C5;
+})(Number);
+var C6 = (function (_super) {
+    __extends(C6, _super);
+    function C6() {
+        _super.apply(this, arguments);
+    }
+    return C6;
+})(Date);
+var C7 = (function (_super) {
+    __extends(C7, _super);
+    function C7() {
+        _super.apply(this, arguments);
+    }
+    return C7;
+})(RegExp);
+var C8 = (function (_super) {
+    __extends(C8, _super);
+    function C8() {
+        _super.apply(this, arguments);
+    }
+    return C8;
+})(Error);
+var C9 = (function (_super) {
+    __extends(C9, _super);
+    function C9() {
+        _super.apply(this, arguments);
+    }
+    return C9;
+})(Array);
+var C10 = (function (_super) {
+    __extends(C10, _super);
+    function C10() {
+        _super.apply(this, arguments);
+    }
+    return C10;
+})(Array);

tests/baselines/reference/classExtendingBuiltinType.symbols

@@ -0,0 +1,41 @@
+=== tests/cases/conformance/classes/classDeclarations/classExtendingBuiltinType.ts ===
+class C1 extends Object { }
+>C1 : Symbol(C1, Decl(classExtendingBuiltinType.ts, 0, 0))
+>Object : Symbol(Object, Decl(lib.d.ts, 92, 1), Decl(lib.d.ts, 223, 11))
+
+class C2 extends Function { }
+>C2 : Symbol(C2, Decl(classExtendingBuiltinType.ts, 0, 27))
+>Function : Symbol(Function, Decl(lib.d.ts, 223, 38), Decl(lib.d.ts, 269, 11))
+
+class C3 extends String { }
+>C3 : Symbol(C3, Decl(classExtendingBuiltinType.ts, 1, 29))
+>String : Symbol(String, Decl(lib.d.ts, 275, 1), Decl(lib.d.ts, 443, 11))
+
+class C4 extends Boolean { }
+>C4 : Symbol(C4, Decl(classExtendingBuiltinType.ts, 2, 27))
+>Boolean : Symbol(Boolean, Decl(lib.d.ts, 443, 38), Decl(lib.d.ts, 456, 11))
+
+class C5 extends Number { }
+>C5 : Symbol(C5, Decl(classExtendingBuiltinType.ts, 3, 28))
+>Number : Symbol(Number, Decl(lib.d.ts, 456, 40), Decl(lib.d.ts, 518, 11))
+
+class C6 extends Date { }
+>C6 : Symbol(C6, Decl(classExtendingBuiltinType.ts, 4, 27))
+>Date : Symbol(Date, Decl(lib.d.ts, 633, 23), Decl(lib.d.ts, 815, 11))
+
+class C7 extends RegExp { }
+>C7 : Symbol(C7, Decl(classExtendingBuiltinType.ts, 5, 25))
+>RegExp : Symbol(RegExp, Decl(lib.d.ts, 825, 1), Decl(lib.d.ts, 876, 11))
+
+class C8 extends Error { }
+>C8 : Symbol(C8, Decl(classExtendingBuiltinType.ts, 6, 27))
+>Error : Symbol(Error, Decl(lib.d.ts, 876, 38), Decl(lib.d.ts, 889, 11))
+
+class C9 extends Array { }
+>C9 : Symbol(C9, Decl(classExtendingBuiltinType.ts, 7, 26))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+
+class C10 extends Array<number> { }
+>C10 : Symbol(C10, Decl(classExtendingBuiltinType.ts, 8, 26))
+>Array : Symbol(Array, Decl(lib.d.ts, 1000, 23), Decl(lib.d.ts, 1171, 11))
+

tests/baselines/reference/classExtendingBuiltinType.types

@@ -0,0 +1,41 @@
+=== tests/cases/conformance/classes/classDeclarations/classExtendingBuiltinType.ts ===
+class C1 extends Object { }
+>C1 : C1
+>Object : Object
+
+class C2 extends Function { }
+>C2 : C2
+>Function : Function
+
+class C3 extends String { }
+>C3 : C3
+>String : String
+
+class C4 extends Boolean { }
+>C4 : C4
+>Boolean : Boolean
+
+class C5 extends Number { }
+>C5 : C5
+>Number : Number
+
+class C6 extends Date { }
+>C6 : C6
+>Date : Date
+
+class C7 extends RegExp { }
+>C7 : C7
+>RegExp : RegExp
+
+class C8 extends Error { }
+>C8 : C8
+>Error : Error
+
+class C9 extends Array { }
+>C9 : C9
+>Array : any[]
+
+class C10 extends Array<number> { }
+>C10 : C10
+>Array : number[]
+

tests/baselines/reference/classExtendingClassLikeType.errors.txt

@@ -0,0 +1,70 @@
+tests/cases/conformance/classes/classDeclarations/classExtendingClassLikeType.ts(7,18): error TS2304: Cannot find name 'Base'.
+tests/cases/conformance/classes/classDeclarations/classExtendingClassLikeType.ts(45,18): error TS2508: No base constructor has the specified number of type arguments.
+tests/cases/conformance/classes/classDeclarations/classExtendingClassLikeType.ts(56,18): error TS2510: Base constructors must all have the same return type.
+
+
+==== tests/cases/conformance/classes/classDeclarations/classExtendingClassLikeType.ts (3 errors) ====
+    interface Base<T, U> {
+        x: T;
+        y: U;
+    }
+    
+    // Error, no Base constructor function
+    class D0 extends Base<string, string> {
+                     ~~~~
+!!! error TS2304: Cannot find name 'Base'.
+    }
+    
+    interface BaseConstructor {
+        new (x: string, y: string): Base<string, string>;
+        new <T>(x: T): Base<T, T>;
+        new <T>(x: T, y: T): Base<T, T>;
+        new <T, U>(x: T, y: U): Base<T, U>;
+    }
+    
+    declare function getBase(): BaseConstructor;
+    
+    class D1 extends getBase() {
+        constructor() {
+            super("abc", "def");
+            this.x = "x";
+            this.y = "y";
+        }
+    }
+    
+    class D2 extends getBase() <number> {
+        constructor() {
+            super(10);
+            super(10, 20);
+            this.x = 1;
+            this.y = 2;
+        }
+    }
+    
+    class D3 extends getBase() <string, number> {
+        constructor() {
+            super("abc", 42);
+            this.x = "x";
+            this.y = 2;
+        }
+    }
+    
+    // Error, no constructors with three type arguments
+    class D4 extends getBase() <string, string, string> {
+                     ~~~~~~~~~
+!!! error TS2508: No base constructor has the specified number of type arguments.
+    }
+    
+    interface BadBaseConstructor {
+        new (x: string): Base<string, string>;
+        new (x: number): Base<number, number>;
+    }
+    
+    declare function getBadBase(): BadBaseConstructor;
+    
+    // Error, constructor return types differ
+    class D5 extends getBadBase() {
+                     ~~~~~~~~~~~~
+!!! error TS2510: Base constructors must all have the same return type.
+    }
+    

tests/baselines/reference/classExtendingClassLikeType.js

@@ -0,0 +1,118 @@
+//// [classExtendingClassLikeType.ts]
+interface Base<T, U> {
+    x: T;
+    y: U;
+}
+
+// Error, no Base constructor function
+class D0 extends Base<string, string> {
+}
+
+interface BaseConstructor {
+    new (x: string, y: string): Base<string, string>;
+    new <T>(x: T): Base<T, T>;
+    new <T>(x: T, y: T): Base<T, T>;
+    new <T, U>(x: T, y: U): Base<T, U>;
+}
+
+declare function getBase(): BaseConstructor;
+
+class D1 extends getBase() {
+    constructor() {
+        super("abc", "def");
+        this.x = "x";
+        this.y = "y";
+    }
+}
+
+class D2 extends getBase() <number> {
+    constructor() {
+        super(10);
+        super(10, 20);
+        this.x = 1;
+        this.y = 2;
+    }
+}
+
+class D3 extends getBase() <string, number> {
+    constructor() {
+        super("abc", 42);
+        this.x = "x";
+        this.y = 2;
+    }
+}
+
+// Error, no constructors with three type arguments
+class D4 extends getBase() <string, string, string> {
+}
+
+interface BadBaseConstructor {
+    new (x: string): Base<string, string>;
+    new (x: number): Base<number, number>;
+}
+
+declare function getBadBase(): BadBaseConstructor;
+
+// Error, constructor return types differ
+class D5 extends getBadBase() {
+}
+
+
+//// [classExtendingClassLikeType.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+// Error, no Base constructor function
+var D0 = (function (_super) {
+    __extends(D0, _super);
+    function D0() {
+        _super.apply(this, arguments);
+    }
+    return D0;
+})(Base);
+var D1 = (function (_super) {
+    __extends(D1, _super);
+    function D1() {
+        _super.call(this, "abc", "def");
+        this.x = "x";
+        this.y = "y";
+    }
+    return D1;
+})(getBase());
+var D2 = (function (_super) {
+    __extends(D2, _super);
+    function D2() {
+        _super.call(this, 10);
+        _super.call(this, 10, 20);
+        this.x = 1;
+        this.y = 2;
+    }
+    return D2;
+})(getBase());
+var D3 = (function (_super) {
+    __extends(D3, _super);
+    function D3() {
+        _super.call(this, "abc", 42);
+        this.x = "x";
+        this.y = 2;
+    }
+    return D3;
+})(getBase());
+// Error, no constructors with three type arguments
+var D4 = (function (_super) {
+    __extends(D4, _super);
+    function D4() {
+        _super.apply(this, arguments);
+    }
+    return D4;
+})(getBase());
+// Error, constructor return types differ
+var D5 = (function (_super) {
+    __extends(D5, _super);
+    function D5() {
+        _super.apply(this, arguments);
+    }
+    return D5;
+})(getBadBase());

tests/baselines/reference/classExtendingNonConstructor.errors.txt

@@ -0,0 +1,38 @@
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(7,18): error TS2507: Type 'undefined' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(8,18): error TS2507: Type 'boolean' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(9,18): error TS2507: Type 'boolean' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(10,18): error TS2507: Type 'number' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(11,18): error TS2507: Type 'string' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(12,18): error TS2507: Type '{}' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts(13,18): error TS2507: Type '() => void' is not a constructor function type.
+
+
+==== tests/cases/conformance/classes/classDeclarations/classExtendingNonConstructor.ts (7 errors) ====
+    var x: {};
+    
+    function foo() {
+        this.x = 1;
+    }
+    
+    class C1 extends undefined { }
+                     ~~~~~~~~~
+!!! error TS2507: Type 'undefined' is not a constructor function type.
+    class C2 extends true { }
+                     ~~~~
+!!! error TS2507: Type 'boolean' is not a constructor function type.
+    class C3 extends false { }
+                     ~~~~~
+!!! error TS2507: Type 'boolean' is not a constructor function type.
+    class C4 extends 42 { }
+                     ~~
+!!! error TS2507: Type 'number' is not a constructor function type.
+    class C5 extends "hello" { }
+                     ~~~~~~~
+!!! error TS2507: Type 'string' is not a constructor function type.
+    class C6 extends x { }
+                     ~
+!!! error TS2507: Type '{}' is not a constructor function type.
+    class C7 extends foo { }
+                     ~~~
+!!! error TS2507: Type '() => void' is not a constructor function type.
+    

tests/baselines/reference/classExtendingNonConstructor.js

@@ -0,0 +1,75 @@
+//// [classExtendingNonConstructor.ts]
+var x: {};
+
+function foo() {
+    this.x = 1;
+}
+
+class C1 extends undefined { }
+class C2 extends true { }
+class C3 extends false { }
+class C4 extends 42 { }
+class C5 extends "hello" { }
+class C6 extends x { }
+class C7 extends foo { }
+
+
+//// [classExtendingNonConstructor.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var x;
+function foo() {
+    this.x = 1;
+}
+var C1 = (function (_super) {
+    __extends(C1, _super);
+    function C1() {
+        _super.apply(this, arguments);
+    }
+    return C1;
+})(undefined);
+var C2 = (function (_super) {
+    __extends(C2, _super);
+    function C2() {
+        _super.apply(this, arguments);
+    }
+    return C2;
+})(true);
+var C3 = (function (_super) {
+    __extends(C3, _super);
+    function C3() {
+        _super.apply(this, arguments);
+    }
+    return C3;
+})(false);
+var C4 = (function (_super) {
+    __extends(C4, _super);
+    function C4() {
+        _super.apply(this, arguments);
+    }
+    return C4;
+})(42);
+var C5 = (function (_super) {
+    __extends(C5, _super);
+    function C5() {
+        _super.apply(this, arguments);
+    }
+    return C5;
+})("hello");
+var C6 = (function (_super) {
+    __extends(C6, _super);
+    function C6() {
+        _super.apply(this, arguments);
+    }
+    return C6;
+})(x);
+var C7 = (function (_super) {
+    __extends(C7, _super);
+    function C7() {
+        _super.apply(this, arguments);
+    }
+    return C7;
+})(foo);

tests/baselines/reference/classExtendingNull.js

@@ -0,0 +1,25 @@
+//// [classExtendingNull.ts]
+class C1 extends null { }
+class C2 extends (null) { }
+
+
+//// [classExtendingNull.js]
+var __extends = (this && this.__extends) || function (d, b) {
+    for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+};
+var C1 = (function (_super) {
+    __extends(C1, _super);
+    function C1() {
+        _super.apply(this, arguments);
+    }
+    return C1;
+})(null);
+var C2 = (function (_super) {
+    __extends(C2, _super);
+    function C2() {
+        _super.apply(this, arguments);
+    }
+    return C2;
+})((null));

tests/baselines/reference/classExtendingNull.symbols

@@ -0,0 +1,7 @@
+=== tests/cases/conformance/classes/classDeclarations/classExtendingNull.ts ===
+class C1 extends null { }
+>C1 : Symbol(C1, Decl(classExtendingNull.ts, 0, 0))
+
+class C2 extends (null) { }
+>C2 : Symbol(C2, Decl(classExtendingNull.ts, 0, 25))
+

tests/baselines/reference/classExtendingNull.types

@@ -0,0 +1,10 @@
+=== tests/cases/conformance/classes/classDeclarations/classExtendingNull.ts ===
+class C1 extends null { }
+>C1 : C1
+>null : null
+
+class C2 extends (null) { }
+>C2 : C2
+>(null) : null
+>null : null
+

tests/baselines/reference/classExtendingPrimitive.errors.txt

@@ -4,13 +4,12 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(6,18): error TS2304: Cannot find name 'Void'.
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(7,19): error TS1109: Expression expected.
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(8,18): error TS2304: Cannot find name 'Null'.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(9,19): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(10,18): error TS2304: Cannot find name 'undefined'.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(10,18): error TS2507: Type 'undefined' is not a constructor function type.
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(11,18): error TS2304: Cannot find name 'Undefined'.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(14,18): error TS2311: A class may only extend another class.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts(14,18): error TS2507: Type 'typeof E' is not a constructor function type.
 
 
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts (10 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive.ts (9 errors) ====
     // classes cannot extend primitives
     
     class C extends number { }
@@ -32,11 +31,9 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
                      ~~~~
 !!! error TS2304: Cannot find name 'Null'.
     class C5a extends null { }
-                      ~~~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
     class C6 extends undefined { }
                      ~~~~~~~~~
-!!! error TS2304: Cannot find name 'undefined'.
+!!! error TS2507: Type 'undefined' is not a constructor function type.
     class C7 extends Undefined { }
                      ~~~~~~~~~
 !!! error TS2304: Cannot find name 'Undefined'.
@@ -44,4 +41,4 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
     enum E { A }
     class C8 extends E { }
                      ~
-!!! error TS2311: A class may only extend another class.
+!!! error TS2507: Type 'typeof E' is not a constructor function type.

tests/baselines/reference/classExtendingPrimitive2.errors.txt

@@ -1,13 +1,10 @@
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(3,19): error TS1109: Expression expected.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts(4,19): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
 
 
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts (2 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendingPrimitive2.ts (1 errors) ====
     // classes cannot extend primitives
     
     class C4a extends void {}
                       ~~~~
 !!! error TS1109: Expression expected.
-    class C5a extends null { }
-                      ~~~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+    class C5a extends null { }

tests/baselines/reference/classExtendingQualifiedName.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/classExtendingQualifiedName.ts(5,23): error TS2305: Module 'M' has no exported member 'C'.
+tests/cases/compiler/classExtendingQualifiedName.ts(5,23): error TS2339: Property 'C' does not exist on type 'typeof M'.
 
 
 ==== tests/cases/compiler/classExtendingQualifiedName.ts (1 errors) ====
@@ -8,6 +8,6 @@ tests/cases/compiler/classExtendingQualifiedName.ts(5,23): error TS2305: Module
     
         class D extends M.C {
                           ~
-!!! error TS2305: Module 'M' has no exported member 'C'.
+!!! error TS2339: Property 'C' does not exist on type 'typeof M'.
         }
     }

tests/baselines/reference/classExtendingQualifiedName2.types

@@ -8,8 +8,8 @@ module M {
 
     class D extends M.C {
 >D : D
->M.C : any
+>M.C : C
 >M : typeof M
->C : C
+>C : typeof C
     }
 }

tests/baselines/reference/classExtendsClauseClassMergedWithModuleNotReferingConstructor.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/classExtendsClauseClassMergedWithModuleNotReferingConstructor.ts(10,21): error TS2419: Type name 'A' in extends clause does not reference constructor function for 'A'.
+tests/cases/compiler/classExtendsClauseClassMergedWithModuleNotReferingConstructor.ts(10,21): error TS2507: Type 'number' is not a constructor function type.
 
 
 ==== tests/cases/compiler/classExtendsClauseClassMergedWithModuleNotReferingConstructor.ts (1 errors) ====
@@ -13,7 +13,7 @@ tests/cases/compiler/classExtendsClauseClassMergedWithModuleNotReferingConstruct
         var A = 1;
         class B extends A {
                         ~
-!!! error TS2419: Type name 'A' in extends clause does not reference constructor function for 'A'.
+!!! error TS2507: Type 'number' is not a constructor function type.
             b: string;
         }
     }

tests/baselines/reference/classExtendsClauseClassNotReferringConstructor.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/classExtendsClauseClassNotReferringConstructor.ts(4,21): error TS2419: Type name 'A' in extends clause does not reference constructor function for 'A'.
+tests/cases/compiler/classExtendsClauseClassNotReferringConstructor.ts(4,21): error TS2507: Type 'number' is not a constructor function type.
 
 
 ==== tests/cases/compiler/classExtendsClauseClassNotReferringConstructor.ts (1 errors) ====
@@ -7,6 +7,6 @@ tests/cases/compiler/classExtendsClauseClassNotReferringConstructor.ts(4,21): er
         var A = 1;
         class B extends A { b: string; }
                         ~
-!!! error TS2419: Type name 'A' in extends clause does not reference constructor function for 'A'.
+!!! error TS2507: Type 'number' is not a constructor function type.
     }
     

tests/baselines/reference/classExtendsEveryObjectType.errors.txt

@@ -1,40 +1,43 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(4,17): error TS2311: A class may only extend another class.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(6,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(4,17): error TS2304: Cannot find name 'I'.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(6,18): error TS2507: Type '{ foo: any; }' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(6,25): error TS2304: Cannot find name 'string'.
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(6,31): error TS1005: ',' expected.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(8,18): error TS2304: Cannot find name 'x'.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(11,18): error TS2304: Cannot find name 'M'.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(14,18): error TS2304: Cannot find name 'foo'.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(16,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(8,18): error TS2507: Type '{ foo: string; }' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(11,18): error TS2507: Type 'typeof M' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(14,18): error TS2507: Type '() => void' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts(16,18): error TS2507: Type 'undefined[]' is not a constructor function type.
 
 
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts (7 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType.ts (8 errors) ====
     interface I {
         foo: string;
     }
     class C extends I { } // error
                     ~
-!!! error TS2311: A class may only extend another class.
+!!! error TS2304: Cannot find name 'I'.
     
     class C2 extends { foo: string; } { } // error
                      ~~~~~~~~~~~~~~~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+!!! error TS2507: Type '{ foo: any; }' is not a constructor function type.
+                            ~~~~~~
+!!! error TS2304: Cannot find name 'string'.
                                   ~
 !!! error TS1005: ',' expected.
     var x: { foo: string; }
     class C3 extends x { } // error
                      ~
-!!! error TS2304: Cannot find name 'x'.
+!!! error TS2507: Type '{ foo: string; }' is not a constructor function type.
     
     module M { export var x = 1; }
     class C4 extends M { } // error
                      ~
-!!! error TS2304: Cannot find name 'M'.
+!!! error TS2507: Type 'typeof M' is not a constructor function type.
     
     function foo() { }
     class C5 extends foo { } // error
                      ~~~
-!!! error TS2304: Cannot find name 'foo'.
+!!! error TS2507: Type '() => void' is not a constructor function type.
     
     class C6 extends []{ } // error
                      ~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+!!! error TS2507: Type 'undefined[]' is not a constructor function type.

tests/baselines/reference/classExtendsEveryObjectType2.errors.txt

@@ -1,15 +1,18 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(1,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(1,18): error TS2507: Type '{ foo: any; }' is not a constructor function type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(1,25): error TS2304: Cannot find name 'string'.
 tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(1,31): error TS1005: ',' expected.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(3,18): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts(3,18): error TS2507: Type 'undefined[]' is not a constructor function type.
 
 
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts (3 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsEveryObjectType2.ts (4 errors) ====
     class C2 extends { foo: string; } { } // error
                      ~~~~~~~~~~~~~~~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+!!! error TS2507: Type '{ foo: any; }' is not a constructor function type.
+                            ~~~~~~
+!!! error TS2304: Cannot find name 'string'.
                                   ~
 !!! error TS1005: ',' expected.
     
     class C6 extends []{ } // error
                      ~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+!!! error TS2507: Type 'undefined[]' is not a constructor function type.

tests/baselines/reference/classExtendsInterface.errors.txt

@@ -1,17 +1,17 @@
-tests/cases/compiler/classExtendsInterface.ts(2,17): error TS2311: A class may only extend another class.
-tests/cases/compiler/classExtendsInterface.ts(6,21): error TS2311: A class may only extend another class.
+tests/cases/compiler/classExtendsInterface.ts(2,17): error TS2304: Cannot find name 'Comparable'.
+tests/cases/compiler/classExtendsInterface.ts(6,21): error TS2304: Cannot find name 'Comparable2'.
 
 
 ==== tests/cases/compiler/classExtendsInterface.ts (2 errors) ====
     interface Comparable {}
     class A extends Comparable {}
                     ~~~~~~~~~~
-!!! error TS2311: A class may only extend another class.
+!!! error TS2304: Cannot find name 'Comparable'.
     class B implements Comparable {}
      
     interface Comparable2<T> {}
     class A2<T> extends Comparable2<T> {}
-                        ~~~~~~~~~~~~~~
-!!! error TS2311: A class may only extend another class.
+                        ~~~~~~~~~~~
+!!! error TS2304: Cannot find name 'Comparable2'.
     class B2<T> implements Comparable2<T> {}
     

tests/baselines/reference/classExtendsItself.errors.txt

@@ -1,17 +1,17 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts(1,7): error TS2310: Type 'C' recursively references itself as a base type.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts(3,7): error TS2310: Type 'D<T>' recursively references itself as a base type.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts(5,7): error TS2310: Type 'E<T>' recursively references itself as a base type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts(1,7): error TS2506: 'C' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts(3,7): error TS2506: 'D' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts(5,7): error TS2506: 'E' is referenced directly or indirectly in its own base expression.
 
 
 ==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItself.ts (3 errors) ====
     class C extends C { } // error
           ~
-!!! error TS2310: Type 'C' recursively references itself as a base type.
+!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression.
     
     class D<T> extends D<T> { } // error
           ~
-!!! error TS2310: Type 'D<T>' recursively references itself as a base type.
+!!! error TS2506: 'D' is referenced directly or indirectly in its own base expression.
     
     class E<T> extends E<string> { } // error
           ~
-!!! error TS2310: Type 'E<T>' recursively references itself as a base type.
+!!! error TS2506: 'E' is referenced directly or indirectly in its own base expression.

tests/baselines/reference/classExtendsItselfIndirectly.errors.txt

@@ -1,20 +1,32 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(1,7): error TS2310: Type 'C' recursively references itself as a base type.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(7,7): error TS2310: Type 'C2<T>' recursively references itself as a base type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(1,7): error TS2506: 'C' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(3,7): error TS2506: 'D' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(5,7): error TS2506: 'E' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(7,7): error TS2506: 'C2' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(9,7): error TS2506: 'D2' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts(11,7): error TS2506: 'E2' is referenced directly or indirectly in its own base expression.
 
 
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts (2 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly.ts (6 errors) ====
     class C extends E { foo: string; } // error
           ~
-!!! error TS2310: Type 'C' recursively references itself as a base type.
+!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression.
     
     class D extends C { bar: string; }
+          ~
+!!! error TS2506: 'D' is referenced directly or indirectly in its own base expression.
     
     class E extends D { baz: number; }
+          ~
+!!! error TS2506: 'E' is referenced directly or indirectly in its own base expression.
     
     class C2<T> extends E2<T> { foo: T; } // error
           ~~
-!!! error TS2310: Type 'C2<T>' recursively references itself as a base type.
+!!! error TS2506: 'C2' is referenced directly or indirectly in its own base expression.
     
     class D2<T> extends C2<T> { bar: T; }
+          ~~
+!!! error TS2506: 'D2' is referenced directly or indirectly in its own base expression.
     
-    class E2<T> extends D2<T> { baz: T; }
+    class E2<T> extends D2<T> { baz: T; }
+          ~~
+!!! error TS2506: 'E2' is referenced directly or indirectly in its own base expression.

tests/baselines/reference/classExtendsItselfIndirectly2.errors.txt

@@ -1,31 +1,43 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(1,7): error TS2310: Type 'C' recursively references itself as a base type.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(13,11): error TS2310: Type 'C2<T>' recursively references itself as a base type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(1,7): error TS2506: 'C' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(4,18): error TS2506: 'D' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(9,18): error TS2506: 'E' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(13,11): error TS2506: 'C2' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(16,22): error TS2506: 'D2' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts(20,22): error TS2506: 'E2' is referenced directly or indirectly in its own base expression.
 
 
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts (2 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly2.ts (6 errors) ====
     class C extends N.E { foo: string; } // error
           ~
-!!! error TS2310: Type 'C' recursively references itself as a base type.
+!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression.
     
     module M {
         export class D extends C { bar: string; }
+                     ~
+!!! error TS2506: 'D' is referenced directly or indirectly in its own base expression.
     
     }
     
     module N {
         export class E extends M.D { baz: number; }
+                     ~
+!!! error TS2506: 'E' is referenced directly or indirectly in its own base expression.
     }
     
     module O {
         class C2<T> extends Q.E2<T> { foo: T; } // error
               ~~
-!!! error TS2310: Type 'C2<T>' recursively references itself as a base type.
+!!! error TS2506: 'C2' is referenced directly or indirectly in its own base expression.
     
         module P {
             export class D2<T> extends C2<T> { bar: T; }
+                         ~~
+!!! error TS2506: 'D2' is referenced directly or indirectly in its own base expression.
         }
     
         module Q {
             export class E2<T> extends P.D2<T> { baz: T; }
+                         ~~
+!!! error TS2506: 'E2' is referenced directly or indirectly in its own base expression.
         }
     }

tests/baselines/reference/classExtendsItselfIndirectly3.errors.txt

@@ -1,25 +1,37 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file1.ts(1,7): error TS2310: Type 'C' recursively references itself as a base type.
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file4.ts(1,7): error TS2310: Type 'C2<T>' recursively references itself as a base type.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file1.ts(1,7): error TS2506: 'C' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file2.ts(1,7): error TS2506: 'D' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file3.ts(1,7): error TS2506: 'E' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file4.ts(1,7): error TS2506: 'C2' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file5.ts(1,7): error TS2506: 'D2' is referenced directly or indirectly in its own base expression.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file6.ts(1,7): error TS2506: 'E2' is referenced directly or indirectly in its own base expression.
 
 
 ==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file1.ts (1 errors) ====
     class C extends E { foo: string; } // error
           ~
-!!! error TS2310: Type 'C' recursively references itself as a base type.
+!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression.
     
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file2.ts (0 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file2.ts (1 errors) ====
     class D extends C { bar: string; }
+          ~
+!!! error TS2506: 'D' is referenced directly or indirectly in its own base expression.
     
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file3.ts (0 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file3.ts (1 errors) ====
     class E extends D { baz: number; }
+          ~
+!!! error TS2506: 'E' is referenced directly or indirectly in its own base expression.
     
 ==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file4.ts (1 errors) ====
     class C2<T> extends E2<T> { foo: T; } // error
           ~~
-!!! error TS2310: Type 'C2<T>' recursively references itself as a base type.
+!!! error TS2506: 'C2' is referenced directly or indirectly in its own base expression.
     
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file5.ts (0 errors) ====
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file5.ts (1 errors) ====
     class D2<T> extends C2<T> { bar: T; }
+          ~~
+!!! error TS2506: 'D2' is referenced directly or indirectly in its own base expression.
     
-==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file6.ts (0 errors) ====
-    class E2<T> extends D2<T> { baz: T; }
+==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsItselfIndirectly_file6.ts (1 errors) ====
+    class E2<T> extends D2<T> { baz: T; }
+          ~~
+!!! error TS2506: 'E2' is referenced directly or indirectly in its own base expression.

tests/baselines/reference/classExtendsShadowedConstructorFunction.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsShadowedConstructorFunction.ts(5,21): error TS2419: Type name 'C' in extends clause does not reference constructor function for 'C'.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsShadowedConstructorFunction.ts(5,21): error TS2507: Type 'number' is not a constructor function type.
 
 
 ==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsShadowedConstructorFunction.ts (1 errors) ====
@@ -8,7 +8,7 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
         var C = 1;
         class D extends C { // error, C must evaluate to constructor function
                         ~
-!!! error TS2419: Type name 'C' in extends clause does not reference constructor function for 'C'.
+!!! error TS2507: Type 'number' is not a constructor function type.
             bar: string;
         }
     }

tests/baselines/reference/classExtendsValidConstructorFunction.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsValidConstructorFunction.ts(5,17): error TS2304: Cannot find name 'foo'.
+tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsValidConstructorFunction.ts(5,17): error TS2507: Type '() => void' is not a constructor function type.
 
 
 ==== tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/classExtendsValidConstructorFunction.ts (1 errors) ====
@@ -8,4 +8,4 @@ tests/cases/conformance/classes/classDeclarations/classHeritageSpecification/cla
     
     class C extends foo { } // error, cannot extend it though
                     ~~~
-!!! error TS2304: Cannot find name 'foo'.
+!!! error TS2507: Type '() => void' is not a constructor function type.

tests/baselines/reference/classInheritence.errors.txt

@@ -1,8 +1,8 @@
-tests/cases/compiler/classInheritence.ts(2,7): error TS2310: Type 'A' recursively references itself as a base type.
+tests/cases/compiler/classInheritence.ts(2,7): error TS2506: 'A' is referenced directly or indirectly in its own base expression.
 
 
 ==== tests/cases/compiler/classInheritence.ts (1 errors) ====
     class B extends A { }
     class A extends A { }
           ~
-!!! error TS2310: Type 'A' recursively references itself as a base type.
+!!! error TS2506: 'A' is referenced directly or indirectly in its own base expression.

tests/baselines/reference/classUpdateTests.errors.txt

@@ -1,7 +1,5 @@
 tests/cases/compiler/classUpdateTests.ts(34,2): error TS2377: Constructors for derived classes must contain a 'super' call.
 tests/cases/compiler/classUpdateTests.ts(43,18): error TS2335: 'super' can only be referenced in a derived class.
-tests/cases/compiler/classUpdateTests.ts(46,17): error TS2311: A class may only extend another class.
-tests/cases/compiler/classUpdateTests.ts(47,18): error TS2335: 'super' can only be referenced in a derived class.
 tests/cases/compiler/classUpdateTests.ts(57,2): error TS2376: A 'super' call must be the first statement in the constructor when a class contains initialized properties or has parameter properties.
 tests/cases/compiler/classUpdateTests.ts(63,7): error TS2415: Class 'L' incorrectly extends base class 'G'.
   Property 'p1' is private in type 'L' but not in type 'G'.
@@ -20,7 +18,7 @@ tests/cases/compiler/classUpdateTests.ts(111,15): error TS1005: ';' expected.
 tests/cases/compiler/classUpdateTests.ts(113,1): error TS1128: Declaration or statement expected.
 
 
-==== tests/cases/compiler/classUpdateTests.ts (18 errors) ====
+==== tests/cases/compiler/classUpdateTests.ts (16 errors) ====
     //
     // test codegen for instance properties
     //
@@ -71,11 +69,7 @@ tests/cases/compiler/classUpdateTests.ts(113,1): error TS1128: Declaration or st
     }
     
     class I extends Object {
-                    ~~~~~~
-!!! error TS2311: A class may only extend another class.
     	constructor() { super(); } // ERROR - no super call allowed
-    	                ~~~~~
-!!! error TS2335: 'super' can only be referenced in a derived class.
     }
     
     class J extends G {

tests/baselines/reference/commentOnAmbientModule.types

@@ -5,9 +5,9 @@ declare module E {
 
     class foobar extends D.bar {
 >foobar : foobar
->D.bar : any
+>D.bar : D.bar
 >D : typeof D
->bar : D.bar
+>bar : typeof D.bar
 
         foo();
 >foo : () => any

tests/baselines/reference/complicatedGenericRecursiveBaseClassReference.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/compiler/complicatedGenericRecursiveBaseClassReference.ts(1,7): error TS2310: Type 'S18<B, A, C>' recursively references itself as a base type.
+tests/cases/compiler/complicatedGenericRecursiveBaseClassReference.ts(1,7): error TS2506: 'S18' is referenced directly or indirectly in its own base expression.
 tests/cases/compiler/complicatedGenericRecursiveBaseClassReference.ts(4,2): error TS2346: Supplied parameters do not match any signature of call target.
 
 
 ==== tests/cases/compiler/complicatedGenericRecursiveBaseClassReference.ts (2 errors) ====
     class S18<B, A, C> extends S18<A[], { S19: A; (): A }[], C[]>
           ~~~
-!!! error TS2310: Type 'S18<B, A, C>' recursively references itself as a base type.
+!!! error TS2506: 'S18' is referenced directly or indirectly in its own base expression.
     {
     }
     (new S18(123)).S18 = 0;

tests/baselines/reference/constraintCheckInGenericBaseTypeReference.types

@@ -16,7 +16,7 @@ class GenericBase<T extends Constraint> {
 }
 class Derived extends GenericBase<TypeArg> {
 >Derived : Derived
->GenericBase : GenericBase<T>
+>GenericBase : GenericBase<TypeArg>
 >TypeArg : TypeArg
 
 }

tests/baselines/reference/constraints0.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/constraints0.ts(14,9): error TS2344: Type 'B' does not satisfy the constraint 'A'.
+tests/cases/compiler/constraints0.ts(14,11): error TS2344: Type 'B' does not satisfy the constraint 'A'.
   Property 'a' is missing in type 'B'.
 
 
@@ -17,7 +17,7 @@ tests/cases/compiler/constraints0.ts(14,9): error TS2344: Type 'B' does not sati
     
     var v1: C<A>; // should work
     var v2: C<B>; // should not work
-            ~~~~
+              ~
 !!! error TS2344: Type 'B' does not satisfy the constraint 'A'.
 !!! error TS2344:   Property 'a' is missing in type 'B'.
     

tests/baselines/reference/declFileForFunctionTypeAsTypeParameter.types

@@ -6,7 +6,7 @@ class X<T> {
 }
 class C extends X<() => number> {
 >C : C
->X : X<T>
+>X : X<() => number>
 }
 interface I extends X<() => number> {
 >I : I

tests/baselines/reference/declFileGenericType.types

@@ -153,9 +153,9 @@ export var g = C.F5<C.A<C.B>>();
 
 export class h extends C.A<C.B>{ }
 >h : h
->C.A : any
+>C.A : C.A<C.B>
 >C : typeof C
->A : C.A<T>
+>A : typeof C.A
 >C : any
 >B : C.B
 

tests/baselines/reference/declFileGenericType2.types

@@ -86,11 +86,11 @@ module templa.dom.mvc {
 >templa : any
 >mvc : any
 >IModel : templa.mvc.IModel
->templa.mvc.AbstractController : any
+>templa.mvc.AbstractController : templa.mvc.AbstractController<ModelType>
 >templa.mvc : typeof templa.mvc
 >templa : typeof templa
 >mvc : typeof templa.mvc
->AbstractController : templa.mvc.AbstractController<ModelType>
+>AbstractController : typeof templa.mvc.AbstractController
 >ModelType : ModelType
 >IElementController : IElementController<ModelType>
 >ModelType : ModelType
@@ -116,13 +116,13 @@ module templa.dom.mvc.composite {
 >mvc : any
 >composite : any
 >ICompositeControllerModel : templa.mvc.composite.ICompositeControllerModel
->templa.dom.mvc.AbstractElementController : any
+>templa.dom.mvc.AbstractElementController : AbstractElementController<ModelType>
 >templa.dom.mvc : typeof mvc
 >templa.dom : typeof dom
 >templa : typeof templa
 >dom : typeof dom
 >mvc : typeof mvc
->AbstractElementController : AbstractElementController<ModelType>
+>AbstractElementController : typeof AbstractElementController
 >ModelType : ModelType
 
         public _controllers: templa.mvc.IController<templa.mvc.IModel>[];

tests/baselines/reference/declFileWithClassNameConflictingWithClassReferredByExtendsClause.types

@@ -19,13 +19,13 @@ module X.Y.base {
 
     export class W extends A.B.Base.W {
 >W : W
->A.B.Base.W : any
+>A.B.Base.W : A.B.Base.W
 >A.B.Base : typeof A.B.Base
 >A.B : typeof A.B
 >A : typeof A
 >B : typeof A.B
 >Base : typeof A.B.Base
->W : A.B.Base.W
+>W : typeof A.B.Base.W
 
         name: string;
 >name : string
@@ -41,13 +41,13 @@ module X.Y.base.Z {
     export class W<TValue> extends X.Y.base.W {
 >W : W<TValue>
 >TValue : TValue
->X.Y.base.W : any
+>X.Y.base.W : base.W
 >X.Y.base : typeof base
 >X.Y : typeof Y
 >X : typeof X
 >Y : typeof Y
 >base : typeof base
->W : base.W
+>W : typeof base.W
 
         value: boolean;
 >value : boolean

tests/baselines/reference/declareDottedExtend.types

@@ -14,15 +14,15 @@ import ab = A.B;
 
 class D extends ab.C{ }
 >D : D
->ab.C : any
+>ab.C : ab.C
 >ab : typeof ab
->C : ab.C
+>C : typeof ab.C
 
 class E extends A.B.C{ }
 >E : E
->A.B.C : any
+>A.B.C : ab.C
 >A.B : typeof ab
 >A : typeof A
 >B : typeof ab
->C : ab.C
+>C : typeof ab.C
 

tests/baselines/reference/emitClassDeclarationWithExtensionAndTypeArgumentInES6.types

@@ -9,11 +9,11 @@ class B<T> {
 }
 class C extends B<string> { }
 >C : C
->B : B<T>
+>B : B<string>
 
 class D extends B<number> {
 >D : D
->B : B<T>
+>B : B<number>
 
     constructor(a: any)
 >a : any

tests/baselines/reference/es6ClassTest7.types

@@ -9,8 +9,8 @@ declare module M {
 
 class Bar extends M.Foo {
 >Bar : Bar
->M.Foo : any
+>M.Foo : M.Foo
 >M : typeof M
->Foo : M.Foo
+>Foo : typeof M.Foo
 }
 

tests/baselines/reference/exportAssignmentOfGenericType1.types

@@ -5,7 +5,7 @@ import q = require("exportAssignmentOfGenericType1_0");
 
 class M extends q<string> { }
 >M : M
->q : q<X>
+>q : q<string>
 
 var m: M;
 >m : M

tests/baselines/reference/extBaseClass1.types

@@ -30,9 +30,9 @@ module N {
 
     export class C3 extends M.B {
 >C3 : C3
->M.B : any
+>M.B : M.B
 >M : typeof M
->B : M.B
+>B : typeof M.B
     }
 }
 

tests/baselines/reference/extBaseClass2.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/extBaseClass2.ts(2,31): error TS2305: Module 'M' has no exported member 'B'.
+tests/cases/compiler/extBaseClass2.ts(2,31): error TS2339: Property 'B' does not exist on type 'typeof M'.
 tests/cases/compiler/extBaseClass2.ts(7,29): error TS2304: Cannot find name 'B'.
 
 
@@ -6,7 +6,7 @@ tests/cases/compiler/extBaseClass2.ts(7,29): error TS2304: Cannot find name 'B'.
     module N {
         export class C4 extends M.B {
                                   ~
-!!! error TS2305: Module 'M' has no exported member 'B'.
+!!! error TS2339: Property 'B' does not exist on type 'typeof M'.
         }
     }
     

tests/baselines/reference/extendNonClassSymbol1.errors.txt

@@ -1,9 +0,0 @@
-tests/cases/compiler/extendNonClassSymbol1.ts(3,17): error TS2304: Cannot find name 'x'.
-
-
-==== tests/cases/compiler/extendNonClassSymbol1.ts (1 errors) ====
-    class A { foo() { } }
-    var x = A;
-    class C extends x { } // error, could not find symbol xs
-                    ~
-!!! error TS2304: Cannot find name 'x'.

tests/baselines/reference/extendNonClassSymbol1.symbols

@@ -0,0 +1,12 @@
+=== tests/cases/compiler/extendNonClassSymbol1.ts ===
+class A { foo() { } }
+>A : Symbol(A, Decl(extendNonClassSymbol1.ts, 0, 0))
+>foo : Symbol(foo, Decl(extendNonClassSymbol1.ts, 0, 9))
+
+var x = A;
+>x : Symbol(x, Decl(extendNonClassSymbol1.ts, 1, 3))
+>A : Symbol(A, Decl(extendNonClassSymbol1.ts, 0, 0))
+
+class C extends x { } // error, could not find symbol xs
+>C : Symbol(C, Decl(extendNonClassSymbol1.ts, 1, 10))
+

tests/baselines/reference/extendNonClassSymbol1.types

@@ -0,0 +1,13 @@
+=== tests/cases/compiler/extendNonClassSymbol1.ts ===
+class A { foo() { } }
+>A : A
+>foo : () => void
+
+var x = A;
+>x : typeof A
+>A : typeof A
+
+class C extends x { } // error, could not find symbol xs
+>C : C
+>x : A
+

tests/baselines/reference/extendNonClassSymbol2.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/extendNonClassSymbol2.ts(5,17): error TS2304: Cannot find name 'Foo'.
+tests/cases/compiler/extendNonClassSymbol2.ts(5,17): error TS2507: Type '() => void' is not a constructor function type.
 
 
 ==== tests/cases/compiler/extendNonClassSymbol2.ts (1 errors) ====
@@ -8,4 +8,4 @@ tests/cases/compiler/extendNonClassSymbol2.ts(5,17): error TS2304: Cannot find n
     var x = new Foo(); // legal, considered a constructor function
     class C extends Foo {} // error, could not find symbol Foo
                     ~~~
-!!! error TS2304: Cannot find name 'Foo'.
+!!! error TS2507: Type '() => void' is not a constructor function type.

tests/baselines/reference/extendingClassFromAliasAndUsageInIndexer.types

@@ -61,9 +61,9 @@ import Backbone = require("extendingClassFromAliasAndUsageInIndexer_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // interesting stuff here
 }
@@ -74,9 +74,9 @@ import Backbone = require("extendingClassFromAliasAndUsageInIndexer_backbone");
 
 export class VisualizationModel extends Backbone.Model {
 >VisualizationModel : VisualizationModel
->Backbone.Model : any
+>Backbone.Model : Backbone.Model
 >Backbone : typeof Backbone
->Model : Backbone.Model
+>Model : typeof Backbone.Model
 
     // different interesting stuff here
 }

tests/baselines/reference/generatorTypeCheck40.errors.txt

@@ -1,9 +1,12 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,21): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,21): error TS2507: Type 'any' is not a constructor function type.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts(2,22): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts (1 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck40.ts (2 errors) ====
     function* g() {
         class C extends (yield 0) { }
                         ~~~~~~~~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+!!! error TS2507: Type 'any' is not a constructor function type.
+                         ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
     }

tests/baselines/reference/generatorTypeCheck60.errors.txt

@@ -1,9 +1,12 @@
-tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,21): error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,21): error TS2507: Type 'any' is not a constructor function type.
+tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts(2,22): error TS1163: A 'yield' expression is only allowed in a generator body.
 
 
-==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts (1 errors) ====
+==== tests/cases/conformance/es6/yieldExpressions/generatorTypeCheck60.ts (2 errors) ====
     function* g() {
         class C extends (yield) {};
                         ~~~~~~~
-!!! error TS9002: Only identifiers/qualified-names with optional type arguments are currently supported in a class 'extends' clauses.
+!!! error TS2507: Type 'any' is not a constructor function type.
+                         ~~~~~
+!!! error TS1163: A 'yield' expression is only allowed in a generator body.
     }

tests/baselines/reference/genericBaseClassLiteralProperty.types

@@ -14,7 +14,7 @@ class BaseClass<T> {
 
 class SubClass extends BaseClass<number> {
 >SubClass : SubClass
->BaseClass : BaseClass<T>
+>BaseClass : BaseClass<number>
 
     public Error(): void {
 >Error : () => void

tests/baselines/reference/genericBaseClassLiteralProperty2.types

@@ -24,7 +24,7 @@ class BaseCollection2<TItem extends CollectionItem2> {
 
 class DataView2 extends BaseCollection2<CollectionItem2> {
 >DataView2 : DataView2
->BaseCollection2 : BaseCollection2<TItem>
+>BaseCollection2 : BaseCollection2<CollectionItem2>
 >CollectionItem2 : CollectionItem2
 
     fillItems(item: CollectionItem2) {

tests/baselines/reference/genericCallbacksAndClassHierarchy.types

@@ -31,7 +31,7 @@ module M {
     export class B<T> extends C1<A<T>> { }
 >B : B<T>
 >T : T
->C1 : C1<T>
+>C1 : C1<A<T>>
 >A : A<T>
 >T : T
 

tests/baselines/reference/genericClassInheritsConstructorFromNonGenericClass.types

@@ -1,7 +1,7 @@
 === tests/cases/compiler/genericClassInheritsConstructorFromNonGenericClass.ts ===
 class A extends B<string> { }
 >A : A
->B : B<U>
+>B : B<string>
 
 class B<U> extends C { }
 >B : B<U>

tests/baselines/reference/genericClassPropertyInheritanceSpecialization.types

@@ -192,13 +192,13 @@ module PortalFx.ViewModels.Controls.Validators {
     export class Validator<TValue> extends Portal.Controls.Validators.Validator<TValue> {
 >Validator : Validator<TValue>
 >TValue : TValue
->Portal.Controls.Validators.Validator : any
+>Portal.Controls.Validators.Validator : Portal.Controls.Validators.Validator<TValue>
 >Portal.Controls.Validators : typeof Portal.Controls.Validators
 >Portal.Controls : typeof Portal.Controls
 >Portal : typeof Portal
 >Controls : typeof Portal.Controls
 >Validators : typeof Portal.Controls.Validators
->Validator : Portal.Controls.Validators.Validator<TValue>
+>Validator : typeof Portal.Controls.Validators.Validator
 >TValue : TValue
 
         constructor(message?: string) {

tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes.types

@@ -53,7 +53,7 @@ module EndGate.Tweening {
 
     export class NumberTween extends Tween<number>{
 >NumberTween : NumberTween
->Tween : Tween<T>
+>Tween : Tween<number>
 
         constructor(from: number) {
 >from : number

tests/baselines/reference/genericConstraintOnExtendedBuiltinTypes2.types

@@ -52,7 +52,7 @@ module EndGate.Tweening {
 
     export class NumberTween extends Tween<Number>{
 >NumberTween : NumberTween
->Tween : Tween<T>
+>Tween : Tween<Number>
 >Number : Number
 
         constructor(from: number) {

tests/baselines/reference/genericTypeConstraints.errors.txt

@@ -1,9 +1,8 @@
-tests/cases/compiler/genericTypeConstraints.ts(9,27): error TS2344: Type 'FooExtended' does not satisfy the constraint 'Foo'.
-  Property 'fooMethod' is missing in type 'FooExtended'.
 tests/cases/compiler/genericTypeConstraints.ts(9,31): error TS2344: Type 'FooExtended' does not satisfy the constraint 'Foo'.
+  Property 'fooMethod' is missing in type 'FooExtended'.
 
 
-==== tests/cases/compiler/genericTypeConstraints.ts (2 errors) ====
+==== tests/cases/compiler/genericTypeConstraints.ts (1 errors) ====
     class Foo {
         fooMethod() {}
     }
@@ -13,11 +12,9 @@ tests/cases/compiler/genericTypeConstraints.ts(9,31): error TS2344: Type 'FooExt
     class Bar<T extends Foo> { }
     
     class BarExtended extends Bar<FooExtended> {
-                              ~~~~~~~~~~~~~~~~
-!!! error TS2344: Type 'FooExtended' does not satisfy the constraint 'Foo'.
-!!! error TS2344:   Property 'fooMethod' is missing in type 'FooExtended'.
                                   ~~~~~~~~~~~
 !!! error TS2344: Type 'FooExtended' does not satisfy the constraint 'Foo'.
+!!! error TS2344:   Property 'fooMethod' is missing in type 'FooExtended'.
         constructor() {
             super();
         }

tests/baselines/reference/genericTypeReferenceWithoutTypeArgument.d.errors.txt

@@ -8,7 +8,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(14,23): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(14,27): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(16,25): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
-tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(22,28): error TS2305: Module 'M' has no exported member 'C'.
+tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(22,28): error TS2339: Property 'C' does not exist on type 'typeof M'.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(23,28): error TS2314: Generic type 'E<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(25,30): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument.d.ts(26,30): error TS2314: Generic type 'E<T>' requires 1 type argument(s).
@@ -58,7 +58,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
     
     declare class D2 extends M.C { }
                                ~
-!!! error TS2305: Module 'M' has no exported member 'C'.
+!!! error TS2339: Property 'C' does not exist on type 'typeof M'.
     declare class D3<T extends M.E> { }
                                ~~~
 !!! error TS2314: Generic type 'E<T>' requires 1 type argument(s).

tests/baselines/reference/genericTypeReferenceWithoutTypeArgument2.errors.txt

@@ -13,9 +13,9 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(18,23): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(18,27): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(18,38): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
-tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(20,17): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
+tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(20,17): error TS2304: Cannot find name 'I'.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(23,21): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
-tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,20): error TS2305: Module 'M' has no exported member 'C'.
+tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(29,18): error TS2304: Cannot find name 'M'.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(30,24): error TS2314: Generic type 'E<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(31,24): error TS2305: Module 'M' has no exported member 'C'.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument2.ts(33,22): error TS2314: Generic type 'I<T>' requires 1 type argument(s).
@@ -76,7 +76,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
     
     class D extends I {
                     ~
-!!! error TS2314: Generic type 'I<T>' requires 1 type argument(s).
+!!! error TS2304: Cannot find name 'I'.
     }
     
     interface U extends I {}
@@ -88,8 +88,8 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
     }
     
     class D2 extends M.C { }
-                       ~
-!!! error TS2305: Module 'M' has no exported member 'C'.
+                     ~
+!!! error TS2304: Cannot find name 'M'.
     interface D3<T extends M.E> { }
                            ~~~
 !!! error TS2314: Generic type 'E<T>' requires 1 type argument(s).

tests/baselines/reference/genericTypeReferenceWithoutTypeArgument3.errors.txt

@@ -8,7 +8,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(14,23): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(14,27): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(16,25): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
-tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(22,28): error TS2305: Module 'M' has no exported member 'C'.
+tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(22,28): error TS2339: Property 'C' does not exist on type 'typeof M'.
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(23,28): error TS2314: Generic type 'E<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(25,30): error TS2314: Generic type 'C<T>' requires 1 type argument(s).
 tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenceWithoutTypeArgument3.ts(26,30): error TS2314: Generic type 'E<T>' requires 1 type argument(s).
@@ -58,7 +58,7 @@ tests/cases/conformance/types/specifyingTypes/typeReferences/genericTypeReferenc
     
     declare class D2 extends M.C { }
                                ~
-!!! error TS2305: Module 'M' has no exported member 'C'.
+!!! error TS2339: Property 'C' does not exist on type 'typeof M'.
     declare class D3<T extends M.E> { }
                                ~~~
 !!! error TS2314: Generic type 'E<T>' requires 1 type argument(s).

tests/baselines/reference/genericWithIndexerOfTypeParameterType2.types

@@ -12,7 +12,7 @@ export class Collection<TItem extends CollectionItem> {
 
 export class List extends Collection<ListItem>{
 >List : List
->Collection : Collection<TItem>
+>Collection : Collection<ListItem>
 >ListItem : ListItem
 
     Bar() {}

tests/baselines/reference/generics1.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/generics1.ts(10,9): error TS2344: Type 'A' does not satisfy the constraint 'B'.
+tests/cases/compiler/generics1.ts(10,14): error TS2344: Type 'A' does not satisfy the constraint 'B'.
   Property 'b' is missing in type 'A'.
 tests/cases/compiler/generics1.ts(13,9): error TS2314: Generic type 'G<T, U>' requires 2 type argument(s).
 tests/cases/compiler/generics1.ts(14,9): error TS2314: Generic type 'G<T, U>' requires 2 type argument(s).
@@ -15,7 +15,7 @@ tests/cases/compiler/generics1.ts(14,9): error TS2314: Generic type 'G<T, U>' re
     var v1: G<A, C>;               // Ok
     var v2: G<{ a: string }, C>;   // Ok, equivalent to G<A, C>
     var v3: G<A, A>;               // Error, A not valid argument for U
-            ~~~~~~~
+                 ~
 !!! error TS2344: Type 'A' does not satisfy the constraint 'B'.
 !!! error TS2344:   Property 'b' is missing in type 'A'.
     var v4: G<G<A, B>, C>;         // Ok

tests/baselines/reference/generics2.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/generics2.ts(17,9): error TS2344: Type 'A' does not satisfy the constraint 'B'.
+tests/cases/compiler/generics2.ts(17,14): error TS2344: Type 'A' does not satisfy the constraint 'B'.
   Property 'b' is missing in type 'A'.
 tests/cases/compiler/generics2.ts(20,9): error TS2314: Generic type 'G<T, U>' requires 2 type argument(s).
 tests/cases/compiler/generics2.ts(21,9): error TS2314: Generic type 'G<T, U>' requires 2 type argument(s).
@@ -22,7 +22,7 @@ tests/cases/compiler/generics2.ts(21,9): error TS2314: Generic type 'G<T, U>' re
     
     var v2: G<{ a: string }, C>;   // Ok, equivalent to G<A, C>
     var v3: G<A, A>;               // Error, A not valid argument for U
-            ~~~~~~~
+                 ~
 !!! error TS2344: Type 'A' does not satisfy the constraint 'B'.
 !!! error TS2344:   Property 'b' is missing in type 'A'.
     var v4: G<G<A, B>, C>;         // Ok

tests/baselines/reference/generics5.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/generics5.ts(10,9): error TS2344: Type 'A' does not satisfy the constraint 'B'.
+tests/cases/compiler/generics5.ts(10,14): error TS2344: Type 'A' does not satisfy the constraint 'B'.
   Property 'b' is missing in type 'A'.
 
 
@@ -13,7 +13,7 @@ tests/cases/compiler/generics5.ts(10,9): error TS2344: Type 'A' does not satisfy
     }
     
     var v3: G<A, A>;               // Error, A not valid argument for U
-            ~~~~~~~
+                 ~
 !!! error TS2344: Type 'A' does not satisfy the constraint 'B'.
 !!! error TS2344:   Property 'b' is missing in type 'A'.
     

tests/baselines/reference/importAsBaseClass.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/compiler/importAsBaseClass_1.ts(2,21): error TS2304: Cannot find name 'Greeter'.
+tests/cases/compiler/importAsBaseClass_1.ts(2,21): error TS2507: Type 'typeof "tests/cases/compiler/importAsBaseClass_0"' is not a constructor function type.
 
 
 ==== tests/cases/compiler/importAsBaseClass_1.ts (1 errors) ====
     import Greeter = require("importAsBaseClass_0");
     class Hello extends Greeter { }
                         ~~~~~~~
-!!! error TS2304: Cannot find name 'Greeter'.
+!!! error TS2507: Type 'typeof "tests/cases/compiler/importAsBaseClass_0"' is not a constructor function type.
     
 ==== tests/cases/compiler/importAsBaseClass_0.ts (0 errors) ====
     export class Greeter {

tests/baselines/reference/importAsBaseClass.js

@@ -24,6 +24,7 @@ var __extends = (this && this.__extends) || function (d, b) {
     function __() { this.constructor = d; }
     d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
 };
+var Greeter = require("importAsBaseClass_0");
 var Hello = (function (_super) {
     __extends(Hello, _super);
     function Hello() {

tests/baselines/reference/importUsedInExtendsList1.types

@@ -5,9 +5,9 @@ import foo = require('importUsedInExtendsList1_require');
 
 class Sub extends foo.Super { }
 >Sub : Sub
->foo.Super : any
+>foo.Super : foo.Super
 >foo : typeof foo
->Super : foo.Super
+>Super : typeof foo.Super
 
 var s: Sub;
 >s : Sub

tests/baselines/reference/indirectSelfReference.errors.txt

@@ -1,8 +1,11 @@
-tests/cases/compiler/indirectSelfReference.ts(1,7): error TS2310: Type 'a' recursively references itself as a base type.
+tests/cases/compiler/indirectSelfReference.ts(1,7): error TS2506: 'a' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/indirectSelfReference.ts(2,7): error TS2506: 'b' is referenced directly or indirectly in its own base expression.
 
 
-==== tests/cases/compiler/indirectSelfReference.ts (1 errors) ====
+==== tests/cases/compiler/indirectSelfReference.ts (2 errors) ====
     class a extends b{ }
           ~
-!!! error TS2310: Type 'a' recursively references itself as a base type.
-    class b extends a{ }
+!!! error TS2506: 'a' is referenced directly or indirectly in its own base expression.
+    class b extends a{ }
+          ~
+!!! error TS2506: 'b' is referenced directly or indirectly in its own base expression.

tests/baselines/reference/indirectSelfReferenceGeneric.errors.txt

@@ -1,8 +1,11 @@
-tests/cases/compiler/indirectSelfReferenceGeneric.ts(1,7): error TS2310: Type 'a<T>' recursively references itself as a base type.
+tests/cases/compiler/indirectSelfReferenceGeneric.ts(1,7): error TS2506: 'a' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/indirectSelfReferenceGeneric.ts(2,7): error TS2506: 'b' is referenced directly or indirectly in its own base expression.
 
 
-==== tests/cases/compiler/indirectSelfReferenceGeneric.ts (1 errors) ====
+==== tests/cases/compiler/indirectSelfReferenceGeneric.ts (2 errors) ====
     class a<T> extends b<T> { }
           ~
-!!! error TS2310: Type 'a<T>' recursively references itself as a base type.
-    class b<T> extends a<T> { }
+!!! error TS2506: 'a' is referenced directly or indirectly in its own base expression.
+    class b<T> extends a<T> { }
+          ~
+!!! error TS2506: 'b' is referenced directly or indirectly in its own base expression.

tests/baselines/reference/inheritFromGenericTypeParameter.errors.txt

@@ -1,11 +1,11 @@
-tests/cases/compiler/inheritFromGenericTypeParameter.ts(1,20): error TS2311: A class may only extend another class.
+tests/cases/compiler/inheritFromGenericTypeParameter.ts(1,20): error TS2304: Cannot find name 'T'.
 tests/cases/compiler/inheritFromGenericTypeParameter.ts(2,24): error TS2312: An interface may only extend a class or another interface.
 
 
 ==== tests/cases/compiler/inheritFromGenericTypeParameter.ts (2 errors) ====
     class C<T> extends T { }
                        ~
-!!! error TS2311: A class may only extend another class.
+!!! error TS2304: Cannot find name 'T'.
     interface I<T> extends T { }
                            ~
 !!! error TS2312: An interface may only extend a class or another interface.

tests/baselines/reference/inheritanceOfGenericConstructorMethod2.types

@@ -14,16 +14,16 @@ module N {
 
    export class D1 extends M.C1 { }
 >D1 : D1
->M.C1 : any
+>M.C1 : M.C1
 >M : typeof M
->C1 : M.C1
+>C1 : typeof M.C1
 
    export class D2<T> extends M.C2<T> { }
 >D2 : D2<T>
 >T : T
->M.C2 : any
+>M.C2 : M.C2<T>
 >M : typeof M
->C2 : M.C2<T>
+>C2 : typeof M.C2
 >T : T
 }
 

tests/baselines/reference/moduleImportedForTypeArgumentPosition.types

@@ -9,7 +9,7 @@ class C1<T>{ }
 
 class Test1 extends C1<M2.M2C> {
 >Test1 : Test1
->C1 : C1<T>
+>C1 : C1<M2.M2C>
 >M2 : any
 >M2C : M2.M2C
 }

tests/baselines/reference/moduleWithStatementsOfEveryKind.types

@@ -18,7 +18,7 @@ module A {
 
     class B extends AA<string> implements I { id: number }
 >B : B
->AA : AA<T>
+>AA : AA<string>
 >I : I
 >id : number
 
@@ -106,7 +106,7 @@ module Y {
 
     export class B extends AA<string> implements I { id: number }
 >B : B
->AA : AA<T>
+>AA : AA<string>
 >I : I
 >id : number
 

tests/baselines/reference/nonGenericClassExtendingGenericClassWithAny.types

@@ -10,5 +10,5 @@ class Foo<T> {
 
 class Bar extends Foo<any> { } // Valid
 >Bar : Bar
->Foo : Foo<T>
+>Foo : Foo<any>
 

tests/baselines/reference/overloadresolutionWithConstraintCheckingDeferred.errors.txt

@@ -7,7 +7,7 @@ tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts(18,27):
   Types of parameters 'x' and 'x' are incompatible.
     Type 'D' is not assignable to type 'B'.
       Property 'x' is missing in type 'D'.
-tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts(19,12): error TS2344: Type 'D' does not satisfy the constraint 'A'.
+tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts(19,14): error TS2344: Type 'D' does not satisfy the constraint 'A'.
 
 
 ==== tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts (6 errors) ====
@@ -41,7 +41,7 @@ tests/cases/compiler/overloadresolutionWithConstraintCheckingDeferred.ts(19,12):
                               ~~~~~~~~~~~~~~~~~~~~~~
         var y: G<typeof x>; // error that D does not satisfy constraint, y is of type G<D>, entire call to foo is an error
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-               ~~~~~~~~~~~
+                 ~~~~~~~~
 !!! error TS2344: Type 'D' does not satisfy the constraint 'A'.
         return y;
     ~~~~~~~~~~~~~

tests/baselines/reference/qualifiedName_entity-name-resolution-does-not-affect-class-heritage.errors.txt

@@ -1,4 +1,4 @@
-tests/cases/compiler/qualifiedName_entity-name-resolution-does-not-affect-class-heritage.ts(5,26): error TS2305: Module 'Alpha' has no exported member 'x'.
+tests/cases/compiler/qualifiedName_entity-name-resolution-does-not-affect-class-heritage.ts(5,20): error TS2507: Type 'number' is not a constructor function type.
 
 
 ==== tests/cases/compiler/qualifiedName_entity-name-resolution-does-not-affect-class-heritage.ts (1 errors) ====
@@ -7,6 +7,6 @@ tests/cases/compiler/qualifiedName_entity-name-resolution-does-not-affect-class-
     }
     
     class Beta extends Alpha.x {
-                             ~
-!!! error TS2305: Module 'Alpha' has no exported member 'x'.
+                       ~~~~~~~
+!!! error TS2507: Type 'number' is not a constructor function type.
     }

tests/baselines/reference/recursiveBaseCheck.errors.txt

@@ -1,19 +1,31 @@
-tests/cases/compiler/recursiveBaseCheck.ts(2,11): error TS2310: Type 'C' recursively references itself as a base type.
+tests/cases/compiler/recursiveBaseCheck.ts(2,11): error TS2506: 'C' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/recursiveBaseCheck.ts(4,18): error TS2506: 'B' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/recursiveBaseCheck.ts(6,18): error TS2506: 'A' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/recursiveBaseCheck.ts(8,18): error TS2506: 'AmChart' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/recursiveBaseCheck.ts(10,18): error TS2506: 'D' is referenced directly or indirectly in its own base expression.
 
 
-==== tests/cases/compiler/recursiveBaseCheck.ts (1 errors) ====
+==== tests/cases/compiler/recursiveBaseCheck.ts (5 errors) ====
     declare module Module {
         class C extends D {
               ~
-!!! error TS2310: Type 'C' recursively references itself as a base type.
+!!! error TS2506: 'C' is referenced directly or indirectly in its own base expression.
         }
         export class B extends Module.C {
+                     ~
+!!! error TS2506: 'B' is referenced directly or indirectly in its own base expression.
         }
         export class A extends Module.B {
+                     ~
+!!! error TS2506: 'A' is referenced directly or indirectly in its own base expression.
         }
         export class AmChart extends Module.A {
+                     ~~~~~~~
+!!! error TS2506: 'AmChart' is referenced directly or indirectly in its own base expression.
         }
         export class D extends AmChart {
+                     ~
+!!! error TS2506: 'D' is referenced directly or indirectly in its own base expression.
         }
         export class E extends Module.D {
         }

tests/baselines/reference/recursiveBaseCheck2.errors.txt

@@ -1,13 +1,16 @@
-tests/cases/compiler/recursiveBaseCheck2.ts(2,18): error TS2310: Type 'b2CircleShape' recursively references itself as a base type.
+tests/cases/compiler/recursiveBaseCheck2.ts(2,18): error TS2506: 'b2CircleShape' is referenced directly or indirectly in its own base expression.
+tests/cases/compiler/recursiveBaseCheck2.ts(4,18): error TS2506: 'b2Shape' is referenced directly or indirectly in its own base expression.
 
 
-==== tests/cases/compiler/recursiveBaseCheck2.ts (1 errors) ====
+==== tests/cases/compiler/recursiveBaseCheck2.ts (2 errors) ====
     declare module Box2D.Collision.Shapes {
         export class b2CircleShape extends b2Shape {
                      ~~~~~~~~~~~~~
-!!! error TS2310: Type 'b2CircleShape' recursively references itself as a base type.
+!!! error TS2506: 'b2CircleShape' is referenced directly or indirectly in its own base expression.
         }
         export class b2Shape extends Box2D.Collision.Shapes.b2CircleShape {
+                     ~~~~~~~
+!!! error TS2506: 'b2Shape' is referenced directly or indirectly in its own base expression.
         }
     }
     declare module Box2D.Dynamics {