Emit as class with private ctor

Author: rbuckton

src/compiler/checker.ts

@@ -5949,24 +5949,6 @@ namespace ts {
                     }
                 }
 
-                function isEffectiveClassSymbol(symbol: Symbol) {
-                    if (!(symbol.flags & SymbolFlags.Class)) {
-                        return false;
-                    }
-                    if (isInJSFile(symbol.valueDeclaration) && !isClassLike(symbol.valueDeclaration)) {
-                        // For a symbol that isn't syntactically a `class` in a JS file we have heuristics
-                        // that detect prototype assignments that indicate the symbol is *probably* a class.
-                        // Filter out any prototype assignments for non-class symbols, i.e.
-                        //
-                        //     let A;
-                        //     A = {};
-                        //     A.prototype.b = {};
-                        const type = getTypeOfSymbol(symbol);
-                        return some(getSignaturesOfType(type, SignatureKind.Construct))
-                            || some(getSignaturesOfType(type, SignatureKind.Call));
-                    }
-                    return true;
-                }
 
                 // Synthesize declarations for a symbol - might be an Interface, a Class, a Namespace, a Type, a Variable (const, let, or var), an Alias
                 // or a merge of some number of those.
@@ -6009,14 +5991,14 @@ namespace ts {
                     if (symbol.flags & (SymbolFlags.BlockScopedVariable | SymbolFlags.FunctionScopedVariable | SymbolFlags.Property)
                         && symbol.escapedName !== InternalSymbolName.ExportEquals
                         && !(symbol.flags & SymbolFlags.Prototype)
-                        && !isEffectiveClassSymbol(symbol)
+                        && !(symbol.flags & SymbolFlags.Class)
                         && !isConstMergedWithNSPrintableAsSignatureMerge) {
                         serializeVariableOrProperty(symbol, symbolName, isPrivate, needsPostExportDefault, propertyAsAlias, modifierFlags);
                     }
                     if (symbol.flags & SymbolFlags.Enum) {
                         serializeEnum(symbol, symbolName, modifierFlags);
                     }
-                    if (isEffectiveClassSymbol(symbol)) {
+                    if (symbol.flags & SymbolFlags.Class) {
                         if (symbol.flags & SymbolFlags.Property && isBinaryExpression(symbol.valueDeclaration.parent) && isClassExpression(symbol.valueDeclaration.parent.right)) {
                             // Looks like a `module.exports.Sub = class {}` - if we serialize `symbol` as a class, the result will have no members,
                             // since the classiness is actually from the target of the effective alias the symbol is. yes. A BlockScopedVariable|Class|Property
@@ -6336,7 +6318,8 @@ namespace ts {
                     const baseTypes = getBaseTypes(classType);
                     const implementsTypes = getImplementsTypes(classType);
                     const staticType = getTypeOfSymbol(symbol);
-                    const staticBaseType = staticType.symbol?.valueDeclaration && isClassLike(staticType.symbol.valueDeclaration)
+                    const isClass = !!staticType.symbol?.valueDeclaration && isClassLike(staticType.symbol.valueDeclaration);
+                    const staticBaseType = isClass
                         ? getBaseConstructorTypeOfClass(staticType as InterfaceType)
                         : anyType;
                     const heritageClauses = [
@@ -6374,7 +6357,17 @@ namespace ts {
                     const staticMembers = flatMap(
                         filter(getPropertiesOfType(staticType), p => !(p.flags & SymbolFlags.Prototype) && p.escapedName !== "prototype" && !isNamespaceMember(p)),
                         p => serializePropertySymbolForClass(p, /*isStatic*/ true, staticBaseType));
-                    const constructors = serializeSignatures(SignatureKind.Construct, staticType, baseTypes[0], SyntaxKind.Constructor) as ConstructorDeclaration[];
+                    // When we encounter an `X.prototype.y` assignment in a JS file, we bind `X` as a class regardless as to whether
+                    // the value is ever initialized with a class or function-like value. For cases where `X` could never be
+                    // created via `new`, we will inject a `private constructor()` declaration to indicate it is not createable.
+                    const isNonConstructableClassLikeInJsFile =
+                        !isClass &&
+                        !!symbol.valueDeclaration &&
+                        isInJSFile(symbol.valueDeclaration) &&
+                        !some(getSignaturesOfType(staticType, SignatureKind.Construct));
+                    const constructors = isNonConstructableClassLikeInJsFile ?
+                        [createConstructor(/*decorators*/ undefined, createModifiersFromModifierFlags(ModifierFlags.Private), [], /*body*/ undefined)] :
+                        serializeSignatures(SignatureKind.Construct, staticType, baseTypes[0], SyntaxKind.Constructor) as ConstructorDeclaration[];
                     for (const c of constructors) {
                         // A constructor's return type and type parameters are supposed to be controlled by the enclosing class declaration
                         // `signatureToSignatureDeclarationHelper` appends them regardless, so for now we delete them here

tests/baselines/reference/jsDeclarationsClassLikeHeuristic.js

@@ -12,4 +12,7 @@ A.prototype.b = {};
 
 
 //// [index.d.ts]
-declare let A: any;
+declare class A {
+    private constructor();
+    b: {};
+}