Add basic support for `interface` declarations

- Add a test case for `interface` declarations and the exected implicit type conversion rules around them

- Rename exising "trait" declaration kind to "interface"
  - There was already basic syntax for `__trait` declarations, and a bunch of related machinery.
  - Not all of it worked as needed, but it was clearly a start at solving the problem

- Change `InterfaceConformanceDecl` to a more general `InheritanceDecl` that covers inheritance from any type expression (leave it to other code to validate the cases that should be allowed)

- Instead of keeping a raw `bases` array on interface/trait declarations, turn all inheritance clauses into `IheritanceDecl` members

- Add support for inheritance clause on `struct` types

- Remove the `__conforms` syntax only used in the stdlib, in favor of conentional `: Base` style syntax already in place for aggregate types

- Make sure that the parser pushes a new scope around he member declarations of an aggregate type, so that lookup in member functions will correctly find members of the enclosing type

- In `TryCoerceImpl`, allow a type that conforms to an interface to be implicitly conveted to the corresponding interface type.

This leaves out a lot of major functionality:

- There is no validation that a type provides all the members it is supposed to as part of fulfilling a claimed interface conformance

- The lookup process needs to deal with inherited members at some point.
  - We can avoid this for now if we don't allow inheritance for concrete types
  - When it comes time to handle it, it *might* be possible to implement by considering an `InheritanceDecl` to be, conceptually, a member of the inherited type, with a `__transparent` modifier

- The lookup rules member functions do *not* deal with a lot of stuff:
  - There is no `this` expression right now
  - The semantic checker does not rewrite `foo` to `this.foo`, so downstream stages aren't going to get things in a clean format
  - There is no handling of mutability currently
    - The right answer there is probably to make member functions on `struct` types non-mutating by default, and add a qualifier to opt in to mutability. I believe this is actually what the OOP syntax in HLSL did way back when.
  - There is no handling of `static` members, and thus no checking to make sure that non-static members aren't referenced in static functions

- None of this affects down-stream code generation right now, so it probably won't actually produce anything valid.
  - This is where we start needing a suitable IR to use for lowering, to manage the complexity.

1 files changed, 6 insertions, 6 deletions

diff --git a/source/slang/syntax.cpp b/source/slang/syntax.cpp
index fffc6c725..e47c610c0 100644
--- a/source/slang/syntax.cpp
+++ b/source/slang/syntax.cpp
@@ -1311,19 +1311,19 @@ namespace Slang
             return visitor->VisitDefaultStmt(this);
         }
 
-        // TraitDecl
+        // InterfaceDecl
 
-        RefPtr<SyntaxNode> TraitDecl::Accept(SyntaxVisitor * visitor)
+        RefPtr<SyntaxNode> InterfaceDecl::Accept(SyntaxVisitor * visitor)
         {
-            visitor->VisitTraitDecl(this);
+            visitor->visitInterfaceDecl(this);
             return this;
         }
 
-        // TraitConformanceDecl
+        // InheritanceDecl
 
-        RefPtr<SyntaxNode> TraitConformanceDecl::Accept(SyntaxVisitor * visitor)
+        RefPtr<SyntaxNode> InheritanceDecl::Accept(SyntaxVisitor * visitor)
         {
-            visitor->VisitTraitConformanceDecl(this);
+            visitor->visitInheritanceDecl(this);
             return this;
         }