Language experiments (#2068)

* #include an absolute path didn't work - because paths were taken to always be relative.

* Moved to experiments.
Added some more tests.

* More tests around associated types.

* Return interface tests.

* More tests.

64 files changed, 848 insertions, 33 deletions

diff --git a/tests/current-bugs/generic/README.md b/tests/current-bugs/generic/README.md
deleted file mode 100644
index 202606979..000000000
--- a/tests/current-bugs/generic/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-Generic Tests
-=============
-
-The following tests are currently disabled. 
-
-They are a series of attempts to use generics for a variety of scenarios. There may be multiple versions of an attempt, when this is the case a number will be added to the suffix. In general tests like this can be considered to have been attempts in that order. 
-
-Some of these tests do compile, but are kept because they provide the end of a train of thought. The solution may not be ideal, or the best way to implement in Slang. So they are kept here for completeness.
-
-Some of the issues may be due to a bug, or unimplemented feature in the compiler.
-
-Others may not work because it is not the appropriate way to achieve the desired effect. 
diff --git a/tests/experiments/README.md b/tests/experiments/README.md
new file mode 100644
index 000000000..2fb7398c2
--- /dev/null
+++ b/tests/experiments/README.md
@@ -0,0 +1,18 @@
+Experiments
+===========
+
+The tests in this directory are all disabled. This set of tests is probably only temporary, and exists to document attempts to use certain language features.
+
+There may be multiple versions of an attempt, when this is the case a number will be added to the suffix. In general tests like this can be considered to have been attempts in that order. 
+
+Some of these tests *do* compile, but are kept because they provide the end of a train of thought. The solution may not be ideal, or the best way to implement in Slang. So they are kept here for completeness.
+
+Some of the issues may be due to a bug, or unimplemented feature in the compiler.
+
+Others may not work because it is not the appropriate way to achieve the desired effect. 
+
+Surprising Observations
+=======================
+
+* let is needed for int generic parameter.
+
diff --git a/tests/experiments/algorithm/find-max-2.slang b/tests/experiments/algorithm/find-max-2.slang
new file mode 100644
index 000000000..3aebbc997
--- /dev/null
+++ b/tests/experiments/algorithm/find-max-2.slang
@@ -0,0 +1,45 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* Find max algorithm. 
+
+Works.
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+interface IComparable
+{
+    bool isLess(This other);
+};
+
+extension int : IComparable
+{
+	bool isLess(int other) { return this < other; }
+};
+
+T findMax<T : IComparable, let SIZE : int>(T arr[SIZE])
+{
+    T m = arr[0];
+    for (int i = 1; i < 8; ++i)
+    {
+        if (m.isLess(arr[i]))
+        {
+            m = arr[i];
+        }
+    }
+    return m;
+}
+
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    int values[] = { 1, 3, - 1};
+    
+	outputBuffer[index] = findMax<int, 3>(values);
+}
+
+
diff --git a/tests/experiments/algorithm/find-max.slang b/tests/experiments/algorithm/find-max.slang
new file mode 100644
index 000000000..ba8499013
--- /dev/null
+++ b/tests/experiments/algorithm/find-max.slang
@@ -0,0 +1,41 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* Find max algorithm. 
+
+Doesn't work because, can't compare T as it is any type.
+
+.slang(15): error 39999: no overload for '>' applicable to arguments of type (T, T)
+        if (arr[i] > m)
+                   ^
+core.meta.slang(2572): note 39999: candidate: func >(uint64_t, uint64_t) -> bool
+
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+T findMax<T, let SIZE : int>(T arr[SIZE])
+{
+    T m = arr[0];
+    for (int i = 1; i < 8; ++i)
+    {
+        if (arr[i] > m)
+        {
+            m = arr[i];
+        }
+    }
+    return i;
+}
+
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    int values[] = { 1, 3, - 1};
+    
+	outputBuffer[index] = findMax(values);
+}
+
+
diff --git a/tests/experiments/algorithm/generic-int-controlled-2.slang b/tests/experiments/algorithm/generic-int-controlled-2.slang
new file mode 100644
index 000000000..52ef02336
--- /dev/null
+++ b/tests/experiments/algorithm/generic-int-controlled-2.slang
@@ -0,0 +1,33 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* Test to control altering of an algorithm via generic compile time values.
+
+Works.
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+int reduce<let Clustering : int, let DupTest : int>( int a)
+{
+    if (Clustering)
+    {
+        a = a + a;
+    }
+    if (DupTest)
+    {
+        a *= a;
+    }
+    return a;
+}
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    int r = reduce<1, 2>(index);
+    
+	outputBuffer[index] = r;
+}
+
diff --git a/tests/experiments/algorithm/generic-int-controlled.slang b/tests/experiments/algorithm/generic-int-controlled.slang
new file mode 100644
index 000000000..5f698633c
--- /dev/null
+++ b/tests/experiments/algorithm/generic-int-controlled.slang
@@ -0,0 +1,35 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* Test to control altering of an algorithm via generic compile time values.
+
+slang(28): note 99999: an internal error threw an exception while working on code near this location
+(0): error 99999: Slang compilation aborted due to an exception of class Slang::InternalError: unexpected: could not resolve target declaration for call
+
+Seems like it's the default value (=1) that leads to this crash. If we explicitly specify it's ok.
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+int reduce<let Clustering : int, let DupTest : int = 1>( int a)
+{
+    if (Clustering)
+    {
+        a = a + a;
+    }
+    if (DupTest)
+    {
+        a *= a;
+    }
+    return a;
+}
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    int r = reduce<1>(index);
+    
+	outputBuffer[index] = r;
+}
\ No newline at end of file
diff --git a/tests/experiments/generic/README.md b/tests/experiments/generic/README.md
new file mode 100644
index 000000000..ae062bb11
--- /dev/null
+++ b/tests/experiments/generic/README.md
@@ -0,0 +1,7 @@
+Generic Experiments
+===================
+
+Experiement tests around generics.
+
+All tests are disabled.
+
diff --git a/tests/current-bugs/generic/alternative-array-type.slang b/tests/experiments/generic/alternative-array-type.slang
index 1e28a85f5..1e28a85f5 100644
--- a/tests/current-bugs/generic/alternative-array-type.slang
+++ b/tests/experiments/generic/alternative-array-type.slang
diff --git a/tests/current-bugs/generic/built-in-add.slang b/tests/experiments/generic/built-in-add.slang
index 1ca20d6a6..c5751fe69 100644
--- a/tests/current-bugs/generic/built-in-add.slang
+++ b/tests/experiments/generic/built-in-add.slang
@@ -1,12 +1,15 @@
 //DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
 
-/* Test use of a generic with a built in doing something simple.
+/* Test use of a generic with a built in doing something simple. 
 
 Doesn't work because cannot find +.
 
 .slang(3): error 39999: no overload for '+' applicable to arguments of type (typeof(V), int)
 int doThing<V : int>(int b) { return V + b; }
 
+NOTE! We can fix by adding *let*
+
+int doThing<let V : int>(int b) { return V + b; }
 */
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
diff --git a/tests/current-bugs/generic/built-in-extension.slang b/tests/experiments/generic/built-in-extension.slang
index b71e3eaa6..b71e3eaa6 100644
--- a/tests/current-bugs/generic/built-in-extension.slang
+++ b/tests/experiments/generic/built-in-extension.slang
diff --git a/tests/current-bugs/generic/byte-address-ptr-2.slang b/tests/experiments/generic/byte-address-ptr-2.slang
index 895c0dba4..895c0dba4 100644
--- a/tests/current-bugs/generic/byte-address-ptr-2.slang
+++ b/tests/experiments/generic/byte-address-ptr-2.slang
diff --git a/tests/current-bugs/generic/byte-address-ptr.slang b/tests/experiments/generic/byte-address-ptr.slang
index 33096b70f..33096b70f 100644
--- a/tests/current-bugs/generic/byte-address-ptr.slang
+++ b/tests/experiments/generic/byte-address-ptr.slang
diff --git a/tests/current-bugs/generic/constraint.slang b/tests/experiments/generic/constraint.slang
index 7143d3fd4..7143d3fd4 100644
--- a/tests/current-bugs/generic/constraint.slang
+++ b/tests/experiments/generic/constraint.slang
diff --git a/tests/current-bugs/generic/enum-flags.slang b/tests/experiments/generic/enum-flags.slang
index 2afee720f..0ae992e6a 100644
--- a/tests/current-bugs/generic/enum-flags.slang
+++ b/tests/experiments/generic/enum-flags.slang
@@ -2,7 +2,13 @@
 
 /* A test to use generics to treat an enum as a set.
 
-Doesn't work because the integer ops required for Flags impl, can't be seen */
+.slang(15): error 30060: expected a type, got a '__BuiltinIntegerType'
+    B value = 0;
+    
+.slang(23): error 30019: expected an expression of type 'int', got 'typeof(uint8_t)'
+    Flags<Enum, uint8_t> flags;
+                ^~~~~~~    
+*/
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
 RWStructuredBuffer<float> outputBuffer;
@@ -14,7 +20,7 @@ enum Enum
     C = 0x4,
 };
 
-__generic<E, B : __BuiltinIntegerType>
+__generic<E, let B : __BuiltinIntegerType>
 struct Flags
 {
     [mutating] void set(E e) { value |= (B)e; }
diff --git a/tests/current-bugs/generic/enum-int-flags.slang b/tests/experiments/generic/enum-int-flags.slang
index d35b7e6ab..d35b7e6ab 100644
--- a/tests/current-bugs/generic/enum-int-flags.slang
+++ b/tests/experiments/generic/enum-int-flags.slang
diff --git a/tests/current-bugs/generic/equality-2.slang b/tests/experiments/generic/equality-2.slang
index 8a1f87463..8a1f87463 100644
--- a/tests/current-bugs/generic/equality-2.slang
+++ b/tests/experiments/generic/equality-2.slang
diff --git a/tests/experiments/generic/equality-3.slang b/tests/experiments/generic/equality-3.slang
new file mode 100644
index 000000000..e5e42aedf
--- /dev/null
+++ b/tests/experiments/generic/equality-3.slang
@@ -0,0 +1,40 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test for equality around interface types
+
+This style is discussed in the documentation here:
+
+Still has limitiation that it only works for an an implementation of an interface.  
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+interface IEquality
+{
+    bool isEqual(This other);
+}
+
+struct A : IEquality
+{
+    bool isEqual(This other)
+    {
+        return value == other.value;
+    }
+    int value;
+};
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    A a = { 1 };
+    A b = { 2 };
+    
+    bool isEqual = a.isEqual(b);
+
+	outputBuffer[index] = 1 + int(isEqual);
+}
+
+
diff --git a/tests/experiments/generic/equality-4.slang b/tests/experiments/generic/equality-4.slang
new file mode 100644
index 000000000..44c049323
--- /dev/null
+++ b/tests/experiments/generic/equality-4.slang
@@ -0,0 +1,56 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test for equality around interface types
+
+Here again trying to apply equality *outside* of the types (MyStruct) definition.  
+
+Doesn't work:
+
+.slang(24): error 30019: expected an expression of type 'Type', got 'T'
+    return T::isEqual(a, b);
+    
+Note! This may be somewhat of a silly example for equality. We could get what we want here by just
+implementing 'isEqual(MyStruct a, MyStruct b)` as a free function and use overloading.     
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+struct MyStruct
+{
+    int a = 10;
+};
+
+interface IEquality
+{
+    associatedtype Type;
+    static bool isEqual(Type a, Type b);
+}
+
+extension MyStruct : IEquality
+{
+    // Do I need this? Is the type This?
+    typedef MyStruct Type;
+    static bool isEqual(Type a, Type b) { return a.a == b.a; }
+};
+
+__generic<T : IEquality>
+bool isEqual(T a, T b)
+{
+    return T::isEqual(a, b);
+}
+             
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    MyStruct a = { 1 };
+    MyStruct b = { 2 };
+    
+    bool res = isEqual(a, b);
+
+	outputBuffer[index] = 1 + int(res);
+}
+
+
diff --git a/tests/experiments/generic/equality-5.slang b/tests/experiments/generic/equality-5.slang
new file mode 100644
index 000000000..41cadbbfc
--- /dev/null
+++ b/tests/experiments/generic/equality-5.slang
@@ -0,0 +1,44 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test for equality around interface types
+
+This is an attempt to get the *outside* impl of equality to work. The simple case does, but just to throw 
+a spanner in the works, lets mix in some inheritance. 
+
+An issue here (perhaps) is that this will compile - the isEqual implementation will just slice and probably not do what the implementer expected.
+    
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+struct MyStruct
+{
+    int a = 10;
+};
+
+struct MyStruct2 : MyStruct
+{
+    int b;
+};
+
+bool isEqual(MyStruct a, MyStruct b)
+{
+    return a.a == b.a;
+}
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    // I *suppose* it could be argued that this is problematic - that the b field is uninitialized 
+    // but there is no warning or an error.
+   
+    MyStruct2 a = { 1 };
+    MyStruct2 b = { 2 };
+    
+    bool res = isEqual(a, b);
+
+	outputBuffer[index] = 1 + int(res);
+}
\ No newline at end of file
diff --git a/tests/current-bugs/generic/equality.slang b/tests/experiments/generic/equality.slang
index 604e347b1..eb4569df5 100644
--- a/tests/current-bugs/generic/equality.slang
+++ b/tests/experiments/generic/equality.slang
@@ -21,7 +21,7 @@ struct A : IEquality
 {
     bool isEqual(IEquality rhs)
     {
-        // Hmm. How can I cant query rhs, and then cast, so how to implement
+        // Hmm. How can I cant query rhs, and then cast, so not clear how to implement
         return true;
     }
     int value;
diff --git a/tests/experiments/generic/field-inheritance-2.slang b/tests/experiments/generic/field-inheritance-2.slang
new file mode 100644
index 000000000..af3a153b4
--- /dev/null
+++ b/tests/experiments/generic/field-inheritance-2.slang
@@ -0,0 +1,38 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* The test is for behavior with inheritance and two fields with the same name. 
+
+.slang(24): error 39999: no overload for 'int' applicable to arguments of type (overload group)
+    outputBuffer[index] = 1 + int(a.a);
+
+Looks like the problem is that it sees 'a' as 'overloaded' - which I guess is one way to look at it. It is then followed with ...
+    
+core.meta.slang(230): note 39999: candidate: int.init(uint64_t)
+core.meta.slang(230): note 39999: candidate: int.init(uint)
+
+Which doesn't seem appropriate    
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+struct MyStruct
+{
+    int a = 10;
+};
+
+struct MyStruct2 : MyStruct
+{
+    int a = 10;
+};    
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    MyStruct2 a;
+
+	outputBuffer[index] = 1 + int(a.a);
+}
+
diff --git a/tests/experiments/generic/field-inheritance.slang b/tests/experiments/generic/field-inheritance.slang
new file mode 100644
index 000000000..593ee81f1
--- /dev/null
+++ b/tests/experiments/generic/field-inheritance.slang
@@ -0,0 +1,48 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* The test here uses struct inheritance but has a field with the same name in the derived type. 
+
+This error is for the MyStruct2 version. 
+
+.slang(20): error 39999: no overload for '==' applicable to arguments of type (overload group, overload group)
+    return a.a == b.a;
+
+No error/warning is given for the shadowing of MyStruct.a.
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<float> outputBuffer;
+
+struct MyStruct
+{
+    int a = 10;
+};
+
+struct MyStruct2 : MyStruct
+{
+    int a = 10;
+};
+
+bool isEqual(MyStruct a, MyStruct b)
+{
+    return a.a == b.a;
+}
+
+bool isEqual(MyStruct2 a, MyStruct2 b)
+{
+    return a.a == b.a;
+}
+             
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int index = dispatchThreadID.x;
+
+    MyStruct a = { 1 };
+    MyStruct b = { 2 };
+    
+    bool res = isEqual(a, b);
+
+	outputBuffer[index] = 1 + int(res);
+}
+
diff --git a/tests/current-bugs/generic/fixed-array-2.slang b/tests/experiments/generic/fixed-array-2.slang
index 00024f80e..00024f80e 100644
--- a/tests/current-bugs/generic/fixed-array-2.slang
+++ b/tests/experiments/generic/fixed-array-2.slang
diff --git a/tests/current-bugs/generic/fixed-array-3.slang b/tests/experiments/generic/fixed-array-3.slang
index 16c4c9931..16c4c9931 100644
--- a/tests/current-bugs/generic/fixed-array-3.slang
+++ b/tests/experiments/generic/fixed-array-3.slang
diff --git a/tests/current-bugs/generic/fixed-array-4.slang b/tests/experiments/generic/fixed-array-4.slang
index bf58398d0..bf58398d0 100644
--- a/tests/current-bugs/generic/fixed-array-4.slang
+++ b/tests/experiments/generic/fixed-array-4.slang
diff --git a/tests/current-bugs/generic/fixed-array-5.slang b/tests/experiments/generic/fixed-array-5.slang
index 6d0c6f8b9..6d0c6f8b9 100644
--- a/tests/current-bugs/generic/fixed-array-5.slang
+++ b/tests/experiments/generic/fixed-array-5.slang
diff --git a/tests/current-bugs/generic/fixed-array.slang b/tests/experiments/generic/fixed-array.slang
index 32b6d16aa..8f8335aa2 100644
--- a/tests/current-bugs/generic/fixed-array.slang
+++ b/tests/experiments/generic/fixed-array.slang
@@ -2,14 +2,19 @@
 
 /* A test around use of an array like container. 
 
-Doesn't work because SIZE can't be used to set the element array size */
+Has error:
+
+.slang(5): error 30019: expected an expression of type 'int', got 'typeof(SIZE)'
+    T elements[SIZE];
+
+Problem here is SIZE doesn't have *let* in front. The error doesn't provide any useful insight into that. It's also not entirely clear *why* let is needed. Presumably because it's not a type?
+*/
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
 RWStructuredBuffer<float> outputBuffer;
 
 struct FixedArray<T, SIZE : int> 
-{
-    
+{   
     T elements[SIZE];
 };
 
diff --git a/tests/current-bugs/generic/inheritance.slang b/tests/experiments/generic/inheritance.slang
index 6374ccd7f..6374ccd7f 100644
--- a/tests/current-bugs/generic/inheritance.slang
+++ b/tests/experiments/generic/inheritance.slang
diff --git a/tests/current-bugs/generic/int-generic-param.slang b/tests/experiments/generic/int-generic-param.slang
index ba743d0d3..f2f5ebb14 100644
--- a/tests/current-bugs/generic/int-generic-param.slang
+++ b/tests/experiments/generic/int-generic-param.slang
@@ -6,6 +6,8 @@ Fails with:
 
 .slang(7): error 30019: expected an expression of type 'int', got 'typeof(N)'
     return N;
+    
+This is like *fixed-array.slang*. It needs let.    
  */
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
diff --git a/tests/current-bugs/generic/interface.slang b/tests/experiments/generic/interface.slang
index d1d8c60ab..d1d8c60ab 100644
--- a/tests/current-bugs/generic/interface.slang
+++ b/tests/experiments/generic/interface.slang
diff --git a/tests/current-bugs/generic/matrix.slang b/tests/experiments/generic/matrix.slang
index d660b699c..c55c7be33 100644
--- a/tests/current-bugs/generic/matrix.slang
+++ b/tests/experiments/generic/matrix.slang
@@ -2,16 +2,13 @@
 
 /* A test to use generics around resource/built in types. 
 
-Doesn't work
-
-.slang(5): error 30019: expected an expression of type 'int', got 'typeof(W)'
-    matrix<float, W, H> values;
+CRASHES the compiler. 
  */
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
 RWStructuredBuffer<int> outputBuffer;
 
-struct Another<W : int, H : int>
+struct Another<let W : int, let H : int>
 {
     matrix<float, W, H> values;
 };
diff --git a/tests/current-bugs/generic/meta-2.slang b/tests/experiments/generic/meta-2.slang
index 60f33af86..98ae09ce5 100644
--- a/tests/current-bugs/generic/meta-2.slang
+++ b/tests/experiments/generic/meta-2.slang
@@ -2,16 +2,13 @@
 
 /* A test meta programing.
 
-Doesn't work:
-
-.slang(7): error 30019: expected an expression of type 'int', got 'typeof(N)'
-    static const int Value = N;
+CRASHES the compiler(!). Stack overrun.
  */
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
 RWStructuredBuffer<int> outputBuffer;
 
-struct GetValue<N : int>
+struct GetValue<let N : int>
 {
     static const int Value = N;
 };
diff --git a/tests/current-bugs/generic/meta.slang b/tests/experiments/generic/meta.slang
index 8304593b5..8304593b5 100644
--- a/tests/current-bugs/generic/meta.slang
+++ b/tests/experiments/generic/meta.slang
diff --git a/tests/current-bugs/generic/mutating-interface.slang b/tests/experiments/generic/mutating-interface.slang
index 2198b56b2..2198b56b2 100644
--- a/tests/current-bugs/generic/mutating-interface.slang
+++ b/tests/experiments/generic/mutating-interface.slang
diff --git a/tests/current-bugs/generic/operator-overload.slang b/tests/experiments/generic/operator-overload.slang
index 590322171..590322171 100644
--- a/tests/current-bugs/generic/operator-overload.slang
+++ b/tests/experiments/generic/operator-overload.slang
diff --git a/tests/current-bugs/generic/param-specialize-2.slang b/tests/experiments/generic/param-specialize-2.slang
index 478202f2a..04dc2f61c 100644
--- a/tests/current-bugs/generic/param-specialize-2.slang
+++ b/tests/experiments/generic/param-specialize-2.slang
@@ -21,6 +21,7 @@ enum class Enum
     A, B
 };
 
+// NOTE! Here we don't have let!
 int doThing<a : bool, b : int, c : Enum>()
 {
     //if (a)
diff --git a/tests/current-bugs/generic/param-specialize.slang b/tests/experiments/generic/param-specialize.slang
index 4115184a8..cff623827 100644
--- a/tests/current-bugs/generic/param-specialize.slang
+++ b/tests/experiments/generic/param-specialize.slang
@@ -7,8 +7,11 @@ will have those values known at compile time, and presumably lead to a specializ
 
 Does not work because
 
-.slang(11): error 30019: expected an expression of type 'bool', got 'typeof(a)'
-    if (a)
+.slang(24): error 30019: expected an expression of type 'int', got 'Enum'
+    let v = doThing<true, false, Enum::A>();
+                                     ^      
+                                   
+Note that docs say doesn't support any other than int, but error is a bit confusing. No error at declaration.
 */
 
 //TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
@@ -19,7 +22,7 @@ enum class Enum
     A, B
 };
 
-int doThing<a : bool, b : int, c : Enum>()
+int doThing<let a : bool, let b : int, let c : Enum>()
 {
     if (a)
     {
diff --git a/tests/current-bugs/generic/resource.slang b/tests/experiments/generic/resource.slang
index 51cd8a00f..51cd8a00f 100644
--- a/tests/current-bugs/generic/resource.slang
+++ b/tests/experiments/generic/resource.slang
diff --git a/tests/current-bugs/generic/return-generic-2.slang b/tests/experiments/generic/return-generic-2.slang
index 487b20e44..487b20e44 100644
--- a/tests/current-bugs/generic/return-generic-2.slang
+++ b/tests/experiments/generic/return-generic-2.slang
diff --git a/tests/current-bugs/generic/return-generic-3.slang b/tests/experiments/generic/return-generic-3.slang
index 645312d1d..9d6997deb 100644
--- a/tests/current-bugs/generic/return-generic-3.slang
+++ b/tests/experiments/generic/return-generic-3.slang
@@ -1,6 +1,6 @@
 //DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
 
-/* A test of a generic function returning a generic struct.  types. 
+/* A test of a generic function returning a generic struct. 
 
 Works, and deduces the input type of broadcast.
  */
diff --git a/tests/current-bugs/generic/return-generic-4.slang b/tests/experiments/generic/return-generic-4.slang
index d9454169e..d9454169e 100644
--- a/tests/current-bugs/generic/return-generic-4.slang
+++ b/tests/experiments/generic/return-generic-4.slang
diff --git a/tests/experiments/generic/return-generic-5.slang b/tests/experiments/generic/return-generic-5.slang
new file mode 100644
index 000000000..34b90605f
--- /dev/null
+++ b/tests/experiments/generic/return-generic-5.slang
@@ -0,0 +1,30 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test of a generic function returning a generic struct (of built in type). 
+
+Note somewhat silly example because could just use float4(2.0f)
+
+Works.
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+vector<T, N> broadcast<T, let N : int>(T v)
+{
+	vector<T, N> vec;
+    for (int i = 0; i < N; ++i)
+    {
+        vec[i] = v;
+    }
+ 	
+    return vec;
+}
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{    
+    int index = dispatchThreadID.x;
+    let vec = broadcast<float, 4>(2.0f);
+	outputBuffer[index] = dot(vec, vec);
+}
diff --git a/tests/current-bugs/generic/return-generic.slang b/tests/experiments/generic/return-generic.slang
index d107bdafe..d107bdafe 100644
--- a/tests/current-bugs/generic/return-generic.slang
+++ b/tests/experiments/generic/return-generic.slang
diff --git a/tests/current-bugs/generic/scope-type.slang b/tests/experiments/generic/scope-type.slang
index 01c9bfc62..01c9bfc62 100644
--- a/tests/current-bugs/generic/scope-type.slang
+++ b/tests/experiments/generic/scope-type.slang
diff --git a/tests/current-bugs/generic/scope-value-2.slang b/tests/experiments/generic/scope-value-2.slang
index 9b30934b4..9b30934b4 100644
--- a/tests/current-bugs/generic/scope-value-2.slang
+++ b/tests/experiments/generic/scope-value-2.slang
diff --git a/tests/current-bugs/generic/scope-value.slang b/tests/experiments/generic/scope-value.slang
index 8b71c7dcc..8b71c7dcc 100644
--- a/tests/current-bugs/generic/scope-value.slang
+++ b/tests/experiments/generic/scope-value.slang
diff --git a/tests/current-bugs/generic/tuple.slang b/tests/experiments/generic/tuple.slang
index e5362ed6e..e5362ed6e 100644
--- a/tests/current-bugs/generic/tuple.slang
+++ b/tests/experiments/generic/tuple.slang
diff --git a/tests/current-bugs/generic/type-inference-2.slang b/tests/experiments/generic/type-inference-2.slang
index 5108ec90d..5108ec90d 100644
--- a/tests/current-bugs/generic/type-inference-2.slang
+++ b/tests/experiments/generic/type-inference-2.slang
diff --git a/tests/experiments/generic/type-inference-3.slang b/tests/experiments/generic/type-inference-3.slang
new file mode 100644
index 000000000..82691d8c3
--- /dev/null
+++ b/tests/experiments/generic/type-inference-3.slang
@@ -0,0 +1,29 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test of a generic functions with type inference.
+
+.slang(5): internal error 99999: unimplemented feature in Slang compiler: swizzle on vector of unknown size
+    return val.x;
+
+Sort of plausible and in general. But .x would work for any size of vector. 
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+T getFirst<T, let N : int>(vector<T, N> val)
+{
+    return val.x;
+}
+    
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{    
+    int index = dispatchThreadID.x;
+
+    float4 values = { 1, 2, 3, 4 };
+    
+    let val = getFirst(values);
+    
+	outputBuffer[index] = val;
+}
\ No newline at end of file
diff --git a/tests/experiments/generic/type-inference-4.slang b/tests/experiments/generic/type-inference-4.slang
new file mode 100644
index 000000000..cee29e440
--- /dev/null
+++ b/tests/experiments/generic/type-inference-4.slang
@@ -0,0 +1,30 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test of a generic functions with type inference.
+
+Fails in glslang.
+
+glslang:  .slang(13): error :  '[' :  vector index out of range '2'
+glslang:  .slang(13): error :  '' : compilation terminated 
+glslang: note : ERROR: 2 compilation errors.  No code generated.
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+T getFirst<T, let N : int>(vector<T, N> val)
+{
+    return val[2];
+}
+    
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{    
+    int index = dispatchThreadID.x;
+
+    float2 values = { 1, 2 }; 
+    
+    let val = getFirst(values);
+    
+	outputBuffer[index] = val;
+}
\ No newline at end of file
diff --git a/tests/experiments/generic/type-inference-5.slang b/tests/experiments/generic/type-inference-5.slang
new file mode 100644
index 000000000..8254f6065
--- /dev/null
+++ b/tests/experiments/generic/type-inference-5.slang
@@ -0,0 +1,26 @@
+//DISABLE_TEST(compute):COMPARE_COMPUTE_EX:-slang -compute -shaderobj
+
+/* A test of a generic functions with type inference.
+
+Works(!) (even though any swizzle does not)
+ */
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+T getFirst<T, let N : int>(vector<T, N> val)
+{
+    return val[2];
+}
+    
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{    
+    int index = dispatchThreadID.x;
+
+    float4 values = { 1, 2, 3, 4 }; 
+    
+    let val = getFirst(values);
+    
+	outputBuffer[index] = val;
+}
\ No newline at end of file
diff --git a/tests/current-bugs/generic/type-inference.slang b/tests/experiments/generic/type-inference.slang
index 5c8d7efe7..5c8d7efe7 100644
--- a/tests/current-bugs/generic/type-inference.slang
+++ b/tests/experiments/generic/type-inference.slang
diff --git a/tests/current-bugs/generic/type-to-value-2.slang b/tests/experiments/generic/type-to-value-2.slang
index 1be4e59fc..1be4e59fc 100644
--- a/tests/current-bugs/generic/type-to-value-2.slang
+++ b/tests/experiments/generic/type-to-value-2.slang
diff --git a/tests/current-bugs/generic/type-to-value-3.slang b/tests/experiments/generic/type-to-value-3.slang
index 773c0fe5c..773c0fe5c 100644
--- a/tests/current-bugs/generic/type-to-value-3.slang
+++ b/tests/experiments/generic/type-to-value-3.slang
diff --git a/tests/current-bugs/generic/type-to-value-4.slang b/tests/experiments/generic/type-to-value-4.slang
index 986fffaf7..986fffaf7 100644
--- a/tests/current-bugs/generic/type-to-value-4.slang
+++ b/tests/experiments/generic/type-to-value-4.slang
diff --git a/tests/current-bugs/generic/type-to-value-5.slang b/tests/experiments/generic/type-to-value-5.slang
index ce3271d47..ce3271d47 100644
--- a/tests/current-bugs/generic/type-to-value-5.slang
+++ b/tests/experiments/generic/type-to-value-5.slang
diff --git a/tests/current-bugs/generic/type-to-value-6.slang b/tests/experiments/generic/type-to-value-6.slang
index fa7b05cbd..fa7b05cbd 100644
--- a/tests/current-bugs/generic/type-to-value-6.slang
+++ b/tests/experiments/generic/type-to-value-6.slang
diff --git a/tests/current-bugs/generic/type-to-value.slang b/tests/experiments/generic/type-to-value.slang
index 65442212f..65442212f 100644
--- a/tests/current-bugs/generic/type-to-value.slang
+++ b/tests/experiments/generic/type-to-value.slang
diff --git a/tests/experiments/interface/README.md b/tests/experiments/interface/README.md
new file mode 100644
index 000000000..655c5e508
--- /dev/null
+++ b/tests/experiments/interface/README.md
@@ -0,0 +1,5 @@
+Interface Experiments
+=====================
+
+All tests are disabled.
+
diff --git a/tests/experiments/interface/associated-type-2.slang b/tests/experiments/interface/associated-type-2.slang
new file mode 100644
index 000000000..2dd3779d9
--- /dev/null
+++ b/tests/experiments/interface/associated-type-2.slang
@@ -0,0 +1,61 @@
+//DISABLE_TEST:SIMPLE:-target dxil -entry computeMain -profile cs_6_2
+
+/* 
+Testing how an associated type can be used.
+
+Here we try and only use Type returned in IInterface with methods on IInterface, since presubably the 
+impl knows how to deal with it.
+
+Doesn't work.
+
+.slang(52): error 30019: expected an expression of type 'Type', got 'Type'
+    outputBuffer[dispatchThreadID.x] = x + intf.getValue(r, 16);
+
+*/
+
+struct SomeType
+{
+    int getValue(int index) { return index + offset; }
+    
+    int offset;
+};
+
+interface IInterface
+{
+    associatedtype Type;
+    
+    Type get(int offset);
+    int getValue(Type type, int index);
+};
+
+struct InterfaceImpl : IInterface
+{
+    typedef SomeType Type;
+    
+    Type get(int offset) 
+    {
+        Type v;
+        v.offset = offset;
+        return v;
+    }; 
+    int getValue(Type type, int index)
+    {
+        return type.getValue(index);
+    }
+};
+
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(4, 4, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int x = dispatchThreadID.x;
+    
+    InterfaceImpl impl;
+    
+    IInterface intf = impl;
+    
+    var r = intf.get(16);
+    
+    outputBuffer[dispatchThreadID.x] = x + intf.getValue(r, 16);
+}
\ No newline at end of file
diff --git a/tests/experiments/interface/associated-type.slang b/tests/experiments/interface/associated-type.slang
new file mode 100644
index 000000000..2cc4f7c68
--- /dev/null
+++ b/tests/experiments/interface/associated-type.slang
@@ -0,0 +1,59 @@
+//TEST_TEST:SIMPLE:-target dxil -entry computeMain -profile cs_6_2
+
+/* 
+Testing how an associated type can be used.
+
+In this example because we get the Type from the interface, it doesn't know what actual type it is.
+
+.slang(43): error 30027: 'getValue' is not a member of 'Type'.
+    outputBuffer[dispatchThreadID.x] = x + r.getValue(x);
+
+From an error message point of view this perhaps somewhat confusing because there aren't any methods on Type in this context. 
+
+It would be possible for an implementation to determine intf is impl, and do the right thing, although not in general. 
+*/
+
+struct SomeType
+{
+    int getValue(int index) { return index + offset; }
+    
+    int offset;
+};
+
+interface IInterface
+{
+    associatedtype Type;
+    
+    Type get(int offset);
+};
+
+struct InterfaceImpl : IInterface
+{
+    typedef SomeType Type;
+    
+    Type get(int offset) 
+    {
+        Type v;
+        v.offset = offset;
+        return v;
+    }; 
+};
+
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(4, 4, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int x = dispatchThreadID.x;
+    
+    InterfaceImpl impl;
+    
+    IInterface intf = impl;
+    
+    // Works if we get from impl. Doesn't work if we get from the interface
+    // saying that 'Type' doesn't define getValue.
+    
+    var r = intf.get(16);
+    
+    outputBuffer[dispatchThreadID.x] = x + r.getValue(x);
+}
\ No newline at end of file
diff --git a/tests/experiments/interface/resource-associated-type.slang b/tests/experiments/interface/resource-associated-type.slang
new file mode 100644
index 000000000..e5d96a309
--- /dev/null
+++ b/tests/experiments/interface/resource-associated-type.slang
@@ -0,0 +1,63 @@
+//DISABLE_TEST:SIMPLE:-target dxil -entry computeMain -profile cs_6_2
+
+/* 
+
+Doesn't work:
+
+.slang(51): error 30027: 'getValue' is not a member of 'Type'.
+    outputBuffer[dispatchThreadID.x] = x + r.getValue(x);
+                                            ^                 
+    */
+
+interface ISomeInterface
+{
+    int getValue(int index);
+};
+
+struct SomeType : ISomeInterface
+{
+    int getValue(int index) { return data.Load(index + offset); }
+    
+    int offset;
+    ByteAddressBuffer data;     
+};
+
+interface IInterface
+{
+    associatedtype Type;
+    
+    Type get(int offset);
+};
+
+struct InterfaceImpl : IInterface
+{
+    typedef SomeType Type;
+    
+    Type get(int offset) 
+    {
+        Type a;
+        a.offset = offset;
+        a.data = byteAddressBuffer;
+        return a;
+    }; 
+};
+
+ByteAddressBuffer byteAddressBuffer;
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(4, 4, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int x = dispatchThreadID.x;
+    
+    InterfaceImpl impl;
+    
+    IInterface intf = impl;
+    
+    // Works if we get from impl. Doesn't work if we get from the interface
+    // saying that 'Type' doesn't define getValue.
+    
+    var r = intf.get(16);
+    
+    outputBuffer[dispatchThreadID.x] = x + r.getValue(x);
+}
\ No newline at end of file
diff --git a/tests/experiments/interface/return-interface-2.slang b/tests/experiments/interface/return-interface-2.slang
new file mode 100644
index 000000000..1aa6fc5e3
--- /dev/null
+++ b/tests/experiments/interface/return-interface-2.slang
@@ -0,0 +1,55 @@
+//TEST_TEST:SIMPLE:-target dxil -entry computeMain -profile cs_6_2
+
+/* 
+Testing returning an interface type.
+
+Fails with:
+
+.slang(6): error 41011: type 'SomeType' does not fit in the size required by its conforming interface.
+struct SomeType : IGetValue
+^~~~~~
+
+That's understandable in so far as dynamic dispatch appears to assume anyValue(16) by default. On the other hand, the compiler will know all conforming types (well at linkage anyway), and so potentially could work out an appropriate size.
+*/
+
+interface IGetValue
+{
+    int getValue(int index);
+};
+
+struct SomeType : IGetValue
+{
+    __init(int inOffset) { offset = inOffset; another = float4(inOffset); }
+    int getValue(int index) { return index + offset; }
+    int offset;
+    float4 another;
+};
+
+interface IInterface
+{
+    IGetValue get(int offset);
+};
+
+struct InterfaceImpl : IInterface
+{   
+    IGetValue get(int offset) 
+    {
+        return SomeType(offset);
+    }; 
+};
+
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(4, 4, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int x = dispatchThreadID.x;
+    
+    InterfaceImpl impl;
+    
+    IInterface intf = impl;
+       
+    var r = intf.get(16);
+    
+    outputBuffer[dispatchThreadID.x] = x + r.getValue(x);
+}
\ No newline at end of file
diff --git a/tests/experiments/interface/return-interface.slang b/tests/experiments/interface/return-interface.slang
new file mode 100644
index 000000000..d7e55e40c
--- /dev/null
+++ b/tests/experiments/interface/return-interface.slang
@@ -0,0 +1,50 @@
+//TEST_TEST:SIMPLE:-target dxil -entry computeMain -profile cs_6_2
+
+/* 
+Testing returning an interface type.
+ 
+Works.
+
+Uses dynamic dispatch like code - but in the end doesn't require any switches (there is only a single impl). That means it could in principal remove all the extraeous code used assuming it does dynamically dispatch.
+ */
+
+interface IGetValue
+{
+    int getValue(int index);
+};
+
+struct SomeType : IGetValue
+{
+    __init(int inOffset) { offset = inOffset; }
+    int getValue(int index) { return index + offset; }
+    int offset;
+};
+
+interface IInterface
+{
+    IGetValue get(int offset);
+};
+
+struct InterfaceImpl : IInterface
+{   
+    IGetValue get(int offset) 
+    {
+        return SomeType(offset);
+    }; 
+};
+
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(4, 4, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    int x = dispatchThreadID.x;
+    
+    InterfaceImpl impl;
+    
+    IInterface intf = impl;
+       
+    var r = intf.get(16);
+    
+    outputBuffer[dispatchThreadID.x] = x + r.getValue(x);
+}
\ No newline at end of file