Error on modules-as-namespaces (#2760)

Copilot · jakebailey · web-flow · commit fbb2755f2906 · 2026-02-20T22:01:10.000Z
Co-authored-by: copilot-swe-agent[bot] &lt;198982749+Copilot@users.noreply.github.com&gt;
Co-authored-by: jakebailey &lt;5341706+jakebailey@users.noreply.github.com&gt;
diff --git a/internal/checker/checker.go b/internal/checker/checker.go
@@ -5013,10 +5013,6 @@ func (c *Checker) checkModuleDeclaration(node *ast.Node) {
 	}
 	if ast.IsIdentifier(node.Name()) {
 		c.checkCollisionsForDeclarationName(node, node.Name())
-		if node.AsModuleDeclaration().Keyword == ast.KindModuleKeyword {
-			tokenRange := getNonModifierTokenRangeOfNode(node)
-			c.suggestionDiagnostics.Add(ast.NewDiagnostic(ast.GetSourceFileOfNode(node), tokenRange, diagnostics.A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead))
-		}
 	}
 	c.checkExportsOnMergedDeclarations(node)
 	symbol := c.getSymbolOfDeclaration(node)
diff --git a/internal/checker/utilities.go b/internal/checker/utilities.go
@@ -1262,14 +1262,6 @@ func minAndMax[T any](slice []T, getValue func(value T) int) (int, int) {
 	return minValue, maxValue
 }
 
-func getNonModifierTokenRangeOfNode(node *ast.Node) core.TextRange {
-	pos := node.Pos()
-	if last := ast.FindLastVisibleNode(node.ModifierNodes()); last != nil {
-		pos = last.Pos()
-	}
-	return scanner.GetRangeOfTokenAtPosition(ast.GetSourceFileOfNode(node), pos)
-}
-
 type FeatureMapEntry struct {
 	lib   string
 	props []string
diff --git a/internal/parser/parser.go b/internal/parser/parser.go
@@ -2082,19 +2082,20 @@ func (p *Parser) parseEnumDeclaration(pos int, jsdoc jsdocScannerInfo, modifiers
 }
 
 func (p *Parser) parseModuleDeclaration(pos int, jsdoc jsdocScannerInfo, modifiers *ast.ModifierList) *ast.Statement {
-	keyword := ast.KindModuleKeyword
 	if p.token == ast.KindGlobalKeyword {
 		// global augmentation
 		return p.parseAmbientExternalModuleDeclaration(pos, jsdoc, modifiers)
 	} else if p.parseOptional(ast.KindNamespaceKeyword) {
-		keyword = ast.KindNamespaceKeyword
+		// namespace keyword always produces a namespace declaration
+		return p.parseModuleOrNamespaceDeclaration(pos, jsdoc, modifiers, false /*nested*/, false /*isIllegalModuleKeyword*/)
 	} else {
 		p.parseExpected(ast.KindModuleKeyword)
 		if p.token == ast.KindStringLiteral {
 			return p.parseAmbientExternalModuleDeclaration(pos, jsdoc, modifiers)
 		}
+		// `module X {}` is illegal; use `namespace` instead
+		return p.parseModuleOrNamespaceDeclaration(pos, jsdoc, modifiers, false /*nested*/, true /*isIllegalModuleKeyword*/)
 	}
-	return p.parseModuleOrNamespaceDeclaration(pos, jsdoc, modifiers, false /*nested*/, keyword)
 }
 
 func (p *Parser) parseAmbientExternalModuleDeclaration(pos int, jsdoc jsdocScannerInfo, modifiers *ast.ModifierList) *ast.Node {
@@ -2133,25 +2134,29 @@ func (p *Parser) parseModuleBlock() *ast.Node {
 	return p.finishNode(p.factory.NewModuleBlock(statements), pos)
 }
 
-func (p *Parser) parseModuleOrNamespaceDeclaration(pos int, jsdoc jsdocScannerInfo, modifiers *ast.ModifierList, nested bool, keyword ast.Kind) *ast.Node {
+func (p *Parser) parseModuleOrNamespaceDeclaration(pos int, jsdoc jsdocScannerInfo, modifiers *ast.ModifierList, nested bool, isIllegalModuleKeyword bool) *ast.Node {
 	saveHasAwaitIdentifier := p.statementHasAwaitIdentifier
 	var name *ast.Node
 	if nested {
 		name = p.parseIdentifierName()
 	} else {
 		name = p.parseIdentifier()
 	}
+	if isIllegalModuleKeyword && !nested {
+		errorStart := scanner.SkipTrivia(p.sourceText, name.Pos())
+		p.parseErrorAt(errorStart, name.End(), diagnostics.A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead)
+	}
 	var body *ast.Node
 	if p.parseOptional(ast.KindDotToken) {
 		implicitExport := p.factory.NewModifier(ast.KindExportKeyword)
 		implicitExport.Loc = core.NewTextRange(p.nodePos(), p.nodePos())
 		implicitExport.Flags = ast.NodeFlagsReparsed
 		implicitModifiers := p.newModifierList(implicitExport.Loc, p.nodeSlicePool.NewSlice1(implicitExport))
-		body = p.parseModuleOrNamespaceDeclaration(p.nodePos(), 0 /*jsdoc*/, implicitModifiers, true /*nested*/, keyword)
+		body = p.parseModuleOrNamespaceDeclaration(p.nodePos(), 0 /*jsdoc*/, implicitModifiers, true /*nested*/, isIllegalModuleKeyword)
 	} else {
 		body = p.parseModuleBlock()
 	}
-	result := p.finishNode(p.factory.NewModuleDeclaration(modifiers, keyword, name, body), pos)
+	result := p.finishNode(p.factory.NewModuleDeclaration(modifiers, ast.KindNamespaceKeyword, name, body), pos)
 	p.withJSDoc(result, jsdoc)
 	p.checkJSSyntax(result)
 	p.statementHasAwaitIdentifier = saveHasAwaitIdentifier
diff --git a/internal/printer/printer_test.go b/internal/printer/printer_test.go
@@ -255,8 +255,6 @@ func TestEmit(t *testing.T) {
 		{title: "EnumDeclaration#1", input: `enum a{}`, output: "enum a {\n}"},
 		{title: "EnumDeclaration#2", input: `enum a{b}`, output: "enum a {\n    b\n}"},
 		{title: "EnumDeclaration#3", input: `enum a{b=c}`, output: "enum a {\n    b = c\n}"},
-		{title: "ModuleDeclaration#1", input: `module a{}`, output: "module a { }"},
-		{title: "ModuleDeclaration#2", input: `module a.b{}`, output: "module a.b { }"},
 		{title: "ModuleDeclaration#3", input: `module "a";`, output: "module \"a\";"},
 		{title: "ModuleDeclaration#4", input: `module "a"{}`, output: "module \"a\" { }"},
 		{title: "ModuleDeclaration#5", input: `namespace a{}`, output: "namespace a { }"},
diff --git a/testdata/baselines/reference/compiler/reachabilityChecks11.errors.txt b/testdata/baselines/reference/compiler/reachabilityChecks11.errors.txt
@@ -11,40 +11,40 @@ reachabilityChecks11.ts(69,5): error TS7027: Unreachable code detected.
     // while (true);
     var x = 1;
     
-    module A {
+    namespace A {
         while (true);
         let x;
         ~~~~~~
 !!! error TS7027: Unreachable code detected.
     }
     
-    module A1 {
+    namespace A1 {
         do {} while(true);
-        module A {
+        namespace A {
             interface F {}
         }
     }
     
-    module A2 {
+    namespace A2 {
         while (true);
-        module A {
-        ~~~~~~~~~~
+        namespace A {
+        ~~~~~~~~~~~~~
             var x = 1;
     ~~~~~~~~~~~~~~~~~~
         }
     ~~~~~
 !!! error TS7027: Unreachable code detected.
     }
     
-    module A3 {
+    namespace A3 {
         while (true);
         type T = string;
     }
     
-    module A4 {
+    namespace A4 {
         while (true);
-        module A {
-        ~~~~~~~~~~
+        namespace A {
+        ~~~~~~~~~~~~~
             const enum E { X }
     ~~~~~~~~~~~~~~~~~~~~~~~~~~
         }
@@ -73,9 +73,9 @@ reachabilityChecks11.ts(69,5): error TS7027: Unreachable code detected.
 !!! error TS7027: Unreachable code detected.
     }
     
-    module B {
+    namespace B {
         for (; ;);
-        module C {
+        namespace C {
         }
     }
     
diff --git a/testdata/baselines/reference/compiler/reachabilityChecks11.js b/testdata/baselines/reference/compiler/reachabilityChecks11.js
@@ -4,33 +4,33 @@
 // while (true);
 var x = 1;
 
-module A {
+namespace A {
     while (true);
     let x;
 }
 
-module A1 {
+namespace A1 {
     do {} while(true);
-    module A {
+    namespace A {
         interface F {}
     }
 }
 
-module A2 {
+namespace A2 {
     while (true);
-    module A {
+    namespace A {
         var x = 1;
     }
 }
 
-module A3 {
+namespace A3 {
     while (true);
     type T = string;
 }
 
-module A4 {
+namespace A4 {
     while (true);
-    module A {
+    namespace A {
         const enum E { X }
     }
 }
@@ -51,9 +51,9 @@ function f2() {
     }
 }
 
-module B {
+namespace B {
     for (; ;);
-    module C {
+    namespace C {
     }
 }
 
diff --git a/testdata/baselines/reference/compiler/reachabilityChecks11.symbols b/testdata/baselines/reference/compiler/reachabilityChecks11.symbols
@@ -5,55 +5,55 @@
 var x = 1;
 >x : Symbol(x, Decl(reachabilityChecks11.ts, 1, 3))
 
-module A {
+namespace A {
 >A : Symbol(A, Decl(reachabilityChecks11.ts, 1, 10))
 
     while (true);
     let x;
 >x : Symbol(x, Decl(reachabilityChecks11.ts, 5, 7))
 }
 
-module A1 {
+namespace A1 {
 >A1 : Symbol(A1, Decl(reachabilityChecks11.ts, 6, 1))
 
     do {} while(true);
-    module A {
+    namespace A {
 >A : Symbol(A, Decl(reachabilityChecks11.ts, 9, 22))
 
         interface F {}
->F : Symbol(F, Decl(reachabilityChecks11.ts, 10, 14))
+>F : Symbol(F, Decl(reachabilityChecks11.ts, 10, 17))
     }
 }
 
-module A2 {
+namespace A2 {
 >A2 : Symbol(A2, Decl(reachabilityChecks11.ts, 13, 1))
 
     while (true);
-    module A {
+    namespace A {
 >A : Symbol(A, Decl(reachabilityChecks11.ts, 16, 17))
 
         var x = 1;
 >x : Symbol(x, Decl(reachabilityChecks11.ts, 18, 11))
     }
 }
 
-module A3 {
+namespace A3 {
 >A3 : Symbol(A3, Decl(reachabilityChecks11.ts, 20, 1))
 
     while (true);
     type T = string;
 >T : Symbol(T, Decl(reachabilityChecks11.ts, 23, 17))
 }
 
-module A4 {
+namespace A4 {
 >A4 : Symbol(A4, Decl(reachabilityChecks11.ts, 25, 1))
 
     while (true);
-    module A {
+    namespace A {
 >A : Symbol(A, Decl(reachabilityChecks11.ts, 28, 17))
 
         const enum E { X }
->E : Symbol(E, Decl(reachabilityChecks11.ts, 29, 14))
+>E : Symbol(E, Decl(reachabilityChecks11.ts, 29, 17))
 >X : Symbol(E.X, Decl(reachabilityChecks11.ts, 30, 22))
     }
 }
@@ -84,11 +84,11 @@ function f2() {
     }
 }
 
-module B {
+namespace B {
 >B : Symbol(B, Decl(reachabilityChecks11.ts, 48, 1))
 
     for (; ;);
-    module C {
+    namespace C {
 >C : Symbol(C, Decl(reachabilityChecks11.ts, 51, 14))
     }
 }
diff --git a/testdata/baselines/reference/compiler/reachabilityChecks11.types b/testdata/baselines/reference/compiler/reachabilityChecks11.types
@@ -6,7 +6,7 @@ var x = 1;
 >x : number
 >1 : 1
 
-module A {
+namespace A {
 >A : typeof A
 
     while (true);
@@ -16,24 +16,24 @@ module A {
 >x : any
 }
 
-module A1 {
+namespace A1 {
 >A1 : typeof A1
 
     do {} while(true);
 >true : true
 
-    module A {
+    namespace A {
         interface F {}
     }
 }
 
-module A2 {
+namespace A2 {
 >A2 : typeof A2
 
     while (true);
 >true : true
 
-    module A {
+    namespace A {
 >A : typeof A
 
         var x = 1;
@@ -42,7 +42,7 @@ module A2 {
     }
 }
 
-module A3 {
+namespace A3 {
 >A3 : typeof A3
 
     while (true);
@@ -52,13 +52,13 @@ module A3 {
 >T : string
 }
 
-module A4 {
+namespace A4 {
 >A4 : typeof A4
 
     while (true);
 >true : true
 
-    module A {
+    namespace A {
         const enum E { X }
 >E : E
 >X : E.X
@@ -93,11 +93,11 @@ function f2() {
     }
 }
 
-module B {
+namespace B {
 >B : typeof B
 
     for (; ;);
-    module C {
+    namespace C {
     }
 }
 
diff --git a/testdata/baselines/reference/submodule/compiler/escapedIdentifiers.errors.txt b/testdata/baselines/reference/submodule/compiler/escapedIdentifiers.errors.txt
@@ -1,8 +1,9 @@
+escapedIdentifiers.ts(25,16): error TS1540: A 'namespace' declaration should not be declared using the 'module' keyword. Please use the 'namespace' keyword instead.
 escapedIdentifiers.ts(37,12): error TS2564: Property 'foo1' has no initializer and is not definitely assigned in the constructor.
 escapedIdentifiers.ts(40,12): error TS2564: Property 'foo2' has no initializer and is not definitely assigned in the constructor.
 
 
-==== escapedIdentifiers.ts (2 errors) ====
+==== escapedIdentifiers.ts (3 errors) ====
     /*
         0 .. \u0030
         9 .. \u0039
@@ -28,6 +29,8 @@ escapedIdentifiers.ts(40,12): error TS2564: Property 'foo2' has no initializer a
         export var baz1: number;
     }
     declare module moduleType\u0032 { 
+                   ~~~~~~~~~~~~~~~~
+!!! error TS1540: A 'namespace' declaration should not be declared using the 'module' keyword. Please use the 'namespace' keyword instead.
         export var baz2: number;
     }
     
diff --git a/testdata/baselines/reference/submodule/compiler/escapedIdentifiers.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/escapedIdentifiers.errors.txt.diff
diff --git a/testdata/baselines/reference/submodule/compiler/moduleKeywordDeprecated.errors.txt b/testdata/baselines/reference/submodule/compiler/moduleKeywordDeprecated.errors.txt
diff --git a/testdata/baselines/reference/submodule/compiler/moduleKeywordDeprecated.errors.txt.diff b/testdata/baselines/reference/submodule/compiler/moduleKeywordDeprecated.errors.txt.diff
diff --git a/testdata/tests/cases/compiler/reachabilityChecks11.ts b/testdata/tests/cases/compiler/reachabilityChecks11.ts

Original file line number	Diff line number	Diff line change
`@@ -5013,10 +5013,6 @@ func (c Checker) checkModuleDeclaration(node ast.Node) {`
`5013`	`5013`	`}`
`5014`	`5014`	`if ast.IsIdentifier(node.Name()) {`
`5015`	`5015`	`c.checkCollisionsForDeclarationName(node, node.Name())`
`5016`		`- if node.AsModuleDeclaration().Keyword == ast.KindModuleKeyword {`
`5017`		`- tokenRange := getNonModifierTokenRangeOfNode(node)`
`5018`		`- c.suggestionDiagnostics.Add(ast.NewDiagnostic(ast.GetSourceFileOfNode(node), tokenRange, diagnostics.A_namespace_declaration_should_not_be_declared_using_the_module_keyword_Please_use_the_namespace_keyword_instead))`
`5019`		`- }`
`5020`	`5016`	`}`
`5021`	`5017`	`c.checkExportsOnMergedDeclarations(node)`
`5022`	`5018`	`symbol := c.getSymbolOfDeclaration(node)`
Original file line number	Diff line number	Diff line change
`@@ -4,33 +4,33 @@`
`4`	`4`	`// while (true);`
`5`	`5`	`var x = 1;`
`6`	`6`
`7`		`-module A {`
	`7`	`+namespace A {`
`8`	`8`	`while (true);`
`9`	`9`	`let x;`
`10`	`10`	`}`
`11`	`11`
`12`		`-module A1 {`
	`12`	`+namespace A1 {`
`13`	`13`	`do {} while(true);`
`14`		`- module A {`
	`14`	`+ namespace A {`
`15`	`15`	`interface F {}`
`16`	`16`	`}`
`17`	`17`	`}`
`18`	`18`
`19`		`-module A2 {`
	`19`	`+namespace A2 {`
`20`	`20`	`while (true);`
`21`		`- module A {`
	`21`	`+ namespace A {`
`22`	`22`	`var x = 1;`
`23`	`23`	`}`
`24`	`24`	`}`
`25`	`25`
`26`		`-module A3 {`
	`26`	`+namespace A3 {`
`27`	`27`	`while (true);`
`28`	`28`	`type T = string;`
`29`	`29`	`}`
`30`	`30`
`31`		`-module A4 {`
	`31`	`+namespace A4 {`
`32`	`32`	`while (true);`
`33`		`- module A {`
	`33`	`+ namespace A {`
`34`	`34`	`const enum E { X }`
`35`	`35`	`}`
`36`	`36`	`}`
`@@ -51,9 +51,9 @@ function f2() {`
`51`	`51`	`}`
`52`	`52`	`}`
`53`	`53`
`54`		`-module B {`
	`54`	`+namespace B {`
`55`	`55`	`for (; ;);`
`56`		`- module C {`
	`56`	`+ namespace C {`
`57`	`57`	`}`
`58`	`58`	`}`
`59`	`59`
Original file line number	Diff line number	Diff line change
`@@ -5,55 +5,55 @@`
`5`	`5`	`var x = 1;`
`6`	`6`	`>x : Symbol(x, Decl(reachabilityChecks11.ts, 1, 3))`
`7`	`7`
`8`		`-module A {`
	`8`	`+namespace A {`
`9`	`9`	`>A : Symbol(A, Decl(reachabilityChecks11.ts, 1, 10))`
`10`	`10`
`11`	`11`	`while (true);`
`12`	`12`	`let x;`
`13`	`13`	`>x : Symbol(x, Decl(reachabilityChecks11.ts, 5, 7))`
`14`	`14`	`}`
`15`	`15`
`16`		`-module A1 {`
	`16`	`+namespace A1 {`
`17`	`17`	`>A1 : Symbol(A1, Decl(reachabilityChecks11.ts, 6, 1))`
`18`	`18`
`19`	`19`	`do {} while(true);`
`20`		`- module A {`
	`20`	`+ namespace A {`
`21`	`21`	`>A : Symbol(A, Decl(reachabilityChecks11.ts, 9, 22))`
`22`	`22`
`23`	`23`	`interface F {}`
`24`		`->F : Symbol(F, Decl(reachabilityChecks11.ts, 10, 14))`
	`24`	`+>F : Symbol(F, Decl(reachabilityChecks11.ts, 10, 17))`
`25`	`25`	`}`
`26`	`26`	`}`
`27`	`27`
`28`		`-module A2 {`
	`28`	`+namespace A2 {`
`29`	`29`	`>A2 : Symbol(A2, Decl(reachabilityChecks11.ts, 13, 1))`
`30`	`30`
`31`	`31`	`while (true);`
`32`		`- module A {`
	`32`	`+ namespace A {`
`33`	`33`	`>A : Symbol(A, Decl(reachabilityChecks11.ts, 16, 17))`
`34`	`34`
`35`	`35`	`var x = 1;`
`36`	`36`	`>x : Symbol(x, Decl(reachabilityChecks11.ts, 18, 11))`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`-module A3 {`
	`40`	`+namespace A3 {`
`41`	`41`	`>A3 : Symbol(A3, Decl(reachabilityChecks11.ts, 20, 1))`
`42`	`42`
`43`	`43`	`while (true);`
`44`	`44`	`type T = string;`
`45`	`45`	`>T : Symbol(T, Decl(reachabilityChecks11.ts, 23, 17))`
`46`	`46`	`}`
`47`	`47`
`48`		`-module A4 {`
	`48`	`+namespace A4 {`
`49`	`49`	`>A4 : Symbol(A4, Decl(reachabilityChecks11.ts, 25, 1))`
`50`	`50`
`51`	`51`	`while (true);`
`52`		`- module A {`
	`52`	`+ namespace A {`
`53`	`53`	`>A : Symbol(A, Decl(reachabilityChecks11.ts, 28, 17))`
`54`	`54`
`55`	`55`	`const enum E { X }`
`56`		`->E : Symbol(E, Decl(reachabilityChecks11.ts, 29, 14))`
	`56`	`+>E : Symbol(E, Decl(reachabilityChecks11.ts, 29, 17))`
`57`	`57`	`>X : Symbol(E.X, Decl(reachabilityChecks11.ts, 30, 22))`
`58`	`58`	`}`
`59`	`59`	`}`
`@@ -84,11 +84,11 @@ function f2() {`
`84`	`84`	`}`
`85`	`85`	`}`
`86`	`86`
`87`		`-module B {`
	`87`	`+namespace B {`
`88`	`88`	`>B : Symbol(B, Decl(reachabilityChecks11.ts, 48, 1))`
`89`	`89`
`90`	`90`	`for (; ;);`
`91`		`- module C {`
	`91`	`+ namespace C {`
`92`	`92`	`>C : Symbol(C, Decl(reachabilityChecks11.ts, 51, 14))`
`93`	`93`	`}`
`94`	`94`	`}`