Add JS support to declaration transformer (currently untested in baselines aside from diagnostic output)

weswigham · weswigham · commit bc86f35d2765 · 2025-05-01T13:56:54.000-07:00
diff --git a/internal/ast/utilities.go b/internal/ast/utilities.go
@@ -3092,6 +3092,7 @@ func IsLateVisibilityPaintedStatement(node *Node) bool {
 		KindFunctionDeclaration,
 		KindModuleDeclaration,
 		KindTypeAliasDeclaration,
+		KindJSTypeAliasDeclaration,
 		KindInterfaceDeclaration,
 		KindEnumDeclaration:
 		return true
diff --git a/internal/checker/emitresolver.go b/internal/checker/emitresolver.go
@@ -114,6 +114,7 @@ func (r *emitResolver) determineIfDeclarationIsVisible(node *ast.Node) bool {
 		ast.KindClassDeclaration,
 		ast.KindInterfaceDeclaration,
 		ast.KindTypeAliasDeclaration,
+		ast.KindJSTypeAliasDeclaration,
 		ast.KindFunctionDeclaration,
 		ast.KindEnumDeclaration,
 		ast.KindImportEqualsDeclaration:
@@ -185,7 +186,7 @@ func (r *emitResolver) determineIfDeclarationIsVisible(node *ast.Node) bool {
 		return true
 
 	// Export assignments do not create name bindings outside the module
-	case ast.KindExportAssignment:
+	case ast.KindExportAssignment, ast.KindJSExportAssignment:
 		return false
 
 	default:
@@ -206,7 +207,7 @@ func (r *emitResolver) PrecalculateDeclarationEmitVisibility(file *ast.SourceFil
 
 func (r *emitResolver) aliasMarkingVisitor(node *ast.Node) bool {
 	switch node.Kind {
-	case ast.KindExportAssignment:
+	case ast.KindExportAssignment, ast.KindJSExportAssignment:
 		if node.AsExportAssignment().Expression.Kind == ast.KindIdentifier {
 			r.markLinkedAliases(node.Expression())
 		}
diff --git a/internal/checker/nodebuilder.go b/internal/checker/nodebuilder.go
@@ -928,6 +928,7 @@ func (b *NodeBuilder) getSymbolChain(symbol *ast.Symbol, meaning ast.SymbolFlags
 							// parentChain root _is_ symbol - symbol is a module export=, so it kinda looks like it's own parent
 							// No need to lookup an alias for the symbol in itself
 							accessibleSymbolChain = parentChain
+							break
 						}
 					}
 					nextSyms := accessibleSymbolChain
diff --git a/internal/declarations/diagnostics.go b/internal/declarations/diagnostics.go
@@ -182,28 +182,16 @@ func createGetSymbolAccessibilityDiagnosticForNode(node *ast.Node) GetSymbolAcce
 		return wrapSimpleDiagnosticSelector(node, func(_ *ast.Node, _ printer.SymbolAccessibilityResult) *diagnostics.Message {
 			return diagnostics.Import_declaration_0_is_using_private_name_1
 		})
-	} else if ast.IsTypeAliasDeclaration(node) /*|| ast.IsJSDocTypeAlias(node)*/ { // !!! JSDoc support
+	} else if ast.IsTypeAliasDeclaration(node) || ast.IsJSTypeAliasDeclaration(node) {
 		// unique node selection behavior, inline closure
 		return func(symbolAccessibilityResult printer.SymbolAccessibilityResult) *SymbolAccessibilityDiagnostic {
 			diagnosticMessage := selectDiagnosticBasedOnModuleNameNoNameCheck(
 				symbolAccessibilityResult,
 				diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1_from_module_2,
 				diagnostics.Exported_type_alias_0_has_or_is_using_private_name_1,
 			)
-			var errorNode *ast.Node
-			// !!! JSDoc Support
-			////if ast.IsJSDocTypeAlias(node) {
-			////	errorNode = node.AsJSDocTypedefTag().TypeExpression
-			////} else {
-			errorNode = node.AsTypeAliasDeclaration().Type
-			////}
-			var typeName *ast.Node
-			// !!! JSDoc Support
-			////if ast.IsJSDocTypeAlias(node) {
-			////	errorNode = getNameOfDeclaration(node)
-			////} else {
-			typeName = node.Name()
-			////}
+			errorNode := node.AsTypeAliasDeclaration().Type
+			typeName := node.Name()
 			return &SymbolAccessibilityDiagnostic{
 				errorNode:         errorNode,
 				diagnosticMessage: diagnosticMessage,
@@ -454,7 +442,7 @@ func getTypeParameterConstraintVisibilityDiagnosticMessage(node *ast.Node, symbo
 	case ast.KindInferType:
 		return diagnostics.Extends_clause_for_inferred_type_0_has_or_is_using_private_name_1
 
-	case ast.KindTypeAliasDeclaration:
+	case ast.KindTypeAliasDeclaration, ast.KindJSTypeAliasDeclaration:
 		return diagnostics.Type_parameter_0_of_exported_type_alias_has_or_is_using_private_name_1
 
 	default:
diff --git a/internal/declarations/transform.go b/internal/declarations/transform.go
@@ -106,11 +106,13 @@ func (tx *DeclarationTransformer) visit(node *ast.Node) *ast.Node {
 		ast.KindImportEqualsDeclaration,
 		ast.KindInterfaceDeclaration,
 		ast.KindClassDeclaration,
+		ast.KindJSTypeAliasDeclaration,
 		ast.KindTypeAliasDeclaration,
 		ast.KindEnumDeclaration,
 		ast.KindVariableStatement,
 		ast.KindImportDeclaration,
 		ast.KindExportDeclaration,
+		ast.KindJSExportAssignment,
 		ast.KindExportAssignment:
 		return tx.visitDeclarationStatements(node)
 	// statements we elide
@@ -133,8 +135,7 @@ func (tx *DeclarationTransformer) visit(node *ast.Node) *ast.Node {
 		ast.KindWithStatement,
 		ast.KindNotEmittedStatement,
 		ast.KindBlock,
-		ast.KindMissingDeclaration,
-		ast.KindJSTypeAliasDeclaration: // !!! TODO: Jsdoc support
+		ast.KindMissingDeclaration:
 		return nil
 	// parts of things, things we just visit children of
 	default:
@@ -180,20 +181,15 @@ func (tx *DeclarationTransformer) collectFileReferences(sourceFile *ast.SourceFi
 
 func (tx *DeclarationTransformer) transformSourceFile(node *ast.SourceFile) *ast.Node {
 	var combinedStatements *ast.StatementList
-	if ast.IsSourceFileJS(node) {
-		// !!! TODO: JS declaration emit support
-		combinedStatements = tx.Factory().NewNodeList([]*ast.Node{})
-	} else {
-		statements := tx.Visitor().VisitNodes(node.Statements)
-		combinedStatements = tx.transformAndReplaceLatePaintedStatements(statements)
-		combinedStatements.Loc = statements.Loc // setTextRange
-		if ast.IsExternalModule(node) && (!tx.resultHasExternalModuleIndicator || (tx.needsScopeFixMarker && !tx.resultHasScopeMarker)) {
-			marker := createEmptyExports(tx.Factory().AsNodeFactory())
-			newList := append(combinedStatements.Nodes, marker)
-			withMarker := tx.Factory().NewNodeList(newList)
-			withMarker.Loc = combinedStatements.Loc
-			combinedStatements = withMarker
-		}
+	statements := tx.Visitor().VisitNodes(node.Statements)
+	combinedStatements = tx.transformAndReplaceLatePaintedStatements(statements)
+	combinedStatements.Loc = statements.Loc // setTextRange
+	if ast.IsExternalOrCommonJSModule(node) && (!tx.resultHasExternalModuleIndicator || (tx.needsScopeFixMarker && !tx.resultHasScopeMarker)) {
+		marker := createEmptyExports(tx.Factory().AsNodeFactory())
+		newList := append(combinedStatements.Nodes, marker)
+		withMarker := tx.Factory().NewNodeList(newList)
+		withMarker.Loc = combinedStatements.Loc
+		combinedStatements = withMarker
 	}
 	outputFilePath := tspath.GetDirectoryPath(tspath.NormalizeSlashes(tx.declarationFilePath))
 	result := tx.Factory().UpdateSourceFile(node, combinedStatements)
@@ -409,7 +405,7 @@ func (tx *DeclarationTransformer) visitDeclarationSubtree(input *ast.Node) *ast.
 
 	canProdiceDiagnostic := canProduceDiagnostics(input)
 	oldWithinObjectLiteralType := tx.suppressNewDiagnosticContexts
-	shouldEnterSuppressNewDiagnosticsContextContext := (input.Kind == ast.KindTypeLiteral || input.Kind == ast.KindMappedType) && input.Parent.Kind != ast.KindTypeAliasDeclaration
+	shouldEnterSuppressNewDiagnosticsContextContext := (input.Kind == ast.KindTypeLiteral || input.Kind == ast.KindMappedType) && !(input.Parent.Kind == ast.KindTypeAliasDeclaration || input.Parent.Kind == ast.KindJSTypeAliasDeclaration)
 
 	oldDiag := tx.state.getSymbolAccessibilityDiagnostic
 	if canProdiceDiagnostic && !tx.suppressNewDiagnosticContexts {
@@ -476,6 +472,22 @@ func (tx *DeclarationTransformer) visitDeclarationSubtree(input *ast.Node) *ast.
 				tx.EmitContext().AddEmitFlags(result, printer.EFSingleLine)
 			}
 		}
+	case ast.KindJSDocTypeExpression:
+		result = tx.transformJSDocTypeExpression(input.AsJSDocTypeExpression())
+	case ast.KindJSDocTypeLiteral:
+		result = tx.transformJSDocTypeLiteral(input.AsJSDocTypeLiteral())
+	case ast.KindJSDocPropertyTag:
+		result = tx.transformJSDocPropertyTag(input.AsJSDocPropertyTag())
+	case ast.KindJSDocAllType:
+		result = tx.transformJSDocAllType(input.AsJSDocAllType())
+	case ast.KindJSDocNullableType:
+		result = tx.transformJSDocNullableType(input.AsJSDocNullableType())
+	case ast.KindJSDocNonNullableType:
+		result = tx.transformJSDocNonNullableType(input.AsJSDocNonNullableType())
+	case ast.KindJSDocOptionalType:
+		result = tx.transformJSDocOptionalType(input.AsJSDocOptionalType())
+	case ast.KindJSDocVariadicType:
+		result = tx.transformJSDocVariadicType(input.AsJSDocVariadicType())
 	default:
 		result = tx.Visitor().VisitEachChild(input)
 	}
@@ -890,7 +902,7 @@ func (tx *DeclarationTransformer) visitDeclarationStatements(input *ast.Node) *a
 			tx.rewriteModuleSpecifier(input, input.AsExportDeclaration().ModuleSpecifier),
 			tx.tryGetResolutionModeOverride(input.AsExportDeclaration().Attributes),
 		)
-	case ast.KindExportAssignment:
+	case ast.KindExportAssignment, ast.KindJSExportAssignment:
 		if ast.IsSourceFile(input.Parent) {
 			tx.resultHasExternalModuleIndicator = true
 		}
@@ -1067,7 +1079,7 @@ func (tx *DeclarationTransformer) transformTopLevelDeclaration(input *ast.Node)
 
 	var result *ast.Node
 	switch input.Kind {
-	case ast.KindTypeAliasDeclaration:
+	case ast.KindTypeAliasDeclaration, ast.KindJSTypeAliasDeclaration:
 		result = tx.transformTypeAliasDeclaration(input.AsTypeAliasDeclaration())
 	case ast.KindInterfaceDeclaration:
 		result = tx.transformInterfaceDeclaration(input.AsInterfaceDeclaration())
@@ -1691,3 +1703,60 @@ func (tx *DeclarationTransformer) transformImportDeclaration(decl *ast.ImportDec
 	// Nothing visible
 	return nil
 }
+
+func (tx *DeclarationTransformer) transformJSDocTypeExpression(input *ast.JSDocTypeExpression) *ast.Node {
+	return tx.Visitor().Visit(input.Type)
+}
+
+func (tx *DeclarationTransformer) transformJSDocTypeLiteral(input *ast.JSDocTypeLiteral) *ast.Node {
+	members, _ := tx.Visitor().VisitSlice(input.JSDocPropertyTags)
+	replacement := tx.Factory().NewTypeLiteralNode(tx.Factory().NewNodeList(members))
+	tx.EmitContext().SetOriginal(replacement, input.AsNode())
+	return replacement
+}
+
+func (tx *DeclarationTransformer) transformJSDocPropertyTag(input *ast.JSDocPropertyTag) *ast.Node {
+	replacement := tx.Factory().NewPropertySignatureDeclaration(
+		nil,
+		tx.Visitor().Visit(input.TagName),
+		nil,
+		tx.Visitor().Visit(input.TypeExpression),
+		nil,
+	)
+	tx.EmitContext().SetOriginal(replacement, input.AsNode())
+	return replacement
+}
+
+func (tx *DeclarationTransformer) transformJSDocAllType(input *ast.JSDocAllType) *ast.Node {
+	replacement := tx.Factory().NewKeywordTypeNode(ast.KindAnyKeyword)
+	tx.EmitContext().SetOriginal(replacement, input.AsNode())
+	return replacement
+}
+
+func (tx *DeclarationTransformer) transformJSDocNullableType(input *ast.JSDocNullableType) *ast.Node {
+	replacement := tx.Factory().NewUnionTypeNode(tx.Factory().NewNodeList([]*ast.Node{
+		tx.Visitor().Visit(input.Type),
+		tx.Factory().NewLiteralTypeNode(tx.Factory().NewKeywordExpression(ast.KindNullKeyword)),
+	}))
+	tx.EmitContext().SetOriginal(replacement, input.AsNode())
+	return replacement
+}
+
+func (tx *DeclarationTransformer) transformJSDocNonNullableType(input *ast.JSDocNonNullableType) *ast.Node {
+	return tx.Visitor().Visit(input.Type)
+}
+
+func (tx *DeclarationTransformer) transformJSDocVariadicType(input *ast.JSDocVariadicType) *ast.Node {
+	replacement := tx.Factory().NewArrayTypeNode(tx.Visitor().Visit(input.Type))
+	tx.EmitContext().SetOriginal(replacement, input.AsNode())
+	return replacement
+}
+
+func (tx *DeclarationTransformer) transformJSDocOptionalType(input *ast.JSDocOptionalType) *ast.Node {
+	replacement := tx.Factory().NewUnionTypeNode(tx.Factory().NewNodeList([]*ast.Node{
+		tx.Visitor().Visit(input.Type),
+		tx.Factory().NewKeywordTypeNode(ast.KindUndefinedKeyword),
+	}))
+	tx.EmitContext().SetOriginal(replacement, input.AsNode())
+	return replacement
+}
diff --git a/internal/declarations/util.go b/internal/declarations/util.go
@@ -39,6 +39,7 @@ func canProduceDiagnostics(node *ast.Node) bool {
 		ast.IsExpressionWithTypeArguments(node) ||
 		ast.IsImportEqualsDeclaration(node) ||
 		ast.IsTypeAliasDeclaration(node) ||
+		ast.IsJSTypeAliasDeclaration(node) ||
 		ast.IsConstructorDeclaration(node) ||
 		ast.IsIndexSignatureDeclaration(node) ||
 		ast.IsPropertyAccessExpression(node) ||
@@ -59,6 +60,7 @@ func hasInferredType(node *ast.Node) bool {
 		ast.KindBinaryExpression,
 		ast.KindVariableDeclaration,
 		ast.KindExportAssignment,
+		ast.KindJSExportAssignment,
 		ast.KindPropertyAssignment,
 		ast.KindShorthandPropertyAssignment,
 		ast.KindJSDocParameterTag,
@@ -78,6 +80,7 @@ func isDeclarationAndNotVisible(emitContext *printer.EmitContext, resolver print
 		ast.KindInterfaceDeclaration,
 		ast.KindClassDeclaration,
 		ast.KindTypeAliasDeclaration,
+		ast.KindJSTypeAliasDeclaration,
 		ast.KindEnumDeclaration:
 		return !resolver.IsDeclarationVisible(node)
 	// The following should be doing their own visibility checks based on filtering their members
@@ -86,6 +89,7 @@ func isDeclarationAndNotVisible(emitContext *printer.EmitContext, resolver print
 	case ast.KindImportEqualsDeclaration,
 		ast.KindImportDeclaration,
 		ast.KindExportDeclaration,
+		ast.KindJSExportAssignment,
 		ast.KindExportAssignment:
 		return false
 	case ast.KindClassStaticBlockDeclaration:
@@ -119,6 +123,7 @@ func getBindingNameVisible(resolver printer.EmitResolver, elem *ast.Node) bool {
 func isEnclosingDeclaration(node *ast.Node) bool {
 	return ast.IsSourceFile(node) ||
 		ast.IsTypeAliasDeclaration(node) ||
+		ast.IsJSTypeAliasDeclaration(node) ||
 		ast.IsModuleDeclaration(node) ||
 		ast.IsClassDeclaration(node) ||
 		ast.IsInterfaceDeclaration(node) ||

Original file line number	Diff line number	Diff line change
`@@ -928,6 +928,7 @@ func (b NodeBuilder) getSymbolChain(symbol ast.Symbol, meaning ast.SymbolFlags`
`928`	`928`	`// parentChain root _is_ symbol - symbol is a module export=, so it kinda looks like it's own parent`
`929`	`929`	`// No need to lookup an alias for the symbol in itself`
`930`	`930`	`accessibleSymbolChain = parentChain`
	`931`	`+ break`
`931`	`932`	`}`
`932`	`933`	`}`
`933`	`934`	`nextSyms := accessibleSymbolChain`