Merge pull request shader-slang#372 from csyonghe/master

Allow type expression as type argument, fix global param enum order

Author: csyonghe

source/slang/check.cpp

@@ -6849,6 +6849,23 @@ namespace Slang
         return (!decl->primaryDecl) || (decl == decl->primaryDecl);
     }
 
+    RefPtr<Type> checkProperType(TranslationUnitRequest * tu, TypeExp typeExp)
+    {
+        RefPtr<Type> type;
+        DiagnosticSink nSink;
+        nSink.sourceManager = tu->compileRequest->sourceManager;
+        SemanticsVisitor visitor(
+            &nSink,
+            tu->compileRequest,
+            tu);
+        auto typeOut = visitor.CheckProperType(typeExp);
+        if (!nSink.errorCount)
+        {
+            type = typeOut.type;
+        }
+        return type;
+    }
+
     void validateEntryPoint(
         EntryPointRequest*  entryPoint)
     {
@@ -6944,26 +6961,25 @@ namespace Slang
         entryPoint->decl = entryPointFuncDecl;
 
         // Lookup generic parameter types in global scope
+        List<RefPtr<Scope>> scopesToTry;
+        scopesToTry.Add(entryPoint->getTranslationUnit()->SyntaxNode->scope);
+        for (auto & module : entryPoint->compileRequest->loadedModulesList)
+            scopesToTry.Add(module->moduleDecl->scope);
         for (auto name : entryPoint->genericParameterTypeNames)
-        {
-            firstDeclWithName = entryPoint->compileRequest->lookupGlobalDecl(name);
-            if (!firstDeclWithName)
-            {
-                // If there doesn't appear to be any such declaration, then
-                // we need to diagnose it as an error, and then bail out.
-                sink->diagnose(translationUnitSyntax, Diagnostics::entryPointTypeParameterNotFound, name);
-                return;
-            }
+        {   
+            // parse type name
             RefPtr<Type> type;
-            if (auto aggType = firstDeclWithName->As<AggTypeDecl>())
-            {
-                type = DeclRefType::Create(entryPoint->compileRequest->mSession, DeclRef<Decl>(aggType, nullptr));
-            }
-            else if (auto typeDefDecl = firstDeclWithName->As<TypeDefDecl>())
+            for (auto & s : scopesToTry)
             {
-                type = GetType(DeclRef<TypeDefDecl>(typeDefDecl, nullptr));
+                RefPtr<Expr> typeExpr = entryPoint->compileRequest->parseTypeString(entryPoint->getTranslationUnit(),
+                    name, s);
+                type = checkProperType(translationUnit, TypeExp(typeExpr));
+                if (type)
+                {
+                    break;
+                }
             }
-            else
+            if (!type)
             {
                 sink->diagnose(firstDeclWithName, Diagnostics::entryPointTypeSymbolNotAType, name);
                 return;

source/slang/compiler.h

@@ -104,7 +104,7 @@ namespace Slang
 
         // The type names we want to substitute into the 
         // global generic type parameters
-        List<Name*> genericParameterTypeNames;
+        List<String> genericParameterTypeNames;
 
         // The profile that the entry point will be compiled for
         // (this is a combination of the target state, and also
@@ -318,6 +318,10 @@ namespace Slang
 
         ~CompileRequest();
 
+        RefPtr<Expr> parseTypeString(TranslationUnitRequest * translationUnit, String typeStr, RefPtr<Scope> scope);
+        
+        Type* getTypeFromString(String typeStr);
+
         void parseTranslationUnit(
             TranslationUnitRequest* translationUnit);
 

source/slang/decl-defs.h

@@ -196,7 +196,9 @@ SIMPLE_SYNTAX_CLASS(Variable, VarDeclBase);
 
 // A "module" of code (essentiately, a single translation unit)
 // that provides a scope for some number of declarations.
-SIMPLE_SYNTAX_CLASS(ModuleDecl, ContainerDecl)
+SYNTAX_CLASS(ModuleDecl, ContainerDecl)
+    FIELD(RefPtr<Scope>, scope)
+END_SYNTAX_CLASS()
 
 SYNTAX_CLASS(ImportDecl, Decl)
     // The name of the module we are trying to import

source/slang/emit.cpp

@@ -7500,7 +7500,7 @@ String emitEntryPoint(
         // none of our target supports generics, or interfaces,
         // so we need to specialize those away.
         //
-        specializeGenerics(irModule);
+        specializeGenerics(irModule, sharedContext.target);
 
         // Debugging code for IR transformations...
 #if 0

source/slang/ir-insts.h

@@ -641,7 +641,8 @@ void specializeIRForEntryPoint(
 // Find suitable uses of the `specialize` instruction that
 // can be replaced with references to specialized functions.
 void specializeGenerics(
-    IRModule*   module);
+    IRModule*   module,
+    CodeGenTarget target);
 
 //