Only export @typedef type aliases in modules

internal/ast/ast.go

@@ -2281,6 +2281,7 @@ func declarationIsWriteAccess(decl *Node) bool {
 		KindParameter,
 		KindShorthandPropertyAssignment,
 		KindTypeAliasDeclaration,
+		KindJSTypeAliasDeclaration,
 		KindTypeParameter:
 		return true
 
@@ -5139,7 +5140,7 @@ func (node *ExportAssignment) Clone(f NodeFactoryCoercible) *Node {
 }
 
 func (node *ExportAssignment) computeSubtreeFacts() SubtreeFacts {
-	return propagateModifierListSubtreeFacts(node.modifiers) | propagateSubtreeFacts(node.Type) | propagateSubtreeFacts(node.Expression)
+	return propagateModifierListSubtreeFacts(node.modifiers) | propagateSubtreeFacts(node.Type) | propagateSubtreeFacts(node.Expression) | core.IfElse(node.IsExportEquals, SubtreeContainsTypeScript, SubtreeFactsNone)
 }
 
 func IsExportAssignment(node *Node) bool {

internal/ast/utilities.go

@@ -3894,3 +3894,7 @@ func IsExpandoInitializer(initializer *Node) bool {
 func GetContainingFunction(node *Node) *Node {
 	return FindAncestor(node.Parent, IsFunctionLike)
 }
+
+func IsImplicitlyExportedJSTypeAlias(node *Node) bool {
+	return IsJSTypeAliasDeclaration(node) && IsSourceFile(node.Parent) && IsExternalOrCommonJSModule(node.Parent.AsSourceFile())
+}

internal/binder/binder.go

@@ -380,7 +380,7 @@ func (b *Binder) declareModuleMember(node *ast.Node, symbolFlags ast.SymbolFlags
 	if node.Kind == ast.KindCommonJSExport {
 		container = b.file.AsNode()
 	}
-	hasExportModifier := ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsExport != 0
+	hasExportModifier := ast.GetCombinedModifierFlags(node)&ast.ModifierFlagsExport != 0 || ast.IsImplicitlyExportedJSTypeAlias(node)
 	if symbolFlags&ast.SymbolFlagsAlias != 0 {
 		if node.Kind == ast.KindExportSpecifier || (node.Kind == ast.KindImportEqualsDeclaration && hasExportModifier) {
 			return b.declareSymbol(ast.GetExports(container.Symbol()), container.Symbol(), node, symbolFlags, symbolExcludes)

internal/checker/checker.go

@@ -6805,7 +6805,7 @@ func (c *Checker) checkUnusedClassMembers(node *ast.Node) {
 					c.reportUnused(parameter, UnusedKindLocal, NewDiagnosticForNode(parameter.Name(), diagnostics.Property_0_is_declared_but_its_value_is_never_read, ast.SymbolName(parameter.Symbol())))
 				}
 			}
-		case ast.KindIndexSignature, ast.KindSemicolonClassElement, ast.KindClassStaticBlockDeclaration:
+		case ast.KindIndexSignature, ast.KindSemicolonClassElement, ast.KindClassStaticBlockDeclaration, ast.KindJSTypeAliasDeclaration:
 			// Can't be private
 		default:
 			panic("Unhandled case in checkUnusedClassMembers")

internal/checker/emitresolver.go

@@ -155,8 +155,9 @@ func (r *EmitResolver) determineIfDeclarationIsVisible(node *ast.Node) bool {
 			}
 			// falls through
 		}
-		// external module augmentation is always visible
-		if ast.IsExternalModuleAugmentation(node) {
+		// External module augmentation is always visible
+		// A @typedef at top-level in an external module is always visible
+		if ast.IsExternalModuleAugmentation(node) || ast.IsImplicitlyExportedJSTypeAlias(node) {
 			return true
 		}
 		parent := ast.GetDeclarationContainer(node)

internal/ls/importTracker.go

@@ -502,7 +502,7 @@ func getImportOrExportSymbol(node *ast.Node, symbol *ast.Symbol, checker *checke
 		} else {
 			exportNode := getExportNode(parent, node)
 			switch {
-			case exportNode != nil && ast.HasSyntacticModifier(exportNode, ast.ModifierFlagsExport):
+			case exportNode != nil && (ast.HasSyntacticModifier(exportNode, ast.ModifierFlagsExport) || ast.IsImplicitlyExportedJSTypeAlias(exportNode)):
 				if ast.IsImportEqualsDeclaration(exportNode) && exportNode.AsImportEqualsDeclaration().ModuleReference == node {
 					// We're at `Y` in `export import X = Y`. This is not the exported symbol, the left-hand-side is. So treat this as an import statement.
 					if comingFromExport {

internal/parser/reparser.go

@@ -70,17 +70,11 @@ func (p *Parser) reparseTags(parent *ast.Node, jsDoc []*ast.Node) {
 func (p *Parser) reparseUnhosted(tag *ast.Node, parent *ast.Node, jsDoc *ast.Node) {
 	switch tag.Kind {
 	case ast.KindJSDocTypedefTag:
-		// !!! Don't mark typedefs as exported if they are not in a module
 		typeExpression := tag.AsJSDocTypedefTag().TypeExpression
 		if typeExpression == nil {
 			break
 		}
-		export := p.factory.NewModifier(ast.KindExportKeyword)
-		export.Loc = tag.Loc
-		export.Flags = p.contextFlags | ast.NodeFlagsReparsed
-		modifiers := p.newModifierList(export.Loc, p.nodeSlicePool.NewSlice1(export))
-
-		typeAlias := p.factory.NewJSTypeAliasDeclaration(modifiers, p.factory.DeepCloneReparse(tag.AsJSDocTypedefTag().Name()), nil, nil)
+		typeAlias := p.factory.NewJSTypeAliasDeclaration(nil, p.factory.DeepCloneReparse(tag.AsJSDocTypedefTag().Name()), nil, nil)
 		typeAlias.AsTypeAliasDeclaration().TypeParameters = p.gatherTypeParameters(jsDoc, tag)
 		var t *ast.Node
 		switch typeExpression.Kind {

internal/transformers/declarations/transform.go

@@ -1582,6 +1582,9 @@ func (tx *DeclarationTransformer) ensureModifierFlags(node *ast.Node) ast.Modifi
 		mask ^= ast.ModifierFlagsAmbient
 		additions = ast.ModifierFlagsNone
 	}
+	if ast.IsImplicitlyExportedJSTypeAlias(node) {
+		additions |= ast.ModifierFlagsExport
+	}
 	return maskModifierFlags(tx.host, node, mask, additions)
 }
 

testdata/baselines/reference/compiler/emitEndOfFileJSDocComments.js

@@ -6,8 +6,6 @@ var unrelated;
 /** @typedef {number} B */
 
 //// [emitEndOfFileJSDocComments.js]
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
 /** @typedef {number} A */
 var unrelated;
 /** @typedef {number} B */ 

testdata/baselines/reference/compiler/emitEndOfFileJSDocComments2.js

@@ -22,9 +22,7 @@ function test(param) {
 
 
 //// [emitEndOfFileJSDocComments2.js]
-"use strict";
 /** @typedef {number} A */
-Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * JSDoc comment for function
  * @param {string} param - A string parameter

testdata/baselines/reference/compiler/nestedJSDocImportType.errors.txt

@@ -0,0 +1,16 @@
+b.js(3,24): error TS2306: File 'a.js' is not a module.
+
+
+==== a.js (0 errors) ====
+    /** @typedef {string} A */
+
+==== b.js (1 errors) ====
+    module.exports = {
+      create() {
+        /** @param {import("./a").A} x */
+                           ~~~~~
+!!! error TS2306: File 'a.js' is not a module.
+        function f(x) {}
+        return f("hi");
+      }
+    }

testdata/baselines/reference/submodule/compiler/commonJsExportTypeDeclarationError.js

@@ -19,9 +19,6 @@ export type test = test;
 
 
 //// [test.js]
-export = {
-    message: ""
-};
 module.exports = {
     message: ""
 };

testdata/baselines/reference/submodule/compiler/commonJsIsolatedModules.js

@@ -6,6 +6,5 @@ var x = 1
 
 
 //// [index.js]
-export = {};
 module.exports = {};
 var x = 1;

testdata/baselines/reference/submodule/compiler/importHelpersCommonJSJavaScript(verbatimmodulesyntax=false).js

@@ -49,5 +49,4 @@ class Foo {
 }
 class Bar extends Foo {
 }
-export = Bar;
 module.exports = Bar;

testdata/baselines/reference/submodule/compiler/importHelpersCommonJSJavaScript(verbatimmodulesyntax=true).js

@@ -49,5 +49,4 @@ class Foo {
 }
 class Bar extends Foo {
 }
-export = Bar;
 module.exports = Bar;

testdata/baselines/reference/submodule/compiler/javascriptCommonjsModule.js

@@ -13,5 +13,4 @@ class Foo {
 }
 class Bar extends Foo {
 }
-export = Bar;
 module.exports = Bar;

testdata/baselines/reference/submodule/compiler/jsDeclarationEmitExportAssignedFunctionWithExtraTypedefsMembers.js

@@ -14,15 +14,6 @@ module.exports = function loader(options) {}
 
 //// [index.js]
 "use strict";
-/**
- * @typedef Options
- * @property {string} opt
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * @param {Options} options
- */
-export = function loader(options) { };
 /**
  * @typedef Options
  * @property {string} opt

testdata/baselines/reference/submodule/compiler/jsDeclarationEmitExportAssignedFunctionWithExtraTypedefsMembers.js.diff

@@ -1,22 +1,6 @@
 --- old.jsDeclarationEmitExportAssignedFunctionWithExtraTypedefsMembers.js
 +++ new.jsDeclarationEmitExportAssignedFunctionWithExtraTypedefsMembers.js
-@@= skipped -17, +17 lines =@@
-  * @typedef Options
-  * @property {string} opt
-  */
-+Object.defineProperty(exports, "__esModule", { value: true });
-+/**
-+ * @param {Options} options
-+ */
-+export = function loader(options) { };
-+/**
-+ * @typedef Options
-+ * @property {string} opt
-+ */
- /**
-  * @param {Options} options
-  */
-@@= skipped -7, +16 lines =@@
+@@= skipped -24, +24 lines =@@
 
 
  //// [index.d.ts]

testdata/baselines/reference/submodule/compiler/jsDeclarationsInheritedTypes.js

@@ -40,9 +40,31 @@ class C3 extends C1 {
  * @typedef A
  * @property {string} a
  */
-export type A = {
+type A = {
     a: string;
 };
-export type B = {
+type B = {
     b: number;
 };
+/**
+ * @typedef B
+ * @property {number} b
+ */
+declare class C1 {
+    /**
+     * @type {A}
+     */
+    value: A;
+}
+declare class C2 extends C1 {
+    /**
+     * @type {A}
+     */
+    value: A;
+}
+declare class C3 extends C1 {
+    /**
+     * @type {A & B}
+     */
+    value: A & B;
+}

testdata/baselines/reference/submodule/compiler/jsDeclarationsInheritedTypes.js.diff

@@ -4,29 +4,33 @@
   * @typedef A
   * @property {string} a
   */
--/**
-- * @typedef B
-- * @property {number} b
-- */
--declare class C1 {
--    /**
--     * @type {A}
--     */
--    value: A;
--}
--declare class C2 extends C1 {
--}
--declare class C3 extends C1 {
--    /**
--     * @type {A & B}
--     */
--    value: A & B;
--}
++type A = {
++    a: string;
++};
++type B = {
++    b: number;
++};
+ /**
+  * @typedef B
+  * @property {number} b
+@@= skipped -11, +17 lines =@@
+     value: A;
+ }
+ declare class C2 extends C1 {
++    /**
++     * @type {A}
++     */
++    value: A;
+ }
+ declare class C3 extends C1 {
+     /**
+@@= skipped -7, +11 lines =@@
+      */
+     value: A & B;
+ }
 -type A = {
-+export type A = {
-     a: string;
- };
+-    a: string;
+-};
 -type B = {
-+export type B = {
-     b: number;
- };
+-    b: number;
+-};