Initial support for enum declarations (shader-slang#599)

Slang `enum` declarations will always be scoped, e.g.:

```hlsl
enum Color
{
    Red,
    Green = 2,
    Blue,
}

Color c = Color.Red; // Not just `Red`
```

A user can write `enum class` as a placebo for now (to ease sharing of headers with C++).
Slang does not currently support the `::` operator for static member lookup, so it must be `Color.Green` and not `Color::Green`. Support for `::` as an alternate syntax could be added later if there is strong user demand.

An `enum` type can have a declared "tag type" using syntax like C++ `enum class`:

```hlsl
enum MyThings : uint
{
    First = 0,
    // ...
}
```

The `enum` cases will store their values using that type. An `enum` that doesn't declare a tag type will use the type `int` by default.

Enum cases are assigned values just like in C/C++: cases can have explicit values, but otherwise default to one more than the previous case, or zero for the first case.

All `enum` types will automatically conform to a standard-library `interface` called `__EnumType`, which is used so that basic operators like equality testing can be defined generically for all `enum` types.
This change only adds one operator at first (the `==` comparison), but other should be added later.

An `enum` case needs to be explicitly converted to an integer where needed (e.g., `int(Color.Red)`).
This is implemented by having the main integer types (`int` and `uint`) support built-in initializers that can work for *any* `enum` type (or rather, anything conforming to `__EnumType`).
Eventually these will be restricted so that an `enum` type can only be converted to its associated tag type.

IR code generation completely eliminates `enum` types and their cases.
The `enum` type will be replaced with its tag type, and the cases will be replaced with the tag values.
Currently this could leave some mess in the IR where cast operations are applied between values that actually have the same type.

Author: Tim Foley

source/slang/check.cpp

@@ -113,8 +113,8 @@ namespace Slang
 
         // The name of the entry point function (e.g., `main`)
         Name* name;
-        
-        // The type names we want to substitute into the 
+
+        // The type names we want to substitute into the
         // global generic type parameters
         List<String> genericParameterTypeNames;
 
@@ -373,7 +373,7 @@ namespace Slang
         ~CompileRequest();
 
         RefPtr<Expr> parseTypeString(TranslationUnitRequest * translationUnit, String typeStr, RefPtr<Scope> scope);
-        
+
         Type* getTypeFromString(String typeStr);
 
         void parseTranslationUnit(
@@ -526,6 +526,8 @@ namespace Slang
         Type* getErrorType();
         Type* getStringType();
 
+        Type* getEnumTypeType();
+
         // Construct the type `Ptr<valueType>`, where `Ptr`
         // is looked up as a builtin type.
         RefPtr<PtrType> getPtrType(RefPtr<Type> valueType);
@@ -572,4 +574,4 @@ namespace Slang
 
 }
 
-#endif
+#endif

source/slang/compiler.h

@@ -28,6 +28,23 @@ interface __BuiltinFloatingPointType : __BuiltinRealType, __BuiltinSignedArithme
     __init(float value);
 }
 
+// A type resulting from an `enum` declaration.
+__magic_type(EnumTypeType)
+interface __EnumType
+{
+    // The type of tags for this `enum`
+    //
+    // Note: using `__Tag` instead of `Tag` to avoid any
+    // conflict if a user had an `enum` case called `Tag`
+    associatedtype __Tag : __BuiltinIntegerType;
+};
+
+// A type resulting from an `enum` declaration
+// with the `[flags]` attribute.
+interface __FlagsEnumType : __EnumType
+{
+};
+
 __generic<T,U> __intrinsic_op(Sequence) U operator,(T left, U right);
 
 __generic<T> __intrinsic_op(select) T operator?:(bool condition, T ifTrue, T ifFalse);
@@ -92,6 +109,28 @@ for (int tt = 0; tt < kBaseTypeCount; ++tt)
         sb << "__init(" << kBaseTypes[ss].name << " value);\n";
     }
 
+    // If this is a basic integer type, then define explicit
+    // initializers that take a value of an `enum` type.
+    //
+    // TODO: This should actually be restricted, so that this
+    // only applies `where T.__Tag == Self`, but we don't have
+    // the needed features in our type system to implement
+    // that constraint right now.
+    //
+    switch (kBaseTypes[tt].tag)
+    {
+    case BaseType::Int:
+    case BaseType::UInt:
+}}}}
+        __generic<T:__EnumType>
+        __init(T value);
+${{{{
+        break;
+
+    default:
+        break;
+    }
+
     sb << "};\n";
 }
 
@@ -1050,6 +1089,12 @@ for (auto op : binaryOps)
 }
 }}}}
 
+// Operators to apply to `enum` types
+
+__generic<E : __EnumType>
+__intrinsic_op($(kIROp_Eql))
+bool operator==(E left, E right);
+
 // Statement Attributes
 
 __attributeTarget(LoopStmt)

source/slang/core.meta.slang

@@ -28,6 +28,23 @@ SLANG_RAW("    // a floating-point value...\n")
 SLANG_RAW("    __init(float value);\n")
 SLANG_RAW("}\n")
 SLANG_RAW("\n")
+SLANG_RAW("// A type resulting from an `enum` declaration.\n")
+SLANG_RAW("__magic_type(EnumTypeType)\n")
+SLANG_RAW("interface __EnumType\n")
+SLANG_RAW("{\n")
+SLANG_RAW("    // The type of tags for this `enum`\n")
+SLANG_RAW("    //\n")
+SLANG_RAW("    // Note: using `__Tag` instead of `Tag` to avoid any\n")
+SLANG_RAW("    // conflict if a user had an `enum` case called `Tag`\n")
+SLANG_RAW("    associatedtype __Tag : __BuiltinIntegerType;\n")
+SLANG_RAW("};\n")
+SLANG_RAW("\n")
+SLANG_RAW("// A type resulting from an `enum` declaration\n")
+SLANG_RAW("// with the `[flags]` attribute.\n")
+SLANG_RAW("interface __FlagsEnumType : __EnumType\n")
+SLANG_RAW("{\n")
+SLANG_RAW("};\n")
+SLANG_RAW("\n")
 SLANG_RAW("__generic<T,U> __intrinsic_op(Sequence) U operator,(T left, U right);\n")
 SLANG_RAW("\n")
 SLANG_RAW("__generic<T> __intrinsic_op(select) T operator?:(bool condition, T ifTrue, T ifFalse);\n")
@@ -92,6 +109,28 @@ for (int tt = 0; tt < kBaseTypeCount; ++tt)
         sb << "__init(" << kBaseTypes[ss].name << " value);\n";
     }
 
+    // If this is a basic integer type, then define explicit
+    // initializers that take a value of an `enum` type.
+    //
+    // TODO: This should actually be restricted, so that this
+    // only applies `where T.__Tag == Self`, but we don't have
+    // the needed features in our type system to implement
+    // that constraint right now.
+    //
+    switch (kBaseTypes[tt].tag)
+    {
+    case BaseType::Int:
+    case BaseType::UInt:
+SLANG_RAW("\n")
+SLANG_RAW("        __generic<T:__EnumType>\n")
+SLANG_RAW("        __init(T value);\n")
+
+        break;
+
+    default:
+        break;
+    }
+
     sb << "};\n";
 }
 
@@ -1065,6 +1104,15 @@ for (auto op : binaryOps)
 }
 SLANG_RAW("\n")
 SLANG_RAW("\n")
+SLANG_RAW("// Operators to apply to `enum` types\n")
+SLANG_RAW("\n")
+SLANG_RAW("__generic<E : __EnumType>\n")
+SLANG_RAW("__intrinsic_op(")
+SLANG_SPLICE(kIROp_Eql
+)
+SLANG_RAW(")\n")
+SLANG_RAW("bool operator==(E left, E right);\n")
+SLANG_RAW("\n")
 SLANG_RAW("// Statement Attributes\n")
 SLANG_RAW("\n")
 SLANG_RAW("__attributeTarget(LoopStmt)\n")

source/slang/core.meta.slang.h

@@ -87,6 +87,19 @@ SIMPLE_SYNTAX_CLASS(StructDecl, AggTypeDecl)
 
 SIMPLE_SYNTAX_CLASS(ClassDecl, AggTypeDecl)
 
+// TODO: Is it appropriate to treat an `enum` as an aggregate type?
+// Most code that looks for, e.g., conformances assumes user-defined
+// types are all `AggTypeDecl`, so this is the right choice for now
+// if we want `enum` types to be able to implement interfaces, etc.
+//
+SYNTAX_CLASS(EnumDecl, AggTypeDecl)
+RAW(
+    RefPtr<Type> tagType;
+)
+END_SYNTAX_CLASS()
+
+SIMPLE_SYNTAX_CLASS(EnumCaseDecl, VarDeclBase)
+
 // An interface which other types can conform to
 SIMPLE_SYNTAX_CLASS(InterfaceDecl, AggTypeDecl)
 
@@ -135,7 +148,7 @@ END_SYNTAX_CLASS()
 SYNTAX_CLASS(AssocTypeDecl, AggTypeDecl)
 END_SYNTAX_CLASS()
 
-// A '__generic_param' declaration, which defines a generic 
+// A '__generic_param' declaration, which defines a generic
 // entry-point parameter. Is a container of GenericTypeConstraintDecl
 SYNTAX_CLASS(GlobalGenericParamDecl, AggTypeDecl)
 END_SYNTAX_CLASS()

source/slang/decl-defs.h

@@ -197,8 +197,10 @@ DIAGNOSTIC(30049, Note,  thisIsImmutableByDefault, "a 'this' parameter is curren
 
 DIAGNOSTIC(30051, Error, invalidValueForArgument, "invalid value for argument '$0'")
 DIAGNOSTIC(30052, Error, invalidSwizzleExpr, "invalid swizzle pattern '$0' on type '$1'")
-DIAGNOSTIC(33070, Error, expectedFunction, "expression preceding parenthesis of apparent call must have function type.")
 
+DIAGNOSTIC(30100, Error, staticRefToNonStaticMember, "type '$0' cannot be used to refer to non-static member '$1'")
+
+DIAGNOSTIC(33070, Error, expectedFunction, "expression preceding parenthesis of apparent call must have function type.")
 DIAGNOSTIC(33071, Error, expectedAStringLiteral, "expected a string literal")
 
 // Attributes
@@ -208,6 +210,14 @@ DIAGNOSTIC(31001, Error, attributeNotApplicable, "attribute '$0' is not valid he
 
 DIAGNOSTIC(31100, Error, unknownStageName,  "unknown stage name '$0'")
 
+// Enums
+
+DIAGNOSTIC(32000, Error, invalidEnumTagType,        "invalid tag type for 'enum': '$0'")
+DIAGNOSTIC(32001, Error, enumTypeAlreadyHasTagType, "'enum' type has already declared a tag type")
+DIAGNOSTIC(32002, Note,  seePreviousTagType,        "see previous tag type declaration")
+DIAGNOSTIC(32003, Error, unexpectedEnumTagExpr,     "unexpected form for 'enum' tag value expression")
+
+
 
 // 303xx: interfaces and associated types
 DIAGNOSTIC(30300, Error, assocTypeInInterfaceOnly, "'associatedtype' can only be defined in an 'interface'.")

source/slang/diagnostic-defs.h

@@ -2668,6 +2668,9 @@ struct StmtLoweringVisitor : StmtVisitor<StmtLoweringVisitor>
     // so we need to track a bit of extra data:
     struct SwitchStmtInfo
     {
+        // The block that will be made to contain the `switch` statement
+        IRBlock* initialBlock = nullptr;
+
         // The label for the `default` case, if any.
         IRBlock*    defaultLabel = nullptr;
 
@@ -2757,12 +2760,21 @@ struct StmtLoweringVisitor : StmtVisitor<StmtLoweringVisitor>
             // for the best.
             //
             // TODO: figure out something cleaner.
-            auto caseVal = getSimpleVal(context, lowerRValueExpr(context, caseStmt->expr));
+
+            // Actually, one gotcha is that if we ever allow non-constant
+            // expressions here (or anything that requires instructions
+            // to be emitted to yield its value), then those instructions
+            // need to go into an appropriate block.
+
+            IRGenContext subContext = *context;
+            IRBuilder subBuilder = *getBuilder();
+            subBuilder.setInsertInto(info->initialBlock);
+            subContext.irBuilder = &subBuilder;
+            auto caseVal = getSimpleVal(context, lowerRValueExpr(&subContext, caseStmt->expr));
 
             // Figure out where we are branching to.
             auto label = getLabelForCase(info);
 
-
             // Add this `case` to the list for the enclosing `switch`.
             info->cases.Add(caseVal);
             info->cases.Add(label);
@@ -2863,6 +2875,7 @@ struct StmtLoweringVisitor : StmtVisitor<StmtLoweringVisitor>
         // Iterate over the body of the statement, looking
         // for `case` or `default` statements:
         SwitchStmtInfo info;
+        info.initialBlock = initialBlock;
         info.defaultLabel = nullptr;
         lowerSwitchCases(stmt->body, &info);
 
@@ -3760,6 +3773,59 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
         setMangledName(inst, context->getSession()->getNameObj(name));
     }
 
+    LoweredValInfo visitEnumCaseDecl(EnumCaseDecl* decl)
+    {
+        // A case within an `enum` decl will lower to a value
+        // of the `enum`'s "tag" type.
+        //
+        // TODO: a bit more work will be needed if we allow for
+        // enum cases that have payloads, because then we need
+        // a function that constructs the value given arguments.
+
+        IRBuilder subBuilderStorage = *getBuilder();
+        IRBuilder* subBuilder = &subBuilderStorage;
+
+        // Emit any generics that should wrap the actual type.
+        emitOuterGenerics(subBuilder, decl, decl);
+
+        IRGenContext subContextStorage = *context;
+        IRGenContext* subContext = &subContextStorage;
+        subContext->irBuilder = subBuilder;
+
+        return lowerRValueExpr(subContext, decl->initExpr);
+    }
+
+    LoweredValInfo visitEnumDecl(EnumDecl* decl)
+    {
+        // Given a declaration of a type, we need to make sure
+        // to output "witness tables" for any interfaces this
+        // type has declared conformance to.
+        for( auto inheritanceDecl : decl->getMembersOfType<InheritanceDecl>() )
+        {
+            ensureDecl(context, inheritanceDecl);
+        }
+
+        IRBuilder subBuilderStorage = *getBuilder();
+        IRBuilder* subBuilder = &subBuilderStorage;
+        emitOuterGenerics(subBuilder, decl, decl);
+
+        IRGenContext subContextStorage = *context;
+        IRGenContext* subContext = &subContextStorage;
+        subContext->irBuilder = subBuilder;
+
+        // An `enum` declaration will currently lower directly to its "tag"
+        // type, so that any references to the `enum` become referenes to
+        // the tag type instead.
+        //
+        // TODO: if we ever support `enum` types with payloads, we would
+        // need to make the `enum` lower to some kind of custom "tagged union"
+        // type.
+
+        IRType* loweredTagType = lowerType(subContext, decl->tagType);
+
+        return LoweredValInfo::simple(finishOuterGenerics(subBuilder, loweredTagType));
+    }
+
     LoweredValInfo visitAggTypeDecl(AggTypeDecl* decl)
     {
         // Don't generate an IR `struct` for intrinsic types
@@ -3768,11 +3834,6 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo>
             return LoweredValInfo();
         }
 
-        if(getMangledName(decl) == "_ST03int")
-        {
-            decl = decl;
-        }
-
         // Given a declaration of a type, we need to make sure
         // to output "witness tables" for any interfaces this
         // type has declared conformance to.