From d655302465457c5d3285ae5339201a0769cc38dc Mon Sep 17 00:00:00 2001 From: Yong He Date: Thu, 5 Sep 2024 11:24:19 -0700 Subject: Support `where` clause and type equality constraint. (#4986) * Support `where` clause. * Fix. * Fix parser. * Enhance test to cover traditional __generic syntax. * Update user-guide. * Support `where` clause on associatedtype. * Fix. * Put in more comments. --- tests/bugs/eroneous-generic-parse.slang | 3 +- tests/bugs/eroneous-generic-parse.slang.expected | 8 ---- tests/bugs/parser-infinite-loop.slang | 3 +- tests/bugs/parser-infinite-loop.slang.expected | 11 ----- tests/language-feature/generics/where-1.slang | 20 +++++++++ tests/language-feature/generics/where-2.slang | 33 +++++++++++++++ tests/language-feature/generics/where-3.slang | 36 ++++++++++++++++ tests/language-feature/generics/where-4.slang | 52 ++++++++++++++++++++++++ 8 files changed, 145 insertions(+), 21 deletions(-) delete mode 100644 tests/bugs/eroneous-generic-parse.slang.expected delete mode 100644 tests/bugs/parser-infinite-loop.slang.expected create mode 100644 tests/language-feature/generics/where-1.slang create mode 100644 tests/language-feature/generics/where-2.slang create mode 100644 tests/language-feature/generics/where-3.slang create mode 100644 tests/language-feature/generics/where-4.slang (limited to 'tests') diff --git a/tests/bugs/eroneous-generic-parse.slang b/tests/bugs/eroneous-generic-parse.slang index 80a693456..18bcb3b1e 100644 --- a/tests/bugs/eroneous-generic-parse.slang +++ b/tests/bugs/eroneous-generic-parse.slang @@ -1,8 +1,9 @@ -//DIAGNOSTIC_TEST:SIMPLE: -target hlsl -entry computeMain -stage compute +//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK): -target hlsl -entry computeMain -stage compute //TEST_INPUT:ubuffer(data=[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0], stride=16):out RWStructuredBuffer outputBuffer; +// CHECK: error 20001 // Previously this definition would lead to an infinite loop in parsing. int doThing<1>() { return 2; } diff --git a/tests/bugs/eroneous-generic-parse.slang.expected b/tests/bugs/eroneous-generic-parse.slang.expected deleted file mode 100644 index a6ee73d88..000000000 --- a/tests/bugs/eroneous-generic-parse.slang.expected +++ /dev/null @@ -1,8 +0,0 @@ -result code = -1 -standard error = { -tests/bugs/eroneous-generic-parse.slang(7): error 20001: unexpected integer literal, expected identifier -int doThing<1>() { return 2; } - ^ -} -standard output = { -} diff --git a/tests/bugs/parser-infinite-loop.slang b/tests/bugs/parser-infinite-loop.slang index 70abc9260..036202c4a 100644 --- a/tests/bugs/parser-infinite-loop.slang +++ b/tests/bugs/parser-infinite-loop.slang @@ -1,5 +1,6 @@ -//DIAGNOSTIC_TEST:SIMPLE: +//DIAGNOSTIC_TEST:SIMPLE(filecheck=CHECK): +// CHECK: error 20001: struct test { float3 field; diff --git a/tests/bugs/parser-infinite-loop.slang.expected b/tests/bugs/parser-infinite-loop.slang.expected deleted file mode 100644 index df1d731bc..000000000 --- a/tests/bugs/parser-infinite-loop.slang.expected +++ /dev/null @@ -1,11 +0,0 @@ -result code = -1 -standard error = { -tests/bugs/parser-infinite-loop.slang(10): error 20001: unexpected integer literal, expected identifier - vector v; - ^ -tests/bugs/parser-infinite-loop.slang(10): error 20001: unexpected identifier, expected '(' - vector v; - ^ -} -standard output = { -} diff --git a/tests/language-feature/generics/where-1.slang b/tests/language-feature/generics/where-1.slang new file mode 100644 index 000000000..904e03d52 --- /dev/null +++ b/tests/language-feature/generics/where-1.slang @@ -0,0 +1,20 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -shaderobj -output-using-type +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -vk -shaderobj -output-using-type + +// Test that we can use `where` clause to constrain generic type parameters. + +T process(vector v) where T : IFloat +{ + return v[0]; +} + +//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +[numthreads(1,1,1)] +void computeMain() +{ + float a = 1.0; + outputBuffer[0] = process(a); + // CHECK: 1.0 +} diff --git a/tests/language-feature/generics/where-2.slang b/tests/language-feature/generics/where-2.slang new file mode 100644 index 000000000..b3e9bb86a --- /dev/null +++ b/tests/language-feature/generics/where-2.slang @@ -0,0 +1,33 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -shaderobj -output-using-type +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -vk -shaderobj -output-using-type + +// Test that we can use `where` clause to constrain associatedtype of generic type parameters. + +interface IFoo +{ + associatedtype TA; +} + +struct FooImpl : IFoo +{ + typealias TA = int; +} + +__generic +T.TA process(T v) + where T : IFoo + where T.TA == int +{ + return 1; +} + +//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +[numthreads(1,1,1)] +void computeMain() +{ + FooImpl fooImpl; + outputBuffer[0] = process(fooImpl); + // CHECK: 1.0 +} diff --git a/tests/language-feature/generics/where-3.slang b/tests/language-feature/generics/where-3.slang new file mode 100644 index 000000000..730373b76 --- /dev/null +++ b/tests/language-feature/generics/where-3.slang @@ -0,0 +1,36 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -shaderobj -output-using-type +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -vk -shaderobj -output-using-type + +// Test that we can use `where` clause to constrain the type of a type pack. + +interface IFoo +{ + associatedtype TA; +} + +struct FooImpl : IFoo +{ + typealias TA = int; +} + +void add(inout int a, int b) +{ + a += b; +} + +int process(T v) where T == int +{ + int result = 0; + expand add(result, each v); + return result; +} + +//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +[numthreads(1,1,1)] +void computeMain() +{ + outputBuffer[0] = process(1,2,3); + // CHECK: 6.0 +} diff --git a/tests/language-feature/generics/where-4.slang b/tests/language-feature/generics/where-4.slang new file mode 100644 index 000000000..9f86ca7dc --- /dev/null +++ b/tests/language-feature/generics/where-4.slang @@ -0,0 +1,52 @@ +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -shaderobj -output-using-type +//TEST(compute):COMPARE_COMPUTE(filecheck-buffer=CHECK): -vk -shaderobj -output-using-type + +// Test that we can use `where` clause to constrain an associatedtype. + +interface IBar +{ + associatedtype TB; + TB get(); +} + +interface IFoo +{ + associatedtype TA : IBar where TA.TB == int; + + TA getVal(); +} + +struct BarImpl : IBar +{ + typealias TB = int; + int x; + int get() { return x; } +} + +struct FooImpl : IFoo +{ + typealias TA = BarImpl; + TA getVal() { TA a; a.x = 1; return a; } +} + +int helper(T foo) +{ + // foo.getVal().get() has type `T.TA.TB`, + // because there is a type equality constraint defined on + // `IFoo.TA` such that `IFoo::TA.TB == int`, we should be able + // to conclude that `T.TA.TB` is `int` and the `return` here + // should type check. + return foo.getVal().get(); +} + +//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer +RWStructuredBuffer outputBuffer; + +[numthreads(1,1,1)] +void computeMain() +{ + FooImpl foo; + + outputBuffer[0] = helper(foo); + // CHECK: 1.0 +} -- cgit v1.2.3