Fix namespace in blockless namespace with same name

.chronus/changes/fix-namespace-in-blockless-2024-6-30-10-29-59.md

@@ -0,0 +1,14 @@
+---
+changeKind: fix
+packages:
+  - "@typespec/compiler"
+---
+
+Allow using compact namespace form `Foo.Bar` when inside another namespace
+  ```tsp
+  namespace MyOrg.MyProject {
+    namespace MyModule.MySubmodule { // <-- this used to emit an error
+      // ...
+    }
+  }
+  ```

.chronus/changes/fix-namespace-in-blockless-2024-6-30-10-31-17.md

@@ -0,0 +1,33 @@
+---
+changeKind: breaking
+packages:
+  - "@typespec/compiler"
+---
+
+Fix issue where naming a namespace with the same name as the blockless namespace would merge with it instead of creating a subnamespace like any other name would.
+
+  ```tsp
+  namespace MyOrg.MyProject;
+
+  namespace MyOrg.MyProject.MyArea {
+    model A {}
+  }
+
+  namespace MyArea2 {
+    model B {}
+  }
+  ```
+
+  Previously model `A` would end-up in namespace `MyOrg.MyProject.MyArea` and model `B` in `MyOrg.MyProject.MyArea2`. With this change model `A` will now be in `MyOrg.MyProject.MyOrg.MyProject.MyArea`. To achieve the previous behavior the above code should be written as:
+
+  ```tsp
+  namespace MyOrg.MyProject;
+
+  namespace MyArea {
+    model A {}
+  }
+
+  namespace MyArea2 {
+    model B {}
+  }
+  ```

packages/compiler/src/core/binder.ts

@@ -490,8 +490,9 @@ export function createBinder(program: Program): Binder {
   }
 
   function bindNamespaceStatement(statement: NamespaceStatementNode) {
+    const effectiveScope = fileNamespace ?? scope;
     // check if there's an existing symbol for this namespace
-    const existingBinding = (scope as NamespaceStatementNode).symbol.exports!.get(statement.id.sv);
+    const existingBinding = effectiveScope.symbol.exports!.get(statement.id.sv);
     if (existingBinding && existingBinding.flags & SymbolFlags.Namespace) {
       mutate(statement).symbol = existingBinding;
       // locals are never shared.

packages/compiler/src/core/parser.ts

@@ -582,7 +582,7 @@ function createParser(code: string | SourceFile, options: ParseOptions = {}): Pa
         case Token.NamespaceKeyword:
           const ns = parseNamespaceStatement(pos, decorators, docs, directives);
 
-          if (!Array.isArray(ns.statements)) {
+          if (isBlocklessNamespace(ns)) {
             error({ code: "blockless-namespace-first", messageId: "topLevel", target: ns });
           }
           item = ns;

packages/compiler/test/binder.test.ts

@@ -60,6 +60,44 @@ describe("compiler: binder", () => {
       },
     });
   });
+
+  it("namespace inside blockless namespace with the same name", () => {
+    const code = `
+      namespace A.B;
+      namespace A.B {
+        model D { }
+      }
+    `;
+    const script = bindTypeSpec(code);
+    strictEqual(script.namespaces.length, 4);
+    assertBindings("root", script.symbol.exports!, {
+      A: {
+        declarations: [SyntaxKind.NamespaceStatement],
+        flags: SymbolFlags.Namespace,
+        exports: {
+          B: {
+            flags: SymbolFlags.Namespace,
+            exports: {
+              A: {
+                declarations: [SyntaxKind.NamespaceStatement],
+                flags: SymbolFlags.Namespace,
+                exports: {
+                  B: {
+                    flags: SymbolFlags.Namespace,
+                    exports: {
+                      D: {
+                        flags: SymbolFlags.Model,
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+  });
   it("binds namespaces", () => {
     const code = `
       namespace A {