Preserve enum type in custom attribute argument of type obj (#995)

An enum assigned to a custom-attribute argument or property of type 'obj'
was stored in metadata as its underlying integer, so it round-tripped as
an int instead of the enum.

Carry the enum type alongside the value (new ILAttribElem.Enum) and encode
it with the ECMA-335 enum tag (0x55 + type name) for the boxed-object case,
matching what C# emits. Also decode that form (previously threw) and keep
encode/decode symmetric so static linking preserves it.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: edgarfgp

docs/release-notes/.FSharp.Compiler.Service/11.0.100.md

@@ -2,6 +2,7 @@
 
 * Fix `[<return: X>]` prefix attributes being silently dropped on class members, and fix false-positive `AllowMultiple=false` errors when `[<X>]` and `[<return: X>]` are applied to the same binding. ([Issue #17904](https://github.com/dotnet/fsharp/issues/17904), [Issue #19020](https://github.com/dotnet/fsharp/issues/19020), [PR #19738](https://github.com/dotnet/fsharp/pull/19738))
 * Fix attributes on return type of unparenthesized tuple methods being silently dropped from IL. ([Issue #462](https://github.com/dotnet/fsharp/issues/462), [PR #19714](https://github.com/dotnet/fsharp/pull/19714))
+* Fix enum values losing their type when used in a custom attribute argument of type `obj` (they were stored as the underlying integer instead of the enum). ([Issue #995](https://github.com/dotnet/fsharp/issues/995))
 * Fix internal error FS0073 "Undefined or unsolved type variable" in IlxGen when nested inline SRTP functions with multiple overloads leave unsolved typars in the non-witness codegen path. ([Issue #19709](https://github.com/dotnet/fsharp/issues/19709), [PR #19710](https://github.com/dotnet/fsharp/pull/19710))
 * Fix NRE when calling virtual Object methods on value types through inline SRTP functions. ([Issue #8098](https://github.com/dotnet/fsharp/issues/8098), [PR #19511](https://github.com/dotnet/fsharp/pull/19511))
 * Fix attributes not resolved from opened namespaces in `namespace rec` / `module rec` scopes. ([Issue #7931](https://github.com/dotnet/fsharp/issues/7931), [PR #19502](https://github.com/dotnet/fsharp/pull/19502))

src/Compiler/AbstractIL/il.fs

@@ -1192,6 +1192,7 @@ type ILAttribElem =
     | Type of ILType option
     | TypeRef of ILTypeRef option
     | Array of ILType * ILAttribElem list
+    | Enum of enumType: ILType * value: ILAttribElem
 
 type ILAttributeNamedArg = string * ILType * bool * ILAttribElem
 
@@ -4882,6 +4883,8 @@ let rec encodeCustomAttrElemTypeForObject x =
     | ILAttribElem.Single _ -> [| et_R4 |]
     | ILAttribElem.Double _ -> [| et_R8 |]
     | ILAttribElem.Array(elemTy, _) -> [| yield et_SZARRAY; yield! encodeCustomAttrElemType elemTy |]
+    // An enum boxed in 'object' is encoded as 0x55 followed by the enum type's qualified name.
+    | ILAttribElem.Enum(enumTy, _) -> encodeCustomAttrElemType enumTy
 
 let parseILVersion (vstr: string) =
     // matches "v1.2.3.4" or "1.2.3.4". Note, if numbers are missing, returns -1 (not 0).
@@ -4979,6 +4982,25 @@ let rec decodeCustomAttrElemType bytes sigptr x =
         mkILArr1DTy elemTy, sigptr
     | x when x = 0x50uy -> PrimaryAssemblyILGlobals.typ_Type, sigptr
     | x when x = 0x51uy -> PrimaryAssemblyILGlobals.typ_Object, sigptr // SERIALIZATION_TYPE_TAGGED_OBJECT (ECMA-335 II.23.3)
+    | x when x = 0x55uy ->
+        // SERIALIZATION_TYPE_ENUM (ECMA-335 II.23.3): the enum type's qualified name follows.
+        // Occurs e.g. when an enum is boxed into an 'object'-typed argument.
+        let qualifiedName, sigptr = sigptr_get_serstring bytes sigptr
+
+        let unqualifiedName, rest =
+            let pieces = qualifiedName.Split ','
+
+            if pieces.Length > 1 then
+                pieces[0], Some(String.concat "," pieces[1..])
+            else
+                pieces[0], None
+
+        let scoref =
+            match rest with
+            | Some aname -> ILScopeRef.Assembly(ILAssemblyRef.FromAssemblyName(AssemblyName aname))
+            | None -> PrimaryAssemblyILGlobals.primaryAssemblyScopeRef
+
+        ILType.Value(mkILNonGenericTySpec (mkILTyRef (scoref, unqualifiedName))), sigptr
     | _ -> failwithf "decodeCustomAttrElemType ilg: unrecognized custom element type: %A" x
 
 /// Given a custom attribute element, encode it to a binary representation according to the rules in Ecma 335 Partition II.
@@ -5009,6 +5031,8 @@ let rec encodeCustomAttrPrimValue c =
             for elem in elems do
                 yield! encodeCustomAttrPrimValue elem
         |]
+    // The enum type is captured separately (in the type tag); the value is the underlying integer.
+    | ILAttribElem.Enum(_, value) -> encodeCustomAttrPrimValue value
 
 and encodeCustomAttrValue ty c =
     match ty, c with
@@ -5355,7 +5379,13 @@ let decodeILAttribData (ca: ILAttribute) =
                     ILAttribElem.Null, sigptr
                 else
                     let ty, sigptr = decodeCustomAttrElemType bytes sigptr et
-                    parseVal ty sigptr
+                    let v, sigptr = parseVal ty sigptr
+                    // Preserve the enum type of a boxed enum so it re-encodes with its 0x55 enum tag
+                    // (rather than the bare underlying integer) when the attribute is round-tripped,
+                    // e.g. during static linking. See https://github.com/dotnet/fsharp/issues/995.
+                    match ty with
+                    | ILType.Value _ -> ILAttribElem.Enum(ty, v), sigptr
+                    | _ -> v, sigptr
             | ILType.Array(shape, elemTy) when shape = ILArrayShape.SingleDimensional ->
                 let n, sigptr = sigptr_get_i32 bytes sigptr
 
@@ -5371,7 +5401,11 @@ let decodeILAttribData (ca: ILAttribute) =
 
                     let elems, sigptr = parseElems [] n sigptr
                     ILAttribElem.Array(elemTy, elems), sigptr
-            | ILType.Value _ -> (* assume it is an enumeration *)
+            | ILType.Value _ ->
+                // Assume an enumeration. Note: the underlying integer width is not present in the
+                // blob, so this reads it as int32. Enums with a non-int32 underlying type (byte,
+                // int16, int64, ...) are therefore not read correctly here; resolving that would
+                // require materializing the enum type, which this blob parser does not do.
                 let n, sigptr = sigptr_get_i32 bytes sigptr
                 ILAttribElem.Int32 n, sigptr
             | _ -> failwith "decodeILAttribData: attribute data involves an enum or System.Type value"
@@ -5394,29 +5428,9 @@ let decodeILAttribData (ca: ILAttribute) =
                 let isPropByte, sigptr = sigptr_get_u8 bytes sigptr
                 let isProp = (int isPropByte = 0x54)
                 let et, sigptr = sigptr_get_u8 bytes sigptr
-                // We have a named value
-                let ty, sigptr =
-                    if ( (* 0x50 = (int et) || *) 0x55 = (int et)) then
-                        let qualified_tname, sigptr = sigptr_get_serstring bytes sigptr
-
-                        let unqualified_tname, rest =
-                            let pieces = qualified_tname.Split ','
-
-                            if pieces.Length > 1 then
-                                pieces[0], Some(String.concat "," pieces[1..])
-                            else
-                                pieces[0], None
-
-                        let scoref =
-                            match rest with
-                            | Some aname -> ILScopeRef.Assembly(ILAssemblyRef.FromAssemblyName(AssemblyName aname))
-                            | None -> PrimaryAssemblyILGlobals.primaryAssemblyScopeRef
-
-                        let tref = mkILTyRef (scoref, unqualified_tname)
-                        let tspec = mkILNonGenericTySpec tref
-                        ILType.Value tspec, sigptr
-                    else
-                        decodeCustomAttrElemType bytes sigptr et
+                // We have a named value. The type tag (including the 0x55 enum form) is decoded by
+                // decodeCustomAttrElemType.
+                let ty, sigptr = decodeCustomAttrElemType bytes sigptr et
 
                 let nm, sigptr = sigptr_get_serstring bytes sigptr
                 let v, sigptr = parseVal ty sigptr

src/Compiler/AbstractIL/il.fsi

@@ -849,6 +849,11 @@ type ILAttribElem =
     | Type of ILType option
     | TypeRef of ILTypeRef option
     | Array of ILType * ILAttribElem list
+    /// Represents an enum value together with its enum type. Used when an enum is stored in a
+    /// custom-attribute argument of type 'object', so the enum type is preserved in the encoded
+    /// blob (ECMA-335 II.23.3) instead of being collapsed to its underlying integer. The second
+    /// element is the underlying integer value (e.g. ILAttribElem.Int32).
+    | Enum of enumType: ILType * value: ILAttribElem
 
 /// Named args: values and flags indicating if they are fields or properties.
 type ILAttributeNamedArg = string * ILType * bool * ILAttribElem

src/Compiler/AbstractIL/ilmorph.fs

@@ -166,6 +166,7 @@ let rec celem_ty2ty f celem =
     | ILAttribElem.Type(Some ty) -> ILAttribElem.Type(Some(f ty))
     | ILAttribElem.TypeRef(Some tref) -> ILAttribElem.TypeRef(Some (f (mkILBoxedType (mkILNonGenericTySpec tref))).TypeRef)
     | ILAttribElem.Array(elemTy, elems) -> ILAttribElem.Array(f elemTy, List.map (celem_ty2ty f) elems)
+    | ILAttribElem.Enum(enumTy, value) -> ILAttribElem.Enum(f enumTy, celem_ty2ty f value)
     | _ -> celem
 
 let cnamedarg_ty2ty f ((nm, ty, isProp, elem): ILAttributeNamedArg) = (nm, f ty, isProp, celem_ty2ty f elem)

src/Compiler/Checking/AttributeChecking.fs

@@ -44,8 +44,10 @@ let rec private evalILAttribElem elem =
     | ILAttribElem.Double x -> box x
     | ILAttribElem.Null -> null
     | ILAttribElem.Array (_, a) -> box [| for i in a -> evalILAttribElem i |]
+    // An enum value: evaluate to its underlying integer value (the enum type itself is not materialized here).
+    | ILAttribElem.Enum (_, value) -> evalILAttribElem value
     // TODO: typeof<..> in attribute values
-    | ILAttribElem.Type (Some _t) -> fail() 
+    | ILAttribElem.Type (Some _t) -> fail()
     | ILAttribElem.Type None -> null
     | ILAttribElem.TypeRef (Some _t) -> fail()
     | ILAttribElem.TypeRef None -> null

src/Compiler/Checking/NicePrint.fs

@@ -644,11 +644,12 @@ module PrintTypes =
         | ILAttribElem.Type (Some ty) -> 
             LeftL.keywordTypeof ^^ SepL.leftAngle ^^ PrintIL.layoutILType denv [] ty ^^ RightL.rightAngle
         | ILAttribElem.Type None -> wordL (tagText "")
-        | ILAttribElem.TypeRef (Some ty) -> 
+        | ILAttribElem.TypeRef (Some ty) ->
             LeftL.keywordTypedefof ^^ SepL.leftAngle ^^ PrintIL.layoutILTypeRef denv ty ^^ RightL.rightAngle
         | ILAttribElem.TypeRef None -> emptyL
+        | ILAttribElem.Enum (_, value) -> layoutILAttribElement denv value
 
-    and layoutILAttrib denv (ty, args) = 
+    and layoutILAttrib denv (ty, args) =
         let argsL = bracketL (sepListL RightL.comma (List.map (layoutILAttribElement denv) args))
         PrintIL.layoutILType denv [] ty ++ argsL
 

src/Compiler/CodeGen/IlxGen.fs

@@ -10322,6 +10322,19 @@ and GenAttribArg amap (g: TcGlobals) eenv x (ilArgTy: ILType) =
         let tynm = ilArgTy.TypeSpec.Name
         let isobj = (tynm = "System.Object")
 
+        // An enum value stored into an 'object'-typed argument must keep its enum type in the
+        // custom-attribute blob (ECMA-335 II.23.3), otherwise it round-trips as the underlying
+        // integer (e.g. 'Prop = MyEnum.B' surfaces as boxed int32). See
+        // https://github.com/dotnet/fsharp/issues/995. The enum type is carried alongside the
+        // underlying integer value, which is computed by recursing with the underlying IL type.
+        if isobj && isEnumTy g ty then
+            let enumIlTy = GenType amap m eenv.tyenv ty
+            let underlyingTy = underlyingTypeOfEnumTy g ty
+            let underlyingIlTy = GenType amap m eenv.tyenv underlyingTy
+            let underlyingElem = GenAttribArg amap g eenv (Expr.Const(c, m, underlyingTy)) underlyingIlTy
+            ILAttribElem.Enum(enumIlTy, underlyingElem)
+        else
+
         match c with
         | Const.Bool b -> ILAttribElem.Bool b
         | Const.Int32 i when isobj || tynm = "System.Int32" -> ILAttribElem.Int32 i

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/Basic/Basic.fs

@@ -34,6 +34,13 @@ module CustomAttributes_Basic =
         |> verifyCompileAndRun
         |> shouldSucceed
 
+    // Regression for https://github.com/dotnet/fsharp/issues/995
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"EnumValueAsObjectArg01.fs"|])>]
+    let ``EnumValueAsObjectArg01_fs`` compilation =
+        compilation
+        |> verifyCompileAndRun
+        |> shouldSucceed
+
     // SOURCE=E_AttributeApplication01.fs					# E_AttributeApplication01.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"E_AttributeApplication01.fs"|])>]
     let ``E_AttributeApplication01_fs`` compilation =

tests/FSharp.Compiler.ComponentTests/Conformance/BasicGrammarElements/CustomAttributes/Basic/EnumValueAsObjectArg01.fs

@@ -0,0 +1,38 @@
+// #Conformance #DeclarationElements #Attributes
+// Regression test for https://github.com/dotnet/fsharp/issues/995
+// An enum assigned to an attribute argument of type 'obj' must keep its enum type in the
+// emitted metadata, instead of being stored as the underlying int32.
+
+open System
+
+type MyAttribute() =
+    inherit Attribute()
+    let mutable prop : obj = null
+    member _.Prop
+        with get () : obj = prop
+        and  set (value: obj) = prop <- value
+
+type MyEnum =
+    | A = 1
+    | B = 2
+
+// An enum with a non-int32 underlying type, to exercise the encoded value width.
+type LongEnum =
+    | P = 1L
+    | Q = 2L
+
+[<My(Prop = MyEnum.B)>]
+type MyClass = class end
+
+[<My(Prop = LongEnum.Q)>]
+type MyClassLong = class end
+
+let propOf<'T> () = (typeof<'T>.GetCustomAttributes(false)[0] :?> MyAttribute).Prop
+
+let intProp = propOf<MyClass> ()
+if intProp.GetType() <> typeof<MyEnum> then failwith "MyEnum type was lost"
+if Convert.ToString(intProp, Globalization.CultureInfo.InvariantCulture) <> "B" then failwith "expected \"B\""
+
+let longProp = propOf<MyClassLong> ()
+if longProp.GetType() <> typeof<LongEnum> then failwith "LongEnum type was lost"
+if Convert.ToString(longProp, Globalization.CultureInfo.InvariantCulture) <> "Q" then failwith "expected \"Q\""