Cleanups to `ParameterBlock<T>` behavior. (#304)

* Cleanups to `ParameterBlock<T>` behavior.

These add some more realistic tests using the `ParameterBlock<T>` support, and show that it can work with the "rewriter" mode.

Unfortunately, this code does *not* currently work with the rewriter + the IR at once. That will need to be fixed in a follow-on change, because I now see that the root problem is pretty ugly.

* cleanup

1 files changed, 35 insertions, 0 deletions

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index c1893423a..4840ae30d 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -1005,6 +1005,40 @@ namespace Slang
                 }
 
             }
+
+            // Are we converting from a parameter group type to its element type?
+            if(auto fromParameterGroupType = fromType->As<ParameterGroupType>())
+            {
+                auto fromElementType = fromParameterGroupType->getElementType();
+
+                // If we have, e.g., `ConstantBuffer<A>` and we want to convert
+                // to `B`, where conversion from `A` to `B` is possible, then
+                // we will do so here.
+
+                ConversionCost subCost = 0;
+                if(CanCoerce(toType, fromElementType, &subCost))
+                {
+                    if(outCost)
+                        *outCost = subCost + kConversionCost_ImplicitDereference;
+
+                    if(outToExpr)
+                    {
+                        auto derefExpr = new DerefExpr();
+                        derefExpr->base = fromExpr;
+                        derefExpr->type = QualType(fromElementType);
+
+                        return TryCoerceImpl(
+                            toType,
+                            outToExpr,
+                            fromElementType,
+                            derefExpr,
+                            nullptr);
+                    }
+                    return true;
+                }
+            }
+
+
             // Look for an initializer/constructor declaration in the target type,
             // which is marked as usable for implicit conversion, and which takes
             // the source type as an argument.
@@ -1171,6 +1205,7 @@ namespace Slang
             RefPtr<TypeCastExpr> castExpr = createImplicitCastExpr();
 
             auto typeType = new TypeType();
+            typeType->setSession(getSession());
             typeType->type = toType;
 
             auto typeExpr = new SharedTypeExpr();