Diagnose for invalid decl nesting + namespace lookup fixes. (#3397)

* Diagnose for invalid decl nesting.

* Fix.

* Fix.

* Fix.

* Fix `namespace` lookup and `using` resolution.

* fix project files.

* revert project files.

* Enhance namespace syntax, docs.

* Fixes.

---------

Co-authored-by: Yong He <yhe@nvidia.com>

12 files changed, 628 insertions, 144 deletions

diff --git a/source/slang/slang-ast-iterator.h b/source/slang/slang-ast-iterator.h
index dbf9bc8fc..7dc358a8e 100644
--- a/source/slang/slang-ast-iterator.h
+++ b/source/slang/slang-ast-iterator.h
@@ -432,7 +432,7 @@ template <typename CallbackFunc>
 void ASTIterator<CallbackFunc>::visitDecl(DeclBase* decl)
 {
     // Don't look at the decl if it is defined in a different file.
-    if (!as<ModuleDecl>(decl) && !sourceManager->getHumaneLoc(decl->loc, SourceLocType::Actual)
+    if (!as<NamespaceDeclBase>(decl) && !sourceManager->getHumaneLoc(decl->loc, SourceLocType::Actual)
                                       .pathInfo.foundPath.getUnownedSlice()
                                       .endsWithCaseInsensitive(fileName))
         return;
@@ -468,6 +468,10 @@ void ASTIterator<CallbackFunc>::visitDecl(DeclBase* decl)
     {
         visitExpr(extDecl->targetType.exp);
     }
+    else if (auto usingDecl = as<UsingDecl>(decl))
+    {
+        visitExpr(usingDecl->arg);
+    }
     if (auto container = as<ContainerDecl>(decl))
     {
         for (auto member : container->members)
diff --git a/source/slang/slang-ast-support-types.h b/source/slang/slang-ast-support-types.h
index f771e24b6..955aff06c 100644
--- a/source/slang/slang-ast-support-types.h
+++ b/source/slang/slang-ast-support-types.h
@@ -65,6 +65,7 @@ namespace Slang
     void printDiagnosticArg(StringBuilder& sb, QualType const& type);
     void printDiagnosticArg(StringBuilder& sb, Val* val);
     void printDiagnosticArg(StringBuilder& sb, DeclRefBase* declRefBase);
+    void printDiagnosticArg(StringBuilder& sb, ASTNodeType nodeType);
 
     struct QualifiedDeclPath
     {
@@ -391,6 +392,10 @@ namespace Slang
             ///
         ModifiersChecked,
 
+            /// Wiring up scopes of namespaces with their siblings defined in different
+            /// files/modules, and other namespaces imported via `using`.
+        ScopesWired,
+
             /// The type/signature of the declaration has been checked.
             ///
             /// For a value declaration like a variable or function, this means that
diff --git a/source/slang/slang-check-decl.cpp b/source/slang/slang-check-decl.cpp
index 396fdd297..75aed010d 100644
--- a/source/slang/slang-check-decl.cpp
+++ b/source/slang/slang-check-decl.cpp
@@ -36,6 +36,23 @@ namespace Slang
         }
     };
 
+    struct SemanticsDeclScopeWiringVisitor : public SemanticsDeclVisitorBase, public DeclVisitor<SemanticsDeclScopeWiringVisitor>
+    {
+        SemanticsDeclScopeWiringVisitor(SemanticsContext const& outer)
+            : SemanticsDeclVisitorBase(outer)
+        {}
+
+        void visitDeclGroup(DeclGroup*) {}
+
+        void visitDecl(Decl*) {}
+
+        void visitUsingDecl(UsingDecl* decl);
+
+        void visitImplementingDecl(ImplementingDecl* decl);
+
+        void visitNamespaceDecl(NamespaceDecl* decl);
+    };
+
     struct SemanticsDeclAttributesVisitor
         : public SemanticsDeclVisitorBase
         , public DeclVisitor<SemanticsDeclAttributesVisitor>
@@ -87,10 +104,6 @@ namespace Slang
 
         void visitIncludeDecl(IncludeDecl* decl);
 
-        void visitImplementingDecl(ImplementingDecl* decl);
-
-        void visitUsingDecl(UsingDecl* decl);
-
         void visitGenericTypeParamDecl(GenericTypeParamDecl* decl);
 
         void visitGenericValueParamDecl(GenericValueParamDecl* decl);
@@ -1864,6 +1877,10 @@ namespace Slang
                     {
                         ensureDecl(implementingDecl, DeclCheckState::Checked);
                     }
+                    else if (auto importDecl = as<ImportDecl>(decl))
+                    {
+                        ensureDecl(importDecl, DeclCheckState::Checked);
+                    }
                 }
             };
         visitIncludeDecls(moduleDecl);
@@ -1927,7 +1944,7 @@ namespace Slang
         //
         DeclCheckState states[] =
         {
-            DeclCheckState::ModifiersChecked,
+            DeclCheckState::ScopesWired,
             DeclCheckState::ReadyForReference,
             DeclCheckState::ReadyForLookup,
             DeclCheckState::ReadyForConformances,
@@ -6831,14 +6848,9 @@ namespace Slang
     {
         // Create a new sub-scope to wire the module
         // into our lookup chain.
-        auto subScope = getASTBuilder()->create<Scope>();
-        subScope->containerDecl = fileDecl;
-
-        subScope->nextSibling = scope->nextSibling;
-        scope->nextSibling = subScope;
+        addSiblingScopeForContainerDecl(scope, fileDecl);
     }
 
-
     void SemanticsVisitor::importModuleIntoScope(Scope* scope, ModuleDecl* moduleDecl)
     {
         // If we've imported this one already, then
@@ -6859,11 +6871,7 @@ namespace Slang
             if (moduleScope->containerDecl != moduleDecl && moduleScope->containerDecl->parentDecl != moduleDecl)
                 continue;
 
-            auto subScope = getASTBuilder()->create<Scope>();
-            subScope->containerDecl = moduleScope->containerDecl;
-
-            subScope->nextSibling = scope->nextSibling;
-            scope->nextSibling = subScope;
+            addSiblingScopeForContainerDecl(scope, moduleScope->containerDecl);
         }
 
         // Also import any modules from nested `import` declarations
@@ -7014,7 +7022,7 @@ namespace Slang
         getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::includedFileMissingImplementing, name);
     }
 
-    void SemanticsDeclHeaderVisitor::visitImplementingDecl(ImplementingDecl* decl)
+    void SemanticsDeclScopeWiringVisitor::visitImplementingDecl(ImplementingDecl* decl)
     {
         // Don't need to do anything unless we are in a language server context.
         if (!getShared()->isInLanguageServer())
@@ -7044,10 +7052,8 @@ namespace Slang
         if (auto moduleDeclaration = as<ModuleDeclarationDecl>(firstMember))
         {
             // We are trying to implement a file that defines a module, this is expected.
-            return;
         }
-
-        if (auto implementing = as<ImplementingDecl>(firstMember))
+        else if (auto implementing = as<ImplementingDecl>(firstMember))
         {
             getSink()->diagnose(decl->moduleNameAndLoc.loc, Diagnostics::implementingMustReferencePrimaryModuleFile);
             return;
@@ -7057,7 +7063,7 @@ namespace Slang
             importFileDeclIntoScope(moduleDecl->ownedScope, fileDecl);
     }
 
-    void SemanticsDeclHeaderVisitor::visitUsingDecl(UsingDecl* decl)
+    void SemanticsDeclScopeWiringVisitor::visitUsingDecl(UsingDecl* decl)
     {
         // First, we need to look up whatever the argument of the `using`
         // declaration names.
@@ -7067,45 +7073,98 @@ namespace Slang
         // Next, we want to ensure that whatever is being named by `decl->arg`
         // is a namespace (or a module, since modules are namespace-like).
         //
-        // TODO: The logic here assumes that we can't have multiple `NamespaceDecl`s
-        // with the same name in scope, but that assumption is only valid in the
-        // context of a single module (where we deduplicate `namespace`s during
-        // parsing). If a user `import`s multiple modules that all have namespaces
+        // If a user `import`s multiple modules that all have namespaces
         // of the same name, it would be possible for `decl->arg` to be overloaded.
-        // In that case we should really iterate over all the entities that are
+        // To handle that case, we will iterate over all the entities that are
         // named and import any that are namespace-like.
         //
-        NamespaceDeclBase* namespaceDecl = nullptr;
-        if( auto declRefExpr = as<DeclRefExpr>(decl->arg) )
+        bool scopesAdded = false;
+        bool hasValidNamespace = false;
+
+        // TODO: consider caching the scope set in NamespaceDecl.
+        HashSet<ContainerDecl*> addedScopes;
+        for (auto s = decl->scope; s; s = s->nextSibling)
+            addedScopes.add(s->containerDecl);
+
+        auto addAllSiblingScopesFromDecl = [&](Scope* scope, ContainerDecl* containerDecl)
+            {
+                for (auto s = containerDecl->ownedScope; s; s = s->nextSibling)
+                {
+                    if (addedScopes.add(s->containerDecl))
+                    {
+                        scopesAdded = true;
+                        addSiblingScopeForContainerDecl(scope, s->containerDecl);
+                    }
+                }
+            };
+
+        if (auto declRefExpr = as<DeclRefExpr>(decl->arg))
+        {
+            if (auto namespaceDeclRef = declRefExpr->declRef.as<NamespaceDeclBase>())
+            {
+                auto namespaceDecl = namespaceDeclRef.getDecl();
+                addAllSiblingScopesFromDecl(decl->scope, namespaceDecl);
+                hasValidNamespace = true;
+            }
+        }
+        else if (auto overloadedExpr = as<OverloadedExpr>(decl->arg))
         {
-            if( auto namespaceDeclRef = declRefExpr->declRef.as<NamespaceDeclBase>() )
+            for (auto item : overloadedExpr->lookupResult2)
             {
-                namespaceDecl = namespaceDeclRef.getDecl();
+                if (auto namespaceDeclRef = item.declRef.as<NamespaceDeclBase>())
+                {
+                    addAllSiblingScopesFromDecl(decl->scope, namespaceDeclRef.getDecl());
+                    hasValidNamespace = true;
+                }
             }
         }
-        if( !namespaceDecl )
+
+        if (!scopesAdded)
         {
-            getSink()->diagnose(decl->arg, Diagnostics::expectedANamespace, decl->arg->type);
+            if (!hasValidNamespace)
+                getSink()->diagnose(decl->arg, Diagnostics::expectedANamespace, decl->arg->type);
             return;
         }
+    }
 
-        // Once we have identified the namespace to bring into scope,
-        // we need to create a new sibling sub-scope to add to the
-        // lookup scope that was in place when the `using` was parsed.
-        //
-        // Subsequent lookup in that scope will walk through our new
-        // sub-scope and see the namespace.
-        //
-        // TODO: If we update the `containerDecl` in a scope to allow
-        // for a more general `DeclRef`, or even a full `DeclRefExpr`,
-        // then it would be possible for `using` to apply to more kinds
-        // of entities than just namespaces.
-        //
-        auto scope = decl->scope;
-        auto subScope = getASTBuilder()->create<Scope>();
-        subScope->containerDecl = namespaceDecl;
-        subScope->nextSibling = scope->nextSibling;
-        scope->nextSibling = subScope;
+    void SemanticsDeclScopeWiringVisitor::visitNamespaceDecl(NamespaceDecl* decl)
+    {
+        // We need to wire up the scope of namespaces with other namespace decls of the same name
+        // that is accessible from the current context.
+        auto parent = as<ContainerDecl>(getParentDecl(decl));
+        if (!parent)
+            return;
+        for (auto parentScope = parent->ownedScope; parentScope; parentScope = parentScope->parent)
+        {
+            for (auto scope = parentScope; scope; scope = scope->nextSibling)
+            {
+                auto container = scope->containerDecl;
+                auto nsDeclPtr = container->getMemberDictionary().tryGetValue(decl->getName());
+                if (!nsDeclPtr) continue;
+                auto nsDecl = *nsDeclPtr;
+                for (auto ns = nsDecl; ns; ns = ns->nextInContainerWithSameName)
+                {
+                    if (ns == decl)
+                        continue;
+                    auto otherNamespace = as<NamespaceDeclBase>(ns);
+                    if (!otherNamespace)
+                        continue;
+
+                    if (!ns->checkState.isBeingChecked())
+                    {
+                        ensureDecl(ns, DeclCheckState::ScopesWired);
+                    }
+                    addSiblingScopeForContainerDecl(decl, otherNamespace);
+                }
+            }
+            // For file decls, we need to continue searching up in the parent module scope.
+            if (!as<FileDecl>(parentScope->containerDecl))
+                break;
+        }
+        for (auto usingDecl : decl->getMembersOfType<UsingDecl>())
+        {
+            ensureDecl(usingDecl, DeclCheckState::ScopesWired);
+        }
     }
 
         /// Get a reference to the candidate extension list for `typeDecl` in the given dictionary
@@ -7470,6 +7529,9 @@ namespace Slang
         case DeclCheckState::ModifiersChecked:
             SemanticsDeclModifiersVisitor(shared).dispatch(decl);
             break;
+        case DeclCheckState::ScopesWired:
+            SemanticsDeclScopeWiringVisitor(shared).dispatch(decl);
+            break;
 
         case DeclCheckState::SignatureChecked:
             SemanticsDeclHeaderVisitor(shared).dispatch(decl);
diff --git a/source/slang/slang-check-expr.cpp b/source/slang/slang-check-expr.cpp
index 9d1898cf5..753f14768 100644
--- a/source/slang/slang-check-expr.cpp
+++ b/source/slang/slang-check-expr.cpp
@@ -248,6 +248,20 @@ namespace Slang
         return SourceLoc();
     }
 
+    void SemanticsVisitor::addSiblingScopeForContainerDecl(ContainerDecl* dest, ContainerDecl* source)
+    {
+        addSiblingScopeForContainerDecl(dest->ownedScope, source);
+    }
+
+    void SemanticsVisitor::addSiblingScopeForContainerDecl(Scope* destScope, ContainerDecl* source)
+    {
+        auto subScope = getASTBuilder()->create<Scope>();
+        subScope->containerDecl = source;
+
+        subScope->nextSibling = destScope->nextSibling;
+        destScope->nextSibling = subScope;
+    }
+
     void SemanticsVisitor::diagnoseDeprecatedDeclRefUsage(
         DeclRef<Decl> declRef,
         SourceLoc loc,
@@ -847,7 +861,10 @@ namespace Slang
         {
             return getDeclVisibility(interfaceDecl);
         }
-
+        else if (as<NamespaceDecl>(decl))
+        {
+            return DeclVisibility::Public;
+        }
         if (auto parentModule = getModuleDecl(decl))
             return parentModule->isInLegacyLanguage ? DeclVisibility::Public : DeclVisibility::Internal;
 
@@ -3541,6 +3558,11 @@ namespace Slang
         LookupResult globalLookupResult;
         bool hasErrors = false;
         Expr* base = nullptr;
+
+        // Keep track of namespace scopes we've already looked up in to avoid producing
+        // duplicates.
+        HashSet<ContainerDecl*> processedNamespaceScopes;
+
         auto handleLeafCase = [&](DeclRef<Decl> baseDeclRef, Type* type)
             {
                 auto aggTypeDeclRef = as<AggTypeDeclBase>(baseDeclRef);
@@ -3549,18 +3571,44 @@ namespace Slang
                 {
                     // We are looking up a namespace member.
                     //
-                    // This ought to be the easy case, because
-                    // there are no restrictions on whether
-                    // we can reference the declaration here.
+                    // We should lookup in all sibling scopes of the namespace.
+                    // Another detail here is that we need to skip scopes that are transitively imported.
+                    // For example, given:
+                    // ```
+                    //     module a;
+                    //     namespace ns { int f_a(); }
+                    // 
+                    //     module b;
+                    //     namespace ns { int f_b(); } // will have a sibling scope that refers to a::ns.
+                    // 
+                    //     module c;
+                    //     import b;
+                    //     void test() {ns.f_a(); // should not be valid, because c does not import a. }
+                    // ```
+                    // Note that this logic doesn't work nicely with __exported import, but we should consider
+                    // deprecate this feature anyway.
                     //
-                    LookupResult nsLookupResult = lookUpDirectAndTransparentMembers(
-                        m_astBuilder,
-                        this,
-                        expr->name,
-                        namespaceDeclRef.getDecl(),
-                        namespaceDeclRef);
-                    AddToLookupResult(globalLookupResult, nsLookupResult);
+                    auto namespaceModule = getModuleDecl(namespaceDeclRef.getDecl());
+                    auto thisModule = m_outerScope ? getModuleDecl(m_outerScope->containerDecl) : namespaceModule;
 
+                    for (auto scope = namespaceDeclRef.getDecl()->ownedScope; scope; scope = scope->nextSibling)
+                    {
+                        auto namespaceDecl = as<NamespaceDeclBase>(scope->containerDecl);
+                        if (!namespaceDecl)
+                            continue;
+                        if (thisModule != namespaceModule && namespaceModule != getModuleDecl(namespaceDecl))
+                            continue;
+                        if (processedNamespaceScopes.add(scope->containerDecl))
+                        {
+                            LookupResult nsLookupResult = lookUpDirectAndTransparentMembers(
+                                m_astBuilder,
+                                this,
+                                expr->name,
+                                namespaceDecl,
+                                DeclRef(namespaceDecl));
+                            AddToLookupResult(globalLookupResult, nsLookupResult);
+                        }
+                    }
                 }
                 else if (aggTypeDeclRef || type)
                 {
diff --git a/source/slang/slang-check-impl.h b/source/slang/slang-check-impl.h
index 43844cf70..4102b3eba 100644
--- a/source/slang/slang-check-impl.h
+++ b/source/slang/slang-check-impl.h
@@ -1048,6 +1048,11 @@ namespace Slang
 
         Scope* getScope(SyntaxNode* node);
 
+        // Add a sibling lookup scope for `dest` to refer to `source`.
+        void addSiblingScopeForContainerDecl(ContainerDecl* dest, ContainerDecl* source);
+        void addSiblingScopeForContainerDecl(Scope* destScope, ContainerDecl* source);
+
+
         void diagnoseDeprecatedDeclRefUsage(DeclRef<Decl> declRef, SourceLoc loc, Expr* originalExpr);
 
         DeclRef<Decl> getDefaultDeclRef(Decl* decl)
diff --git a/source/slang/slang-check-modifier.cpp b/source/slang/slang-check-modifier.cpp
index 339ecba4c..20a393ff5 100644
--- a/source/slang/slang-check-modifier.cpp
+++ b/source/slang/slang-check-modifier.cpp
@@ -1044,9 +1044,18 @@ namespace Slang
 
         if (as<PrivateModifier>(m))
         {
-            if (as<AggTypeDeclBase>(syntaxNode) || as<NamespaceDeclBase>(syntaxNode))
+            if (auto decl = as<Decl>(syntaxNode))
             {
-                getSink()->diagnose(m, Diagnostics::invalidUseOfPrivateVisibility, as<Decl>(syntaxNode));
+                if (isGlobalDecl(decl))
+                {
+                    getSink()->diagnose(m, Diagnostics::invalidUseOfPrivateVisibility, as<Decl>(syntaxNode));
+                    return m;
+                }
+            }
+            if (as<NamespaceDeclBase>(syntaxNode))
+            {
+                getSink()->diagnose(m, Diagnostics::invalidVisibilityModifierOnTypeOfDecl, syntaxNode->astNodeType);
+                return m;
             }
             else if (auto decl = as<Decl>(syntaxNode))
             {
@@ -1057,7 +1066,14 @@ namespace Slang
                 }
             }
         }
-
+        else if (as<InternalModifier>(m))
+        {
+            if (as<NamespaceDeclBase>(syntaxNode))
+            {
+                getSink()->diagnose(m, Diagnostics::invalidVisibilityModifierOnTypeOfDecl, syntaxNode->astNodeType);
+                return m;
+            }
+        }
 
         // Default behavior is to leave things as they are,
         // and assume that modifiers are mostly already checked.
diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h
index ac3220f4b..5f28e2af2 100644
--- a/source/slang/slang-diagnostic-defs.h
+++ b/source/slang/slang-diagnostic-defs.h
@@ -240,6 +240,8 @@ DIAGNOSTIC(20015, Error, unknownSPIRVCapability, "unknown SPIR-V capability '$0'
 
 DIAGNOSTIC(20101, Warning, unintendedEmptyStatement, "potentially unintended empty statement at this location; use {} instead.")
 
+DIAGNOSTIC(30102, Error, declNotAllowed, "$0 is not allowed here.")
+
 // 29xxx - Snippet parsing and inline asm
 DIAGNOSTIC(29000, Error, snippetParsingFailed, "unable to parse target intrinsic snippet: $0")
 
@@ -361,8 +363,9 @@ DIAGNOSTIC(30505, Error, implementingMustReferencePrimaryModuleFile, "the source
 DIAGNOSTIC(30600, Error, declIsNotVisible, "'$0' is not accessible from the current context.")
 DIAGNOSTIC(30601, Error, declCannotHaveHigherVisibility, "'$0' cannot have a higher visibility than '$1'.")
 DIAGNOSTIC(30602, Error, satisfyingDeclCannotHaveLowerVisibility, "'$0' is less visible than the interface requirement it satisfies.")
-DIAGNOSTIC(30603, Error, invalidUseOfPrivateVisibility, "'$0' cannot have private visibility.")
+DIAGNOSTIC(30603, Error, invalidUseOfPrivateVisibility, "'$0' cannot have private visibility because it is not a member of a type.")
 DIAGNOSTIC(30604, Error, useOfLessVisibleType, "'$0' references less visible type '$1'.")
+DIAGNOSTIC(36005, Error, invalidVisibilityModifierOnTypeOfDecl, "visibility modifier is not allowed on '$0'.")
 
 // Attributes
 DIAGNOSTIC(31000, Error, unknownAttributeName, "unknown attribute '$0'")
diff --git a/source/slang/slang-language-server-ast-lookup.cpp b/source/slang/slang-language-server-ast-lookup.cpp
index 3aa66ee02..0e8520f3a 100644
--- a/source/slang/slang-language-server-ast-lookup.cpp
+++ b/source/slang/slang-language-server-ast-lookup.cpp
@@ -669,6 +669,12 @@ bool _findAstNodeImpl(ASTLookupContext& context, SyntaxNode* node)
             if (visitor.dispatchIfNotNull(extDecl->targetType.exp))
                 return true;
         }
+        else if (auto usingDecl = as<UsingDecl>(node))
+        {
+            ASTLookupExprVisitor visitor(&context);
+            if (visitor.dispatchIfNotNull(usingDecl->arg))
+                return true;
+        }
         else if (auto importDecl = as<FileReferenceDeclBase>(node))
         {
             if (_isLocInRange(&context, importDecl->startLoc, importDecl->endLoc))
diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp
index f0fd33e13..146f54932 100644
--- a/source/slang/slang-lower-to-ir.cpp
+++ b/source/slang/slang-lower-to-ir.cpp
@@ -2267,6 +2267,10 @@ static String getNameForNameHint(
     if(auto genericParentDecl = as<GenericDecl>(parentDecl))
         parentDecl = genericParentDecl->parentDecl;
 
+    // Skip past a FileDecl parent.
+    if (auto fileParentDecl = as<FileDecl>(parentDecl))
+        parentDecl = fileParentDecl->parentDecl;
+
     // A `ModuleDecl` can have a name too, but in the common case
     // we don't want to generate name hints that include the module
     // name, simply because they would lead to every global symbol
@@ -10148,6 +10152,13 @@ static void ensureAllDeclsRec(
             ensureAllDeclsRec(context, memberDecl);
         }
     }
+    else if (auto fileDecl = as<FileDecl>(decl))
+    {
+        for (auto memberDecl : fileDecl->members)
+        {
+            ensureAllDeclsRec(context, memberDecl);
+        }
+    }
     else if (auto genericDecl = as<GenericDecl>(decl))
     {
         ensureAllDeclsRec(context, genericDecl->inner);
diff --git a/source/slang/slang-mangle.cpp b/source/slang/slang-mangle.cpp
index 3111ab132..3f701f385 100644
--- a/source/slang/slang-mangle.cpp
+++ b/source/slang/slang-mangle.cpp
@@ -40,7 +40,6 @@ namespace Slang
     void emitNameImpl(ManglingContext* context, UnownedStringSlice str)
     {
         Index length = str.getLength();
-
         // If the name consists of only traditional "identifer characters"
         // (`[a-zA-Z_]`), then we want to emit it more or less directly.
         //
@@ -360,6 +359,9 @@ namespace Slang
         DeclRef<Decl>       declRef)
     {
         auto parentDeclRef = declRef.getParent();
+        if (as<FileDecl>(parentDeclRef))
+            parentDeclRef = parentDeclRef.getParent();
+
         auto parentGenericDeclRef = parentDeclRef.as<GenericDecl>();
         if( parentDeclRef )
         {
diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp
index 7367007e6..9914612ac 100644
--- a/source/slang/slang-parser.cpp
+++ b/source/slang/slang-parser.cpp
@@ -83,6 +83,7 @@ namespace Slang
     {
         bool enableEffectAnnotations = false;
         bool allowGLSLInput = false;
+        bool isInLanguageServer = false;
     };
 
     // TODO: implement two pass parsing for file reference and struct type recognition
@@ -3294,8 +3295,7 @@ namespace Slang
     {
         // We start by parsing the name of the namespace that is being opened.
         //
-        // TODO: We should eventually support a qualified name for
-        // a namespace declaration:
+        // We support a qualified name for a namespace declaration:
         //
         //      namespace A.B { ... }
         //
@@ -3304,86 +3304,94 @@ namespace Slang
         //
         //      namespace A { namespace B { ... } }
         //
-        // TODO: Support we also support the degenerate case of
-        // a namesapce without a name? Should that be treated as
-        // an anonymous (and implicitly imported) namespace, or
-        // something else?
-        //
-        // TODO: Should we support a shorthand syntax for putting
-        // the rest of the current scope/file into a namespace:
-        //
-        //      namespace A.B;
-        //
-        //      ...
-        //
-        NameLoc nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
-
-        // Once we have the name for the namespace, we face a challenge:
-        // either the namespace hasn't been seen before (in which case
-        // we need to create it and start filling it in), or we've seen
-        // the same namespace before inside the same module, such that
-        // we should be adding the declarations we parse to the existing
-        // declarations (so that they share a common scope/parent).
-        //
-        // In each case we will find a namespace that we want to fill in,
-        // but depending on the case we may or may not want to return
-        // a declaration to the caller (since they will try to add
-        // any non-null pointer we return to the AST).
-        //
+        auto parentDecl = parser->currentScope->containerDecl;
+        SLANG_ASSERT(parentDecl);
+        NamespaceDecl* result = nullptr;
         NamespaceDecl* namespaceDecl = nullptr;
-
-        // In order to find out what case we are in, we start by looking
-        // for a namespace declaration of the same name in the parent
-        // declaration.
-        //
-        {
-            auto parentDecl = parser->currentScope->containerDecl;
-            SLANG_ASSERT(parentDecl);
-
-            // We meed to make sure that the member dictionary of
-            // the parent declaration has been built/rebuilt so that
-            // lookup by name will work.
+        List<NamespaceDecl*> nestedNamespaceDecls;
+        do
+        {
+            namespaceDecl = nullptr;
+            NameLoc nameAndLoc = NameLoc(parser->ReadToken(TokenType::Identifier));
+            // Once we have the name for the namespace, we face a challenge:
+            // either the namespace hasn't been seen before (in which case
+            // we need to create it and start filling it in), or we've seen
+            // the same namespace before inside the same module, such that
+            // we should be adding the declarations we parse to the existing
+            // declarations (so that they share a common scope/parent).
             //
-            // TODO: The current way we rebuild the member dictionary
-            // would make for O(N^2) parsing time in a file that
-            // consisted of N back-to-back `namespace`s, since each
-            // would trigger a rebuild of the member dictionary that
-            // would take O(N) time.
+            // In each case we will find a namespace that we want to fill in,
+            // but depending on the case we may or may not want to return
+            // a declaration to the caller (since they will try to add
+            // any non-null pointer we return to the AST).
             //
 
-            // There might be multiple members of the same name
-            // (if we define a namespace `foo` after an overloaded
-            // function `foo` has been defined), and direct member
-            // lookup will only give us the first.
-            //
-            Decl* firstDecl = nullptr;
-            parentDecl->getMemberDictionary().tryGetValue(nameAndLoc.name, firstDecl);
-            //
-            // We will search through the declarations of the name
-            // and find the first that is a namespace (if any).
+            // In order to find out what case we are in, we start by looking
+            // for a namespace declaration of the same name in the parent
+            // declaration.
             //
-            // Note: we do not issue diagnostics here based on
-            // the potential conflicts between these declarations,
-            // because we want to do as little semantic analysis
-            // as possible in the parser, and we'd rather be
-            // as permissive as possible right now.
-            //
-            for(Decl* d = firstDecl; d; d = d->nextInContainerWithSameName)
             {
-                namespaceDecl = as<NamespaceDecl>(d);
-                if(namespaceDecl)
-                    break;
-            }
 
-            // If we didn't find a pre-existing namespace, then
-            // we will go ahead and create one now.
-            //
-            if( !namespaceDecl )
+                // We meed to make sure that the member dictionary of
+                // the parent declaration has been built/rebuilt so that
+                // lookup by name will work.
+                //
+                // TODO: The current way we rebuild the member dictionary
+                // would make for O(N^2) parsing time in a file that
+                // consisted of N back-to-back `namespace`s, since each
+                // would trigger a rebuild of the member dictionary that
+                // would take O(N) time.
+                //
+
+                // There might be multiple members of the same name
+                // (if we define a namespace `foo` after an overloaded
+                // function `foo` has been defined), and direct member
+                // lookup will only give us the first.
+                //
+                Decl* firstDecl = nullptr;
+                parentDecl->getMemberDictionary().tryGetValue(nameAndLoc.name, firstDecl);
+                //
+                // We will search through the declarations of the name
+                // and find the first that is a namespace (if any).
+                //
+                // Note: we do not issue diagnostics here based on
+                // the potential conflicts between these declarations,
+                // because we want to do as little semantic analysis
+                // as possible in the parser, and we'd rather be
+                // as permissive as possible right now.
+                //
+                for (Decl* d = firstDecl; d; d = d->nextInContainerWithSameName)
+                {
+                    namespaceDecl = as<NamespaceDecl>(d);
+                    if (namespaceDecl)
+                        break;
+                }
+
+                // If we didn't find a pre-existing namespace, then
+                // we will go ahead and create one now.
+                //
+                if (!namespaceDecl)
+                {
+                    namespaceDecl = parser->astBuilder->create<NamespaceDecl>();
+                    namespaceDecl->nameAndLoc = nameAndLoc;
+                }
+            }
+            if (!result)
             {
-                namespaceDecl = parser->astBuilder->create<NamespaceDecl>();
-                namespaceDecl->nameAndLoc = nameAndLoc;
+                result = namespaceDecl;
             }
-        }
+            else if (parentDecl)
+            {
+                if (auto parentNamespace = as<NamespaceDecl>(parentDecl))
+                {
+                    parser->PushScope(parentDecl);
+                    nestedNamespaceDecls.add(parentNamespace);
+                }
+                AddMember(parentDecl, namespaceDecl);
+            }
+
+            parentDecl = namespaceDecl;
+        } while (AdvanceIf(parser, TokenType::Dot) || AdvanceIf(parser, TokenType::Scope));
 
         // Now that we have a namespace declaration to fill in
         // (whether a new or existing one), we can parse the
@@ -3392,7 +3400,13 @@ namespace Slang
         //
         parseDeclBody(parser, namespaceDecl);
 
-        return namespaceDecl;
+        for (auto ns : nestedNamespaceDecls)
+        {
+            ns->loc = ns->nameAndLoc.loc;
+            ns->closingSourceLoc = namespaceDecl->closingSourceLoc;
+            parser->PopScope();
+        }
+        return result;
     }
 
     static NodeBase* parseUsingDecl(Parser* parser, void* /*userData*/)
@@ -3929,6 +3943,221 @@ namespace Slang
         return paramDecl;
     }
 
+    static bool shouldDeclBeCheckedForNestingValidity(ASTNodeType declType)
+    {
+        switch (declType)
+        {
+        case ASTNodeType::ExtensionDecl:
+        case ASTNodeType::StructDecl:
+        case ASTNodeType::ClassDecl:
+        case ASTNodeType::GLSLInterfaceBlockDecl:
+        case ASTNodeType::EnumDecl:
+        case ASTNodeType::InterfaceDecl:
+        case ASTNodeType::ConstructorDecl:
+        case ASTNodeType::AccessorDecl:
+        case ASTNodeType::GetterDecl:
+        case ASTNodeType::SetterDecl:
+        case ASTNodeType::RefAccessorDecl:
+        case ASTNodeType::FuncDecl:
+        case ASTNodeType::SubscriptDecl:
+        case ASTNodeType::PropertyDecl:
+        case ASTNodeType::NamespaceDecl:
+        case ASTNodeType::ModuleDecl:
+        case ASTNodeType::FileDecl:
+        case ASTNodeType::GenericDecl:
+        case ASTNodeType::VarDecl:
+        case ASTNodeType::LetDecl:
+        case ASTNodeType::TypeDefDecl:
+        case ASTNodeType::TypeAliasDecl:
+        case ASTNodeType::UsingDecl:
+        case ASTNodeType::ImportDecl:
+        case ASTNodeType::IncludeDeclBase:
+        case ASTNodeType::IncludeDecl:
+        case ASTNodeType::ImplementingDecl:
+        case ASTNodeType::ModuleDeclarationDecl:
+        case ASTNodeType::AssocTypeDecl:
+            return true;
+        default:
+            return false;
+        }
+    }
+
+    // Can a decl of `declType` be allowed as a children of `parentType`?
+    static bool isDeclAllowed(bool languageServer, ASTNodeType parentType, ASTNodeType declType)
+    {
+        // If decl is not known as a decl that can be written by the user (e.g. a synthesized decl type),
+        // then we just allow it.
+        if (!shouldDeclBeCheckedForNestingValidity(declType))
+            return true;
+
+        switch (parentType)
+        {
+        case ASTNodeType::ExtensionDecl:
+            switch (declType)
+            {
+            case ASTNodeType::FuncDecl:
+            case ASTNodeType::SubscriptDecl:
+            case ASTNodeType::PropertyDecl:
+            case ASTNodeType::TypeAliasDecl:
+            case ASTNodeType::TypeDefDecl:
+            case ASTNodeType::VarDecl:
+            case ASTNodeType::LetDecl:
+            case ASTNodeType::StructDecl:
+            case ASTNodeType::ClassDecl:
+            case ASTNodeType::EnumDecl:
+            case ASTNodeType::GenericDecl:
+            case ASTNodeType::ConstructorDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::StructDecl:
+        case ASTNodeType::ClassDecl:
+        case ASTNodeType::EnumDecl:
+            switch (declType)
+            {
+            case ASTNodeType::FuncDecl:
+            case ASTNodeType::SubscriptDecl:
+            case ASTNodeType::PropertyDecl:
+            case ASTNodeType::TypeAliasDecl:
+            case ASTNodeType::TypeDefDecl:
+            case ASTNodeType::VarDecl:
+            case ASTNodeType::LetDecl:
+            case ASTNodeType::StructDecl:
+            case ASTNodeType::ClassDecl:
+            case ASTNodeType::EnumDecl:
+            case ASTNodeType::EnumCaseDecl:
+            case ASTNodeType::GenericDecl:
+            case ASTNodeType::ConstructorDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::InterfaceDecl:
+            switch (declType)
+            {
+            case ASTNodeType::FuncDecl:
+            case ASTNodeType::SubscriptDecl:
+            case ASTNodeType::PropertyDecl:
+            case ASTNodeType::AssocTypeDecl:
+            case ASTNodeType::TypeAliasDecl:
+            case ASTNodeType::TypeDefDecl:
+            case ASTNodeType::VarDecl:
+            case ASTNodeType::LetDecl:
+            case ASTNodeType::StructDecl:
+            case ASTNodeType::ClassDecl:
+            case ASTNodeType::EnumDecl:
+            case ASTNodeType::GenericDecl:
+            case ASTNodeType::ConstructorDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::GLSLInterfaceBlockDecl:
+            switch (declType)
+            {
+            case ASTNodeType::VarDecl:
+            case ASTNodeType::LetDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::ConstructorDecl:
+        case ASTNodeType::AccessorDecl:
+        case ASTNodeType::GetterDecl:
+        case ASTNodeType::SetterDecl:
+        case ASTNodeType::RefAccessorDecl:
+        case ASTNodeType::FuncDecl:
+            switch (declType)
+            {
+            case ASTNodeType::TypeAliasDecl:
+            case ASTNodeType::TypeDefDecl:
+            case ASTNodeType::VarDecl:
+            case ASTNodeType::LetDecl:
+            case ASTNodeType::StructDecl:
+            case ASTNodeType::ClassDecl:
+            case ASTNodeType::EnumDecl:
+            case ASTNodeType::GenericDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::SubscriptDecl:
+        case ASTNodeType::PropertyDecl:
+            switch (declType)
+            {
+            case ASTNodeType::AccessorDecl:
+            case ASTNodeType::GetterDecl:
+            case ASTNodeType::SetterDecl:
+            case ASTNodeType::RefAccessorDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::ModuleDecl:
+        case ASTNodeType::FileDecl:
+        case ASTNodeType::NamespaceDecl:
+            switch (declType)
+            {
+            case ASTNodeType::ImplementingDecl:
+                return parentType == ASTNodeType::FileDecl || languageServer && parentType == ASTNodeType::ModuleDecl;
+            case ASTNodeType::ModuleDeclarationDecl:
+                return parentType == ASTNodeType::ModuleDecl || languageServer && parentType == ASTNodeType::FileDecl;
+            case ASTNodeType::NamespaceDecl:
+            case ASTNodeType::FileDecl:
+            case ASTNodeType::UsingDecl:
+            case ASTNodeType::ImportDecl:
+            case ASTNodeType::IncludeDecl:
+            case ASTNodeType::GenericDecl:
+            case ASTNodeType::VarDecl:
+            case ASTNodeType::LetDecl:
+            case ASTNodeType::TypeDefDecl:
+            case ASTNodeType::TypeAliasDecl:
+            case ASTNodeType::FuncDecl:
+            case ASTNodeType::SubscriptDecl:
+            case ASTNodeType::PropertyDecl:
+            case ASTNodeType::StructDecl:
+            case ASTNodeType::ClassDecl:
+            case ASTNodeType::EnumDecl:
+            case ASTNodeType::InterfaceDecl:
+            case ASTNodeType::GLSLInterfaceBlockDecl:
+            case ASTNodeType::ExtensionDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::GenericDecl:
+            switch (declType)
+            {
+            case ASTNodeType::StructDecl:
+            case ASTNodeType::ClassDecl:
+            case ASTNodeType::EnumDecl:
+            case ASTNodeType::InterfaceDecl:
+            case ASTNodeType::FuncDecl:
+            case ASTNodeType::ConstructorDecl:
+            case ASTNodeType::TypeAliasDecl:
+            case ASTNodeType::TypeDefDecl:
+            case ASTNodeType::ExtensionDecl:
+                return true;
+            default:
+                return false;
+            }
+        case ASTNodeType::VarDecl:
+        case ASTNodeType::LetDecl:
+        case ASTNodeType::TypeDefDecl:
+        case ASTNodeType::TypeAliasDecl:
+        case ASTNodeType::UsingDecl:
+        case ASTNodeType::ImportDecl:
+        case ASTNodeType::IncludeDecl:
+        case ASTNodeType::ImplementingDecl:
+        case ASTNodeType::ModuleDeclarationDecl:
+        case ASTNodeType::AssocTypeDecl:
+            return true;
+        default:
+            return true;
+        }
+    }
+
     // Parse declaration of a name to be used for resolving `[attribute(...)]` style modifiers.
     //
     // These are distinct from `syntax` declarations, because their names don't get added
@@ -4008,7 +4237,7 @@ namespace Slang
 
     // Finish up work on a declaration that was parsed
     static void CompleteDecl(
-        Parser*				/*parser*/,
+        Parser*				parser,
         Decl*		decl,
         ContainerDecl*		containerDecl,
         Modifiers			modifiers)
@@ -4034,10 +4263,31 @@ namespace Slang
             declToModify = genericDecl->inner;
         _addModifiers(declToModify, modifiers);
 
-        if (containerDecl && !as<GenericDecl>(containerDecl))
+        if (containerDecl)
         {
-            // Make sure the decl is properly nested inside its lexical parent
-            AddMember(containerDecl, decl);
+            // Check that the declaration is actually allowed to be nested inside container.
+            if (!isDeclAllowed(parser->options.isInLanguageServer, containerDecl->astNodeType, decl->astNodeType))
+            {
+                parser->sink->diagnose(decl->loc, Diagnostics::declNotAllowed, decl->astNodeType);
+            }
+            else
+            {
+                // For generic decls, we also need to check if the inner decl type is allowed to be
+                // nested here.
+                if (declToModify && declToModify != decl)
+                {
+                    if (!isDeclAllowed(parser->options.isInLanguageServer, containerDecl->astNodeType, declToModify->astNodeType))
+                    {
+                        parser->sink->diagnose(decl->loc, Diagnostics::declNotAllowed, declToModify->astNodeType);
+                    }
+                }
+            }
+
+            if (!as<GenericDecl>(containerDecl))
+            {
+                // Make sure the decl is properly nested inside its lexical parent
+                AddMember(containerDecl, decl);
+            }
         }
     }
 
@@ -6982,6 +7232,7 @@ namespace Slang
         ParserOptions options = {};
         options.enableEffectAnnotations = translationUnit->compileRequest->getLinkage()->getEnableEffectAnnotations();
         options.allowGLSLInput = translationUnit->compileRequest->getLinkage()->getAllowGLSLInput();
+        options.isInLanguageServer = translationUnit->compileRequest->getLinkage()->isInLanguageServer();
 
         Parser parser(astBuilder, tokens, sink, outerScope, options);
         parser.namePool = translationUnit->getNamePool();
diff --git a/source/slang/slang-syntax.cpp b/source/slang/slang-syntax.cpp
index 6350a7e4d..ab0dfcd74 100644
--- a/source/slang/slang-syntax.cpp
+++ b/source/slang/slang-syntax.cpp
@@ -25,6 +25,77 @@ void printDiagnosticArg(StringBuilder& sb, DeclRefBase* declRefBase)
     printDiagnosticArg(sb, declRefBase->getDecl());
 }
 
+void printDiagnosticArg(StringBuilder& sb, ASTNodeType nodeType)
+{
+    // TODO: this can be generated.
+
+    switch (nodeType)
+    {
+        case ASTNodeType::Decl: sb << "Decl"; break;
+        case ASTNodeType::UnresolvedDecl: sb << "UnresolvedDecl"; break;
+        case ASTNodeType::ContainerDecl: sb << "ContainerDecl"; break;
+        case ASTNodeType::AggTypeDeclBase: sb << "AggTypeDeclBase"; break;
+        case ASTNodeType::ExtensionDecl: sb << "extension"; break;
+        case ASTNodeType::AggTypeDecl: sb << "AggTypeDecl"; break;
+        case ASTNodeType::StructDecl: sb << "struct"; break;
+        case ASTNodeType::ClassDecl: sb << "class"; break;
+        case ASTNodeType::GLSLInterfaceBlockDecl: sb << "GLSL interface block"; break;
+        case ASTNodeType::EnumDecl: sb << "enum"; break;
+        case ASTNodeType::ThisTypeDecl: sb << "This"; break;
+        case ASTNodeType::InterfaceDecl: sb << "interface"; break;
+        case ASTNodeType::AssocTypeDecl: sb << "associatedtype"; break;
+        case ASTNodeType::GlobalGenericParamDecl: sb << "global generic param"; break;
+        case ASTNodeType::ScopeDecl: sb << "scope"; break;
+        case ASTNodeType::CallableDecl: sb << "CallableDecl"; break;
+        case ASTNodeType::FunctionDeclBase: sb << "FunctionDeclBase"; break;
+        case ASTNodeType::ConstructorDecl: sb << "__init"; break;
+        case ASTNodeType::AccessorDecl: sb << "accessor"; break;
+        case ASTNodeType::GetterDecl: sb << "getter"; break;
+        case ASTNodeType::SetterDecl: sb << "setter"; break;
+        case ASTNodeType::RefAccessorDecl: sb << "ref accessor"; break;
+        case ASTNodeType::FuncDecl: sb << "function"; break;
+        case ASTNodeType::DerivativeRequirementDecl: sb << "DerivativeRequirementDecl"; break;
+        case ASTNodeType::ForwardDerivativeRequirementDecl: sb << "ForwardDerivativeRequirementDecl"; break;
+        case ASTNodeType::BackwardDerivativeRequirementDecl: sb << "BackwardDerivativeRequirementDecl"; break;
+        case ASTNodeType::DerivativeRequirementReferenceDecl: sb << "DerivativeRequirementReferenceDecl"; break;
+        case ASTNodeType::SubscriptDecl: sb << "__subscript"; break;
+        case ASTNodeType::PropertyDecl: sb << "property"; break;
+        case ASTNodeType::NamespaceDeclBase: sb << "NamespaceDeclBase"; break;
+        case ASTNodeType::NamespaceDecl: sb << "namespace"; break;
+        case ASTNodeType::ModuleDecl: sb << "module"; break;
+        case ASTNodeType::FileDecl: sb << "included file"; break;
+        case ASTNodeType::GenericDecl: sb << "generic"; break;
+        case ASTNodeType::AttributeDecl: sb << "attribute"; break;
+        case ASTNodeType::VarDeclBase: sb << "variable definition"; break;
+        case ASTNodeType::VarDecl: sb << "variable definition"; break;
+        case ASTNodeType::LetDecl: sb << "immutable value definition"; break;
+        case ASTNodeType::GlobalGenericValueParamDecl: sb << "GlobalGenericValueParamDecl"; break;
+        case ASTNodeType::ParamDecl: sb << "parameter"; break;
+        case ASTNodeType::ModernParamDecl: sb << "parameter"; break;
+        case ASTNodeType::GenericValueParamDecl: sb << "GenericValueParamDecl"; break;
+        case ASTNodeType::EnumCaseDecl: sb << "enum case"; break;
+        case ASTNodeType::TypeConstraintDecl: sb << "TypeConstraintDecl"; break;
+        case ASTNodeType::ThisTypeConstraintDecl: sb << "ThisTypeConstraintDecl"; break;
+        case ASTNodeType::InheritanceDecl: sb << "InheritanceDecl"; break;
+        case ASTNodeType::GenericTypeConstraintDecl: sb << "GenericTypeConstraintDecl"; break;
+        case ASTNodeType::SimpleTypeDecl: sb << "SimpleTypeDecl"; break;
+        case ASTNodeType::TypeDefDecl: sb << "typedef"; break;
+        case ASTNodeType::TypeAliasDecl: sb << "typealias"; break;
+        case ASTNodeType::GenericTypeParamDecl: sb << "GenericTypeParamDecl"; break;
+        case ASTNodeType::UsingDecl: sb << "using"; break;
+        case ASTNodeType::FileReferenceDeclBase: sb << "FileReferenceDeclBase"; break;
+        case ASTNodeType::ImportDecl: sb << "import"; break;
+        case ASTNodeType::IncludeDeclBase: sb << "IncludeDeclBase"; break;
+        case ASTNodeType::IncludeDecl: sb << "__include"; break;
+        case ASTNodeType::ImplementingDecl: sb << "implementing"; break;
+        case ASTNodeType::ModuleDeclarationDecl: sb << "module"; break;
+        case ASTNodeType::EmptyDecl: sb << "empty"; break;
+        case ASTNodeType::SyntaxDecl: sb << "syntax"; break;
+        case ASTNodeType::DeclGroup: sb << "decl-group"; break;
+        default: sb << "decl"; break;
+    }
+}
+
 void printDiagnosticArg(StringBuilder& sb, Type* type)
 {
     if (!type)