diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index dac3dce3b32..3803f5d81fa 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -22641,16 +22641,6 @@ namespace ts {
             getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
         }
 
-        function writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) {
-            const classType = <InterfaceType>getDeclaredTypeOfSymbol(getSymbolOfNode(node));
-            resolveBaseTypesOfClass(classType);
-            const baseType = classType.resolvedBaseTypes.length ? classType.resolvedBaseTypes[0] : unknownType;
-            if (!baseType.symbol && !(baseType.flags & TypeFlags.Intersection)) {
-                writer.reportIllegalExtends();
-            }
-            getSymbolDisplayBuilder().buildTypeDisplay(baseType, writer, enclosingDeclaration, flags);
-        }
-
         function hasGlobalName(name: string): boolean {
             return globals.has(name);
         }
@@ -22744,7 +22734,6 @@ namespace ts {
                 writeTypeOfDeclaration,
                 writeReturnTypeOfSignatureDeclaration,
                 writeTypeOfExpression,
-                writeBaseConstructorTypeOfClass,
                 isSymbolAccessible,
                 isEntityNameVisible,
                 getConstantValue: node => {
diff --git a/src/compiler/declarationEmitter.ts b/src/compiler/declarationEmitter.ts
index 7251fec169f..d7ad2c3a78d 100644
--- a/src/compiler/declarationEmitter.ts
+++ b/src/compiler/declarationEmitter.ts
@@ -617,7 +617,7 @@ namespace ts {
             if (!noDeclare) {
                 write("declare ");
             }
-            write("var ");
+            write("const ");
             write(tempVarName);
             write(": ");
             writer.getSymbolAccessibilityDiagnostic = () => diagnostic;
@@ -1096,7 +1096,7 @@ namespace ts {
             }
         }
 
-        function emitHeritageClause(className: Identifier, typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
+        function emitHeritageClause(typeReferences: ExpressionWithTypeArguments[], isImplementsList: boolean) {
             if (typeReferences) {
                 write(isImplementsList ? " implements " : " extends ");
                 emitCommaList(typeReferences, emitTypeOfTypeReference);
@@ -1109,16 +1109,6 @@ namespace ts {
                 else if (!isImplementsList && node.expression.kind === SyntaxKind.NullKeyword) {
                     write("null");
                 }
-                else {
-                    writer.getSymbolAccessibilityDiagnostic = getHeritageClauseVisibilityError;
-                    errorNameNode = className;
-                    resolver.writeBaseConstructorTypeOfClass(
-                        enclosingDeclaration as ClassLikeDeclaration,
-                        enclosingDeclaration,
-                        TypeFormatFlags.UseTypeOfFunction | TypeFormatFlags.UseTypeAliasValue,
-                        writer);
-                    errorNameNode = undefined;
-                }
 
                 function getHeritageClauseVisibilityError(): SymbolAccessibilityDiagnostic {
                     let diagnosticMessage: DiagnosticMessage;
@@ -1158,12 +1148,14 @@ namespace ts {
             enclosingDeclaration = node;
             const baseTypeNode = getClassExtendsHeritageClauseElement(node);
             let tempVarName: string;
-            if (isNonNullExpression(baseTypeNode)) {
-                tempVarName = emitTempVariableDeclaration(baseTypeNode.expression, `_${node.name.text}_intersection_base`, {
-                    diagnosticMessage: Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
-                    errorNode: baseTypeNode,
-                    typeName: node.name
-                });
+            if (baseTypeNode && !isEntityNameExpression(baseTypeNode.expression)) {
+                tempVarName = baseTypeNode.expression.kind === SyntaxKind.NullKeyword ?
+                    "null" :
+                    emitTempVariableDeclaration(baseTypeNode.expression, `${node.name.text}_base`, {
+                        diagnosticMessage: Diagnostics.extends_clause_of_exported_class_0_has_or_is_using_private_name_1,
+                        errorNode: baseTypeNode,
+                        typeName: node.name
+                    });
             }
 
             emitJsDocComments(node);
@@ -1175,7 +1167,7 @@ namespace ts {
             writeTextOfNode(currentText, node.name);
             emitTypeParameters(node.typeParameters);
             if (baseTypeNode) {
-                if (isNonNullExpression(baseTypeNode)) {
+                if (!isEntityNameExpression(baseTypeNode.expression)) {
                     write(" extends ");
                     write(tempVarName);
                     if (baseTypeNode.typeArguments) {
@@ -1185,10 +1177,10 @@ namespace ts {
                     }
                 }
                 else  {
-                    emitHeritageClause(node.name, [baseTypeNode], /*isImplementsList*/ false);
+                    emitHeritageClause([baseTypeNode], /*isImplementsList*/ false);
                 }
             }
-            emitHeritageClause(node.name, getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
+            emitHeritageClause(getClassImplementsHeritageClauseElements(node), /*isImplementsList*/ true);
             write(" {");
             writeLine();
             increaseIndent();
@@ -1210,7 +1202,7 @@ namespace ts {
             emitTypeParameters(node.typeParameters);
             const interfaceExtendsTypes = filter(getInterfaceBaseTypeNodes(node), base => isEntityNameExpression(base.expression));
             if (interfaceExtendsTypes && interfaceExtendsTypes.length) {
-                emitHeritageClause(node.name, interfaceExtendsTypes, /*isImplementsList*/ false);
+                emitHeritageClause(interfaceExtendsTypes, /*isImplementsList*/ false);
             }
             write(" {");
             writeLine();
@@ -1222,10 +1214,6 @@ namespace ts {
             enclosingDeclaration = prevEnclosingDeclaration;
         }
 
-        function isNonNullExpression(node: ExpressionWithTypeArguments) {
-            return node && !isEntityNameExpression(node.expression) && node.expression.kind !== SyntaxKind.NullKeyword;
-        }
-
         function emitPropertyDeclaration(node: Declaration) {
             if (hasDynamicName(node)) {
                 return;
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 57cf17f7100..6bcd24292e8 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -2727,7 +2727,6 @@ namespace ts {
         writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
-        writeBaseConstructorTypeOfClass(node: ClassLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
         isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags, shouldComputeAliasToMarkVisible: boolean): SymbolAccessibilityResult;
         isEntityNameVisible(entityName: EntityNameOrEntityNameExpression, enclosingDeclaration: Node): SymbolVisibilityResult;
         // Returns the constant value this property access resolves to, or 'undefined' for a non-constant