Handle Const.Zero for primitive value types in custom attribute codegen

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

@@ -37,6 +37,7 @@
 * Fix signature generation: missing `[<Class>]` attribute for types without visible constructors. ([Issue #16531](https://github.com/dotnet/fsharp/issues/16531), [PR #19586](https://github.com/dotnet/fsharp/pull/19586))
 * Fix methods being tagged as `Member` instead of `Method` in tooltips. ([Issue #10540](https://github.com/dotnet/fsharp/issues/10540), [PR #19507](https://github.com/dotnet/fsharp/pull/19507))
 * IlxGen: fix missing CompilationMapping attribute for generic values ([PR #19643](https://github.com/dotnet/fsharp/pull/19643))
+* Fix internal error when using custom attribute with `[<Optional>]` value type parameter and no `[<DefaultParameterValue>]`. ([Issue #8353](https://github.com/dotnet/fsharp/issues/8353), [PR #19484](https://github.com/dotnet/fsharp/pull/19484))
 
 ### Added
 

src/Compiler/CodeGen/IlxGen.fs

@@ -10307,7 +10307,7 @@ and GenAttribArg amap g eenv x (ilArgTy: ILType) =
     | Expr.Const(Const.Zero, _, _), ILType.Array _ -> ILAttribElem.Null
 
     // Detect standard constants
-    | Expr.Const(c, m, _), _ ->
+    | Expr.Const(c, m, ty), _ ->
         let tynm = ilArgTy.TypeSpec.Name
         let isobj = (tynm = "System.Object")
 
@@ -10334,6 +10334,22 @@ and GenAttribArg amap g eenv x (ilArgTy: ILType) =
         | Const.Zero when isobj -> ILAttribElem.Null
         | Const.Zero when tynm = "System.String" -> ILAttribElem.String None
         | Const.Zero when tynm = "System.Type" -> ILAttribElem.Type None
+        | Const.Zero when tynm = "System.Boolean" -> ILAttribElem.Bool false
+        | Const.Zero when tynm = "System.SByte" -> ILAttribElem.SByte 0y
+        | Const.Zero when tynm = "System.Int16" -> ILAttribElem.Int16 0s
+        | Const.Zero when tynm = "System.Int32" -> ILAttribElem.Int32 0
+        | Const.Zero when tynm = "System.Int64" -> ILAttribElem.Int64 0L
+        | Const.Zero when tynm = "System.Byte" -> ILAttribElem.Byte 0uy
+        | Const.Zero when tynm = "System.UInt16" -> ILAttribElem.UInt16 0us
+        | Const.Zero when tynm = "System.UInt32" -> ILAttribElem.UInt32 0u
+        | Const.Zero when tynm = "System.UInt64" -> ILAttribElem.UInt64 0UL
+        | Const.Zero when tynm = "System.Single" -> ILAttribElem.Single 0.0f
+        | Const.Zero when tynm = "System.Double" -> ILAttribElem.Double 0.0
+        | Const.Zero when tynm = "System.Char" -> ILAttribElem.Char '\000'
+        | Const.Zero when isEnumTy g ty ->
+            let underlyingTy = underlyingTypeOfEnumTy g ty
+            let underlyingIlTy = GenType amap m eenv.tyenv underlyingTy
+            GenAttribArg amap g eenv (Expr.Const(Const.Zero, m, underlyingTy)) underlyingIlTy
         | Const.String i when isobj || tynm = "System.String" -> ILAttribElem.String(Some i)
         | _ -> error (InternalError("The type '" + tynm + "' may not be used as a custom attribute value", m))
 

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

@@ -303,6 +303,14 @@ module CustomAttributes_Basic =
         |> verifyCompileAndRun
         |> shouldSucceed
 
+    // SOURCE=OptionalAttributeArgs.fs						# OptionalAttributeArgs.fs
+    // Regression test for https://github.com/dotnet/fsharp/issues/8353
+    [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"OptionalAttributeArgs.fs"|])>]
+    let ``OptionalAttributeArgs_fs`` compilation =
+        compilation
+        |> verifyCompileAndRun
+        |> shouldSucceed
+
     // SOURCE=W_ReturnType03b.fs          SCFLAGS="--test:ErrorRanges"		# W_ReturnType03b.fs
     [<Theory; Directory(__SOURCE_DIRECTORY__, Includes=[|"W_ReturnType03b.fs"|])>]
     let ``W_ReturnType03b_fs`` compilation =

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

@@ -0,0 +1,150 @@
+// #Regression #Conformance #DeclarationElements #Attributes
+// Regression test for https://github.com/dotnet/fsharp/issues/8353
+// Verify that custom attributes with [<Optional>] parameters (no DefaultParameterValue) compile for all value types
+// and that the emitted default values are correct at runtime.
+
+open System
+open System.Runtime.InteropServices
+
+type BoolAttribute(name: string, flag: bool) =
+    inherit Attribute()
+    member _.Flag = flag
+    new([<Optional>] flag: bool) = BoolAttribute("", flag)
+
+type IntAttribute(name: string, value: int) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: int) = IntAttribute("", value)
+
+type ByteAttribute(name: string, value: byte) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: byte) = ByteAttribute("", value)
+
+type SByteAttribute(name: string, value: sbyte) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: sbyte) = SByteAttribute("", value)
+
+type Int16Attribute(name: string, value: int16) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: int16) = Int16Attribute("", value)
+
+type Int64Attribute(name: string, value: int64) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: int64) = Int64Attribute("", value)
+
+type UInt16Attribute(name: string, value: uint16) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: uint16) = UInt16Attribute("", value)
+
+type UInt32Attribute(name: string, value: uint32) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: uint32) = UInt32Attribute("", value)
+
+type UInt64Attribute(name: string, value: uint64) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: uint64) = UInt64Attribute("", value)
+
+type FloatAttribute(name: string, value: float) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: float) = FloatAttribute("", value)
+
+type SingleAttribute(name: string, value: float32) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: float32) = SingleAttribute("", value)
+
+type CharAttribute(name: string, value: char) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: char) = CharAttribute("", value)
+
+// Enum types with different underlying types
+type MyIntEnum = A = 0 | B = 1
+
+type MyByteEnum = A = 0uy | B = 1uy
+
+type EnumIntAttribute(name: string, value: MyIntEnum) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: MyIntEnum) = EnumIntAttribute("", value)
+
+type EnumByteAttribute(name: string, value: MyByteEnum) =
+    inherit Attribute()
+    member _.Value = value
+    new([<Optional>] value: MyByteEnum) = EnumByteAttribute("", value)
+
+[<Bool>]
+type T1() = class end
+
+[<Int>]
+type T2() = class end
+
+[<Byte>]
+type T3() = class end
+
+[<Float>]
+type T4() = class end
+
+[<Single>]
+type T5() = class end
+
+[<Char>]
+type T6() = class end
+
+[<SByte>]
+type T7() = class end
+
+[<Int16>]
+type T8() = class end
+
+[<Int64>]
+type T9() = class end
+
+[<UInt16>]
+type T10() = class end
+
+[<UInt32>]
+type T11() = class end
+
+[<UInt64>]
+type T12() = class end
+
+[<EnumInt>]
+type T13() = class end
+
+[<EnumByte>]
+type T14() = class end
+
+// Verify default values at runtime via reflection
+let inline getAttr<'a when 'a :> Attribute> (t: Type) = t.GetCustomAttributes(typeof<'a>, false).[0] :?> 'a
+
+let check (name: string) (actual: 'a) (expected: 'a) =
+    if actual <> expected then
+        failwithf "%s: expected %A but got %A" name expected actual
+
+[<EntryPoint>]
+let main _ =
+    check "bool" (getAttr<BoolAttribute>(typeof<T1>)).Flag false
+    check "int" (getAttr<IntAttribute>(typeof<T2>)).Value 0
+    check "byte" (getAttr<ByteAttribute>(typeof<T3>)).Value 0uy
+    check "float" (getAttr<FloatAttribute>(typeof<T4>)).Value 0.0
+    check "single" (getAttr<SingleAttribute>(typeof<T5>)).Value 0.0f
+    check "char" (getAttr<CharAttribute>(typeof<T6>)).Value '\000'
+    check "sbyte" (getAttr<SByteAttribute>(typeof<T7>)).Value 0y
+    check "int16" (getAttr<Int16Attribute>(typeof<T8>)).Value 0s
+    check "int64" (getAttr<Int64Attribute>(typeof<T9>)).Value 0L
+    check "uint16" (getAttr<UInt16Attribute>(typeof<T10>)).Value 0us
+    check "uint32" (getAttr<UInt32Attribute>(typeof<T11>)).Value 0u
+    check "uint64" (getAttr<UInt64Attribute>(typeof<T12>)).Value 0UL
+    check "enum_int" (getAttr<EnumIntAttribute>(typeof<T13>)).Value MyIntEnum.A
+    check "enum_byte" (getAttr<EnumByteAttribute>(typeof<T14>)).Value MyByteEnum.A
+    0
+