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, 57 insertions, 20 deletions

diff --git a/source/slang/check.cpp b/source/slang/check.cpp
index a1b7393fb..6ff8efe9e 100644
--- a/source/slang/check.cpp
+++ b/source/slang/check.cpp
@@ -546,6 +546,12 @@ namespace Slang
                 // No conversion at all
                 kConversionCost_None = 0,
 
+                // Conversions based on explicit sub-typing relationships are the cheapest
+                //
+                // TODO(tfoley): We will eventually need a discipline for ranking
+                // when two up-casts are comparable.
+                kConversionCost_CastToInterface = 50,
+
                 // Conversion that is lossless and keeps the "kind" of the value the same
                 kConversionCost_RankPromotion = 100,
 
@@ -901,6 +907,25 @@ namespace Slang
                     }
                 }
 
+                if (auto toDeclRefType = toType->As<DeclRefType>())
+                {
+                    auto toTypeDeclRef = toDeclRefType->declRef;
+                    if (auto interfaceDeclRef = toTypeDeclRef.As<InterfaceDeclRef>())
+                    {
+                        // Trying to convert to an interface type.
+                        //
+                        // We will allow this if the type conforms to the interface.
+                        if (DoesTypeConformToInterface(fromType, interfaceDeclRef))
+                        {
+                            if (outToExpr)
+                                *outToExpr = CreateImplicitCastExpr(toType, fromExpr);
+                            if (outCost)
+                                *outCost = kConversionCost_CastToInterface;
+                            return true;
+                        }
+                    }
+                }
+
                 // TODO: more cases!
 
                 return false;
@@ -1045,24 +1070,32 @@ namespace Slang
                 return genericDecl;
             }
 
-            virtual void VisitTraitConformanceDecl(TraitConformanceDecl* conformanceDecl) override
+            virtual void visitInterfaceDecl(InterfaceDecl* decl) override
+            {
+                // TODO: do some actual checking of members here
+            }
+
+            virtual void visitInheritanceDecl(InheritanceDecl* inheritanceDecl) override
             {
-                // check the type being conformed to
-                auto base = conformanceDecl->base;
+                // check the type being inherited from
+                auto base = inheritanceDecl->base;
                 base = TranslateTypeNode(base);
-                conformanceDecl->base = base;
+                inheritanceDecl->base = base;
+
+                // For now we only allow inheritance from interfaces, so
+                // we will validate that the type expression names an interface
 
                 if(auto declRefType = base.type->As<DeclRefType>())
                 {
-                    if(auto traitDeclRef = declRefType->declRef.As<TraitDeclRef>())
+                    if(auto interfaceDeclRef = declRefType->declRef.As<InterfaceDeclRef>())
                     {
-                        conformanceDecl->traitDeclRef = traitDeclRef;
                         return;
                     }
                 }
 
-                // We expected a trait here
-                getSink()->diagnose( conformanceDecl, Diagnostics::expectedATraitGot, base.type);
+                // If type expression didn't name an interface, we'll emit an error here
+                // TODO: deal with the case of an error in the type expression (don't cascade)
+                getSink()->diagnose( base.exp, Diagnostics::expectedAnInterfaceGot, base.type);
             }
 
             RefPtr<ConstantIntVal> checkConstantIntVal(
@@ -2479,20 +2512,24 @@ namespace Slang
                     vectorType->elementCount);
             }
 
-            bool DoesTypeConformToTrait(
+            bool DoesTypeConformToInterface(
                 RefPtr<ExpressionType>  type,
-                TraitDeclRef            traitDeclRef)
+                InterfaceDeclRef        interfaceDeclRef)
             {
                 // for now look up a conformance member...
                 if(auto declRefType = type->As<DeclRefType>())
                 {
                     if( auto aggTypeDeclRef = declRefType->declRef.As<AggTypeDeclRef>() )
                     {
-                        for( auto conformanceRef : aggTypeDeclRef.GetMembersOfType<TraitConformanceDeclRef>())
+                        for( auto inheritanceDeclRef : aggTypeDeclRef.GetMembersOfType<InheritanceDeclRef>())
                         {
-                            EnsureDecl(conformanceRef.GetDecl());
+                            EnsureDecl(inheritanceDeclRef.GetDecl());
+
+                            auto inheritedDeclRefType = inheritanceDeclRef.getBaseType()->As<DeclRefType>();
+                            if (!inheritedDeclRefType)
+                                continue;
 
-                            if(traitDeclRef.Equals(conformanceRef.GetTraitDeclRef()))
+                            if(interfaceDeclRef.Equals(inheritedDeclRefType->declRef))
                                 return true;
                         }
                     }
@@ -2502,12 +2539,12 @@ namespace Slang
                 return false;
             }
 
-            RefPtr<ExpressionType> TryJoinTypeWithTrait(
+            RefPtr<ExpressionType> TryJoinTypeWithInterface(
                 RefPtr<ExpressionType>  type,
-                TraitDeclRef            traitDeclRef)
+                InterfaceDeclRef        interfaceDeclRef)
             {
                 // The most basic test here should be: does the type declare conformance to the trait.
-                if(DoesTypeConformToTrait(type, traitDeclRef))
+                if(DoesTypeConformToInterface(type, interfaceDeclRef))
                     return type;
 
                 // There is a more nuanced case if `type` is a builtin type, and we need to make it
@@ -2590,18 +2627,18 @@ namespace Slang
                 // HACK: trying to work trait types in here...
                 if(auto leftDeclRefType = left->As<DeclRefType>())
                 {
-                    if( auto leftTraitRef = leftDeclRefType->declRef.As<TraitDeclRef>() )
+                    if( auto leftInterfaceRef = leftDeclRefType->declRef.As<InterfaceDeclRef>() )
                     {
                         // 
-                        return TryJoinTypeWithTrait(right, leftTraitRef);
+                        return TryJoinTypeWithInterface(right, leftInterfaceRef);
                     }
                 }
                 if(auto rightDeclRefType = right->As<DeclRefType>())
                 {
-                    if( auto rightTraitRef = rightDeclRefType->declRef.As<TraitDeclRef>() )
+                    if( auto rightInterfaceRef = rightDeclRefType->declRef.As<InterfaceDeclRef>() )
                     {
                         // 
-                        return TryJoinTypeWithTrait(left, rightTraitRef);
+                        return TryJoinTypeWithInterface(left, rightInterfaceRef);
                     }
                 }