Add basic support for namespaces (#1304)

This change adds logic for parsing `namespace` declarations, referencing them, and looking up their members.

* The parser changes are a bit subtle, because that is where we deal with the issue of "re-opening" a namespace. We kludge things a bit by re-using an existing `NamespaceDecl` in the same parent if one is available, and thereby ensure that all the members in the same namespace can see on another.

* In order to allow namespaces to be referenced by name they need to have a type so that a `DeclRefExpr` to them can be formed. For this purpose we introduce `NamespaceType` which is the (singleton) type of a reference to a given namespace.

* The new `NamespaceType` case is detected in the `MemberExpr` checking logic and routed to the same logic that `StaticMemberExpr` uses, and the static lookup logic was extended with support for looking up in a namespace (a thin wrapper around one of the existing worker routines in `slang-lookup.cpp`.

* I made `NamespaceDecl` have a shared base class with `ModuleDecl` in the hopes that this would allow us to allow references to modules by name in the future. That hasn't been tested as part of this change.

* I cleaned up a bunch of logic around `ModuleDecl` holding a `Scope` pointer that was being used for some of the more ad hoc lookup routines in the public API. Those have been switched over to something that is a bit more sensible given the language rules and that doesn't rely on keeping state sititng around on the `ModuleDecl`.

* I added a test case to make sure the new funcitonality works, which includes re-opening a namespace, and it also tests both `.` and `::` operations for lookup in a namespace.

* The main missing feature here is the ability to do something like C++ `using`. It would probably be cleanest if we used `import` for this, since we already have that syntax (and having both `import` and `using` seems like a recipe for confusion). Most of the infrastructure is present to support `import`ing one namespace into another (in a way that wouldn't automatically pollute the namespace for clients), but some careful thought needs to be put into how import of namespaces vs. modules should work.

1 files changed, 42 insertions, 18 deletions

diff --git a/source/slang/slang-check-shader.cpp b/source/slang/slang-check-shader.cpp
index da0313049..53c3f8d89 100644
--- a/source/slang/slang-check-shader.cpp
+++ b/source/slang/slang-check-shader.cpp
@@ -1270,6 +1270,36 @@ namespace Slang
             sink);
     }
 
+    RefPtr<Scope> ComponentType::_createScopeForLegacyLookup()
+    {
+        // The shape of this logic is dictated by the legacy
+        // behavior for name-based lookup/parsing of types
+        // specified via the API or command line.
+        //
+        // We begin with a dummy scope that has as its parent
+        // the scope that provides the "base" langauge
+        // definitions (that scope is necessary because
+        // it defines keywords like `true` and `false`).
+        //
+        RefPtr<Scope> scope = new Scope();
+        scope->parent = getLinkage()->getSessionImpl()->baseLanguageScope;
+        //
+        // Next, the scope needs to include all of the
+        // modules in the program as peers, as if they
+        // were `import`ed into the scope.
+        //
+        for( auto module : getModuleDependencies() )
+        {
+            RefPtr<Scope> moduleScope = new Scope();
+            moduleScope->containerDecl = module->getModuleDecl();
+
+            moduleScope->nextSibling = scope->nextSibling;
+            scope->nextSibling = moduleScope;
+        }
+
+        return scope;
+    }
+
         /// Parse an array of strings as specialization arguments.
         ///
         /// Names in the strings will be parsed in the context of
@@ -1282,14 +1312,8 @@ namespace Slang
     {
         auto unspecialiedProgram = endToEndReq->getUnspecializedGlobalComponentType();
 
-        // TODO: Building a list of `scopesToTry` here shouldn't
-        // be required, since the `Scope` type itself has the ability
-        // for form chains for lookup purposes (e.g., the way that
-        // `import` is handled by modifying a scope).
-        //
-        List<RefPtr<Scope>> scopesToTry;
-        for( auto module : unspecialiedProgram->getModuleDependencies() )
-            scopesToTry.add(module->getModuleDecl()->scope);
+
+        RefPtr<Scope> scope = unspecialiedProgram->_createScopeForLegacyLookup();
 
         // We are going to do some semantic checking, so we need to
         // set up a `SemanticsVistitor` that we can use.
@@ -1311,16 +1335,8 @@ namespace Slang
         //
         for(auto name : genericArgStrings)
         {
-            RefPtr<Expr> argExpr;
-            for (auto & s : scopesToTry)
-            {
-                argExpr = linkage->parseTermString(name, s);
-                argExpr = semantics.CheckTerm(argExpr);
-                if( argExpr )
-                {
-                    break;
-                }
-            }
+            RefPtr<Expr> argExpr = linkage->parseTermString(name, scope);
+            argExpr = semantics.CheckTerm(argExpr);
 
             if(!argExpr)
             {
@@ -1606,6 +1622,14 @@ namespace Slang
             outSpecializedEntryPoints.add(specializedEntryPoint);
         }
 
+        // There might have been errors during the specialization above,
+        // so we will bail out early if anything went wrong, rather
+        // then try to create a composite where some of the constituent
+        // component types might be null.
+        //
+        if(endToEndReq->getSink()->GetErrorCount() != 0)
+            return nullptr;
+
         // Any entry points beyond those that were specified up front will be
         // assumed to not need/want specialization.
         //