From adb1131d08f28f0bc5f729e88b73cf22846c86c5 Mon Sep 17 00:00:00 2001
From: Tim Foley <tfoleyNV@users.noreply.github.com>
Date: Fri, 5 Feb 2021 09:01:36 -0800
Subject: Initial implementation of interface conjunctions (#1691)

The basic feature here is the ability to use the `&` operator to produce the conjunction/intersection of two interfaces. That is, you can have interfaces:

    interface IFirst { int getFirst(); }
    interface ISecond { int getSecoond(); }

and if you need a generic function where the type parameter `T` must conform to *both* of these interfaces, you express that by constraining the parameter to the intersection of the interfaces:

    void someFunction<T : IFirst & ISecond>(T value) { ... }

Without this feature, the main alternative an application would have is to define an intermediate interface, like:

    interface IBoth : IFirst, ISecond {}

Forcing users to deal with an intermediate interface creates more work for type authors (they need to remember to inherit from the right combined interface(s)), or for `extension` authors (when you add `ISecond` to a type that used to just support `IFirst`, you had better also add `IBoth`). In the worst case, a family of N related "leaf" interfaces would give rise to an exponential number of intermediate interfaces to represnt the possible combinations.

A conjunction like `IFirst & ISecond` is officially its own type, and can be used to declare a type alias:

    typealias IBoth = IFirst & ISecond;

This change only includes the first pass of work on this feature, so there are several caveats to be aware of:

* Using a conjunction as part of an inheritance clause is not yet supported (e.g., `struct X : IFirst & ISecond`). This is true even if the conjunction was introduced by an intermediate `typealias`

* The `&` syntax introduced here is only parsed in places where only a type (not an expression) is possible. This means you cannot do things like cast to a conjunction with `(IFirst & ISecond)(someValue)`.

* This work *should* apply to conjunctions of more than two interfaces (like `IA & IB & IC`) but that has not yet been tested

* In the long run it may be sensible to allow conjunctions that use concrete types, but we really ought to have the semantic checking logic rule that out for now.

* During testing, I encountered compiler crashes when trying to use this feature together with `property` declarations. Further investigation and debugging is called for.

* The handling of conjunction types is currently incomplete, in that there are many equivalences the compiler does not yet understand. For example, it is clear that `IA & IB` is equivalent to `IB & IA`, but the compiler currently does not understand this and will treat them as different types. A deeper implementation approach is called for.

* Conjunctions are currently only supported for generic type parameter constraints, when performing full specialization. Use of conjunctions for existential-type value parameters or with dynamic dispatch is not yet supported.
---
 .../interfaces/interface-conjunction.slang         | 49 ++++++++++++++++++++++
 .../interface-conjunction.slang.expected.txt       |  4 ++
 2 files changed, 53 insertions(+)
 create mode 100644 tests/language-feature/interfaces/interface-conjunction.slang
 create mode 100644 tests/language-feature/interfaces/interface-conjunction.slang.expected.txt

(limited to 'tests/language-feature')

diff --git a/tests/language-feature/interfaces/interface-conjunction.slang b/tests/language-feature/interfaces/interface-conjunction.slang
new file mode 100644
index 000000000..b5ec708a5
--- /dev/null
+++ b/tests/language-feature/interfaces/interface-conjunction.slang
@@ -0,0 +1,49 @@
+// interface-conjunction.slang
+
+// Test that we can compose interfaces with `&`
+
+//TEST(compute):COMPARE_COMPUTE: -shaderobj
+
+interface IFirst
+{
+    int getFirst();
+}
+
+interface ISecond
+{
+    int getSecond();
+}
+
+struct Pair : IFirst, ISecond
+{
+    int first;
+    int second;
+
+    int getFirst() { return first; }
+    int getSecond() { return second; }
+}
+
+typealias IBoth = IFirst & ISecond;
+
+int add<T : IBoth>(T input)
+{
+    return 2*input.getFirst() + input.getSecond();
+}
+
+int test(int value)
+{
+    Pair p = { value, (value+1) * 256 };
+    return add(p);
+}
+
+//TEST_INPUT:ubuffer(data=[0 0 0 0], stride=4):out,name=outputBuffer
+RWStructuredBuffer<int> outputBuffer;
+
+[numthreads(4, 1, 1)]
+void computeMain(uint3 dispatchThreadID : SV_DispatchThreadID)
+{
+    uint tid = dispatchThreadID.x;
+    int inVal = tid;
+    int outVal = test(inVal);
+    outputBuffer[tid] = outVal;
+}
diff --git a/tests/language-feature/interfaces/interface-conjunction.slang.expected.txt b/tests/language-feature/interfaces/interface-conjunction.slang.expected.txt
new file mode 100644
index 000000000..23f910a90
--- /dev/null
+++ b/tests/language-feature/interfaces/interface-conjunction.slang.expected.txt
@@ -0,0 +1,4 @@
+100
+202
+304
+406
-- 
cgit v1.2.3