From 367edf757aff609b72de48732113ea756d878f52 Mon Sep 17 00:00:00 2001 From: Tim Foley Date: Thu, 15 Jun 2017 11:16:10 -0700 Subject: 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. --- source/slang/check.cpp | 77 +++++++++++++++++++++++++++++++++++++------------- 1 file changed, 57 insertions(+), 20 deletions(-) (limited to 'source/slang/check.cpp') 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()) + { + auto toTypeDeclRef = toDeclRefType->declRef; + if (auto interfaceDeclRef = toTypeDeclRef.As()) + { + // 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()) { - if(auto traitDeclRef = declRefType->declRef.As()) + if(auto interfaceDeclRef = declRefType->declRef.As()) { - 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 checkConstantIntVal( @@ -2479,20 +2512,24 @@ namespace Slang vectorType->elementCount); } - bool DoesTypeConformToTrait( + bool DoesTypeConformToInterface( RefPtr type, - TraitDeclRef traitDeclRef) + InterfaceDeclRef interfaceDeclRef) { // for now look up a conformance member... if(auto declRefType = type->As()) { if( auto aggTypeDeclRef = declRefType->declRef.As() ) { - for( auto conformanceRef : aggTypeDeclRef.GetMembersOfType()) + for( auto inheritanceDeclRef : aggTypeDeclRef.GetMembersOfType()) { - EnsureDecl(conformanceRef.GetDecl()); + EnsureDecl(inheritanceDeclRef.GetDecl()); + + auto inheritedDeclRefType = inheritanceDeclRef.getBaseType()->As(); + if (!inheritedDeclRefType) + continue; - if(traitDeclRef.Equals(conformanceRef.GetTraitDeclRef())) + if(interfaceDeclRef.Equals(inheritedDeclRefType->declRef)) return true; } } @@ -2502,12 +2539,12 @@ namespace Slang return false; } - RefPtr TryJoinTypeWithTrait( + RefPtr TryJoinTypeWithInterface( RefPtr 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()) { - if( auto leftTraitRef = leftDeclRefType->declRef.As() ) + if( auto leftInterfaceRef = leftDeclRefType->declRef.As() ) { // - return TryJoinTypeWithTrait(right, leftTraitRef); + return TryJoinTypeWithInterface(right, leftInterfaceRef); } } if(auto rightDeclRefType = right->As()) { - if( auto rightTraitRef = rightDeclRefType->declRef.As() ) + if( auto rightInterfaceRef = rightDeclRefType->declRef.As() ) { // - return TryJoinTypeWithTrait(left, rightTraitRef); + return TryJoinTypeWithInterface(left, rightInterfaceRef); } } -- cgit v1.2.3