Fixed CJS class expression exports emit anonymous constructor types (#3850)

Author: johnfav03

internal/checker/checker.go

@@ -648,6 +648,7 @@ type Checker struct {
 	moduleSymbols                               map[*ast.Node]*ast.Symbol
 	globalThisSymbol                            *ast.Symbol
 	symbolTableAliasCache                       map[symbolTableID][]*ast.Symbol
+	classExpressionNameTables                   map[ast.NodeId]ast.SymbolTable
 	resolveName                                 func(location *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message, isUse bool, excludeGlobals bool) *ast.Symbol
 	resolveNameForSymbolSuggestion              func(location *ast.Node, name string, meaning ast.SymbolFlags, nameNotFoundMessage *diagnostics.Message, isUse bool, excludeGlobals bool) *ast.Symbol
 	tupleTypes                                  map[CacheHashKey]*Type

internal/checker/emitresolver.go

@@ -896,6 +896,24 @@ func (r *EmitResolver) GetReferencedValueDeclarations(node *ast.IdentifierNode)
 	return r.getReferenceResolver().GetReferencedValueDeclarations(node)
 }
 
+// IsNameResolvedToDeclaration checks whether `name` resolved at `location`
+// resolves to a symbol that includes `declaration` among its declarations.
+// When `declaration` is nil, checks whether the name resolves to any symbol.
+// This is used by the declaration emitter to check for naming conflicts at file scope.
+func (r *EmitResolver) IsNameResolvedToDeclaration(location *ast.Node, name string, declaration *ast.Node) bool {
+	r.checkerMu.Lock()
+	defer r.checkerMu.Unlock()
+
+	symbol := r.checker.resolveName(location, name, ast.SymbolFlagsValue|ast.SymbolFlagsType|ast.SymbolFlagsNamespace, nil /*nameNotFoundMessage*/, false /*isUse*/, false /*excludeGlobals*/)
+	if symbol == nil {
+		return false
+	}
+	if declaration == nil {
+		return true
+	}
+	return slices.Contains(symbol.Declarations, declaration)
+}
+
 func (r *EmitResolver) GetElementAccessExpressionName(expression *ast.ElementAccessExpression) string {
 	if !ast.IsParseTreeNode(expression.AsNode()) {
 		return ""

internal/checker/symbolaccessibility.go

@@ -785,12 +785,48 @@ func (c *Checker) someSymbolTableInScope(
 			if table != nil && callback(table, symbolTableIDFromMembers(sym), false, false, location) {
 				return true
 			}
+			// Class expression names (e.g., `B` in `class B {}`) are not stored in any
+			// scope table — the binder uses bindAnonymousDeclaration. Expose the name
+			// binding here so getAccessibleSymbolChain can resolve self-references.
+			// This mirrors the special casing of class expression names in
+			// (*NameResolver).Resolve; if class names are ever bound differently
+			// (e.g., via class-local type aliases), both sites should be updated.
+			if ast.IsClassExpression(location) && location.AsClassExpression().Name() != nil {
+				nameTable := c.getClassExpressionNameTable(location)
+				if nameTable != nil && callback(nameTable, symbolTableIDFromLocals(location.AsNode()), false, true, location) {
+					return true
+				}
+			}
 		}
 	}
 
 	return callback(c.globals, symbolTableIDFromGlobals(), false, true, nil)
 }
 
+// getClassExpressionNameTable returns a cached symbol table containing the class
+// expression's name binding. Class expression names are bound via
+// bindAnonymousDeclaration and aren't stored in any container's locals, so this
+// synthesized table lets someSymbolTableInScope expose them during accessibility checks.
+func (c *Checker) getClassExpressionNameTable(location *ast.Node) ast.SymbolTable {
+	nodeId := ast.GetNodeId(location)
+	if c.classExpressionNameTables != nil {
+		if table, ok := c.classExpressionNameTables[nodeId]; ok {
+			return table
+		}
+	}
+	classSymbol := c.getSymbolOfDeclaration(location)
+	nameText := location.AsClassExpression().Name().Text()
+	if len(nameText) == 0 || classSymbol == nil {
+		return nil
+	}
+	table := ast.SymbolTable{nameText: classSymbol}
+	if c.classExpressionNameTables == nil {
+		c.classExpressionNameTables = make(map[ast.NodeId]ast.SymbolTable)
+	}
+	c.classExpressionNameTables[nodeId] = table
+	return table
+}
+
 /**
  * Check if the given symbol in given enclosing declaration is accessible and mark all associated alias to be visible if requested
  *

internal/printer/emitresolver.go

@@ -104,6 +104,7 @@ type EmitResolver interface {
 	IsLiteralConstDeclaration(node *ast.Node) bool
 	RequiresAddingImplicitUndefined(node *ast.Node, symbol *ast.Symbol, enclosingDeclaration *ast.Node) bool
 	IsDeclarationVisible(node *ast.Node) bool
+	IsNameResolvedToDeclaration(location *ast.Node, name string, declaration *ast.Node) bool
 	IsImportRequiredByAugmentation(decl *ast.ImportDeclaration) bool
 	IsDefinitelyReferenceToGlobalSymbolObject(node *ast.Node) bool
 	IsImplementationOfOverload(node *ast.SignatureDeclaration) bool

internal/transformers/declarations/tracker.go

@@ -15,6 +15,11 @@ type SymbolTrackerImpl struct {
 	host          DeclarationEmitHost
 	fallbackStack []*ast.Node
 
+	// For detecting class expression self-references during member serialization.
+	// When set, TrackSymbol will record usage without reporting accessibility errors.
+	watchedClassSymbol *ast.Symbol
+	classSymbolTracked bool
+
 	getIsolatedDeclarationError func(node *ast.Node) *ast.Diagnostic
 }
 
@@ -157,6 +162,13 @@ func (s *SymbolTrackerImpl) TrackSymbol(symbol *ast.Symbol, enclosingDeclaration
 	if symbol.Flags&ast.SymbolFlagsTypeParameter != 0 {
 		return false
 	}
+	// When watching for a class expression symbol, record its usage without
+	// reporting accessibility errors — the caller will handle visibility by
+	// wrapping the class in a namespace.
+	if s.watchedClassSymbol != nil && symbol == s.watchedClassSymbol {
+		s.classSymbolTracked = true
+		return false
+	}
 	issuedDiagnostic := s.handleSymbolAccessibilityError(s.resolver.IsSymbolAccessible(symbol, enclosingDeclaration, meaning /*shouldComputeAliasToMarkVisible*/, true))
 	return issuedDiagnostic
 }