[JS/TS] Fix static val mutable fields declared with [<DefaultValue>] not being zero-initialized (#4418)

Author: MangelMaxime

src/Fable.AST/Fable.fs

@@ -71,6 +71,7 @@ type Field =
     abstract IsMutable: bool
     abstract IsStatic: bool
     abstract LiteralValue: obj option
+    abstract HasDefaultValueAttribute: bool
 
 type UnionCase =
     abstract Name: string

src/Fable.Cli/CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+* [JS/TS] Fix `Unchecked.defaultof<char>` being emitted as `null` instead of `'\0'` (by @MangelMaxime)
+* [JS/TS] Fix `static val mutable` fields declared with `[<DefaultValue>]` not being zero-initialized (fix #2739) (by @MangelMaxime)
 * [JS/TS/Python] Fix record/struct types augmented with `static let` or `static member val` generating extra constructor parameters for each static field, causing constructor arguments to be assigned to wrong slots (by @MangelMaxime)
 * [TS] Annotate `System.Collections.Generic.IList<T>` as `MutableArray<T>` (by @MangelMaxime)
 * [JS/TS] Fix `ResizeArray` index getter/setter not throwing `IndexOutOfRangeException` when index is out of bounds (fix #3812) (by @MangelMaxime)

src/Fable.Compiler/CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+* [JS/TS] Fix `Unchecked.defaultof<char>` being emitted as `null` instead of `'\0'` (by @MangelMaxime)
+* [JS/TS] Fix `static val mutable` fields declared with `[<DefaultValue>]` not being zero-initialized (fix #2739) (by @MangelMaxime)
 * [JS/TS/Python] Fix record/struct types augmented with `static let` or `static member val` generating extra constructor parameters for each static field, causing constructor arguments to be assigned to wrong slots (by @MangelMaxime)
 * [TS] Annotate `System.Collections.Generic.IList<T>` as `MutableArray<T>` (by @MangelMaxime)
 * [JS/TS] Fix `ResizeArray` index getter/setter not throwing `IndexOutOfRangeException` when index is out of bounds (fix #3812) (by @MangelMaxime)

src/Fable.Transforms/FSharp2Fable.Util.fs

@@ -76,6 +76,9 @@ type FsField(fi: FSharpField) =
         member _.IsStatic = fi.IsStatic
         member _.IsMutable = fi.IsMutable
 
+        member _.HasDefaultValueAttribute =
+            fi.FieldAttributes |> Helpers.hasAttrib Atts.defaultValue
+
     static member FSharpFieldName(fi: FSharpField) =
         let rec countConflictingCases acc (ent: FSharpEntity) (name: string) =
             match TypeHelpers.tryGetBaseEntity ent with

src/Fable.Transforms/Fable2Babel.fs

@@ -3412,6 +3412,30 @@ but thanks to the optimisation done below we get
     let sanitizeName fieldName =
         fieldName |> Naming.sanitizeJsIdentForbiddenChars |> Naming.checkJsKeywords
 
+    [<RequireQualifiedAccess>]
+    module DefaultValue =
+
+        open Replacements.Util
+        open Fable.Transforms
+
+        /// Mirrors `Fable.Transforms.JS.Replacements.defaultof` for the types we can handle
+        /// without the full FSharp2Fable compiler context (which that function requires).
+        let rec forType (com: IBabelCompiler) ctx (t: Fable.Type) : Expression =
+            match t with
+            | Fable.Nullable _ -> Expression.nullLiteral ()
+            // Struct tuples are value types — initialize each element to its zero
+            | Fable.Tuple(args, true) -> Expression.arrayExpression (args |> List.map (forType com ctx) |> List.toArray)
+            | Fable.Boolean -> Expression.booleanLiteral false
+            | Fable.Char -> Expression.stringLiteral "\u0000"
+            | Fable.Number(kind, uom) ->
+                com.TransformAsExpr(ctx, Fable.NumberConstant(Fable.NumberValue.GetZero kind, uom) |> makeValue None)
+            | Builtin(BclTimeSpan | BclTimeOnly) -> Expression.numericLiteral 0
+            | Builtin BclGuid -> Expression.stringLiteral "00000000-0000-0000-0000-000000000000"
+            | Builtin BclDateTime -> libCall com ctx None "Date" "minValue" [] []
+            | Builtin BclDateTimeOffset -> libCall com ctx None "DateOffset" "minValue" [] []
+            | Builtin BclDateOnly -> libCall com ctx None "DateOnly" "minValue" [] []
+            | _ -> libCall com ctx None "Util" "defaultOf" [] []
+
     let getEntityFieldsAsIdents (ent: Fable.Entity) =
         ent.FSharpFields
         |> List.choose (fun field ->
@@ -3533,6 +3557,45 @@ but thanks to the optimisation done below we get
             None
         |> declareClassWithParams com ctx ent entName doc consArgs [||] consBody superClass classMembers
 
+    /// Emits an IIFE that zero-initializes all static [<DefaultValue>] fields of a class.
+    ///
+    /// ```
+    /// [<DefaultValue>]
+    /// static val mutable MyField: int
+    /// ```
+    ///
+    /// This mirrors the pattern used for `static let mutable` bindings, which FCS compiles
+    /// to a `.cctor` that Fable emits as an IIFE.
+    let declareDefaultValueStaticFieldInits
+        (com: IBabelCompiler)
+        ctx
+        (ent: Fable.Entity)
+        (entName: string)
+        : ModuleDeclaration list
+        =
+        let defaultValueFields =
+            ent.FSharpFields
+            |> List.filter (fun f -> f.IsStatic && f.HasDefaultValueAttribute)
+
+        if defaultValueFields.IsEmpty then
+            []
+        else
+            let classIdent = Expression.identifier entName
+
+            let assignments =
+                defaultValueFields
+                |> List.map (fun field ->
+                    let left = get None classIdent field.Name
+                    let right = DefaultValue.forType com ctx field.FieldType
+                    assign None left right |> ExpressionStatement
+                )
+                |> List.toArray
+
+            let iife =
+                Expression.callExpression (Expression.functionExpression ([||], BlockStatement(assignments)), [||])
+
+            [ iife |> ExpressionStatement |> PrivateModuleDeclaration ]
+
     let declareTypeReflection (com: IBabelCompiler) ctx (ent: Fable.Entity) entName : ModuleDeclaration =
         let ta =
             if com.IsTypeScript then
@@ -3571,12 +3634,14 @@ but thanks to the optimisation done below we get
         let typeDeclaration =
             declareClass com ctx ent entName doc consArgs consBody baseExpr classMembers
 
+        let fieldInits = declareDefaultValueStaticFieldInits com ctx ent entName
+
         if com.Options.NoReflection then
-            [ typeDeclaration ]
+            [ typeDeclaration; yield! fieldInits ]
         else
             let reflectionDeclaration = declareTypeReflection com ctx ent entName
 
-            [ typeDeclaration; reflectionDeclaration ]
+            [ typeDeclaration; reflectionDeclaration; yield! fieldInits ]
 
     let hasAttribute fullName (atts: Fable.Attribute seq) =
         atts |> Seq.exists (fun att -> att.Entity.FullName = fullName)

src/Fable.Transforms/Replacements.fs

@@ -676,10 +676,10 @@ let makeHashSet (com: ICompiler) ctx r t sourceSeq =
 let rec getZero (com: ICompiler) (ctx: Context) (t: Type) =
     match t with
     | Boolean -> makeBoolConst false
-    | Char
+    | Char -> makeCharConst '\000'
     | String -> makeStrConst "" // TODO: Use null for string?
     | Number(kind, uom) -> NumberConstant(NumberValue.GetZero kind, uom) |> makeValue None
-    | Builtin(BclTimeSpan | BclTimeOnly) -> makeIntConst 0 // TODO: Type cast
+    | Builtin(BclTimeSpan | BclTimeOnly) -> TypeCast(makeIntConst 0, t)
     | Builtin BclDateTime as t -> Helper.LibCall(com, "Date", "minValue", t, [])
     | Builtin BclDateTimeOffset as t -> Helper.LibCall(com, "DateOffset", "minValue", t, [])
     | Builtin BclDateOnly as t -> Helper.LibCall(com, "DateOnly", "minValue", t, [])
@@ -993,6 +993,7 @@ let rec defaultof (com: ICompiler) (ctx: Context) r t =
             // Null t |> makeValue None
             Helper.LibCall(com, "Util", "defaultOf", t, [], ?loc = r)
         )
+    | Char -> makeCharConst '\000'
     // TODO: Fail (or raise warning) if this is an unresolved generic parameter?
     | _ ->
         // Null t |> makeValue None

src/Fable.Transforms/Transforms.Util.fs

@@ -43,6 +43,9 @@ module Atts =
     [<Literal>]
     let mangle = "Fable.Core.MangleAttribute" // typeof<Fable.Core.MangleAttribute>.FullName
 
+    [<Literal>]
+    let defaultValue = "Microsoft.FSharp.Core.DefaultValueAttribute" // typeof<Microsoft.FSharp.Core.DefaultValueAttribute>.FullName
+
     [<Literal>]
     let attachMembers = "Fable.Core.AttachMembersAttribute"
 
@@ -1042,6 +1045,7 @@ module AST =
 
     let makeBoolConst (x: bool) = BoolConstant x |> makeValue None
     let makeStrConst (x: string) = StringConstant x |> makeValue None
+    let makeCharConst (x: char) = CharConstant x |> makeValue None
 
     let makeIntConst (x: int) =
         NumberConstant(NumberValue.Int32 x, NumberInfo.Empty) |> makeValue None

src/fable-library-ts/Reflection.ts

@@ -536,8 +536,7 @@ export function createInstance(t: TypeInfo, consArgs?: any[]): any {
       case decimal_type.fullname:
         return new Decimal(0);
       case char_type.fullname:
-        // Even though char is a value type, it's erased to string, and Unchecked.defaultof<char> is null
-        return null;
+        return "\0";
       default:
         throw new Exception(`Cannot access constructor of ${t.fullname}`);
     }

tests/Js/Main/MiscTests.fs

@@ -1125,6 +1125,7 @@ let tests =
         Unchecked.defaultof<TimeSpan> |> equal (TimeSpan.FromMilliseconds 0.)
         Unchecked.defaultof<bool> |> equal false
         Unchecked.defaultof<string> |> equal null
+        Unchecked.defaultof<char> |> equal '\u0000'
         Unchecked.defaultof<Guid> |> equal Guid.Empty
 #if !FABLE_COMPILER_TYPESCRIPT
         let x = ValueType()

tests/Js/Main/TypeTests.fs

@@ -329,6 +329,107 @@ type Test_TestTypeWithParameterizedUnitMeasure = {
 //     [<DefaultValue>] val mutable StringValue: string
 //     [<DefaultValue>] val mutable ObjValue: System.Collections.Generic.Dictionary<string, string>
 
+[<AllowNullLiteral>]
+type MyUser =
+    class end
+
+// See #2739: static [<DefaultValue>] fields must be zero-initialized in JS/TS
+type ClassWithDefaultValueStaticFields() =
+
+    [<DefaultValue>]
+    static val mutable private int: int
+    [<DefaultValue>]
+    static val mutable private bool: bool
+    [<DefaultValue>]
+    static val mutable private string: string
+    [<DefaultValue>]
+    static val mutable private guid: Guid
+    [<DefaultValue>]
+    static val mutable private char: char
+
+    [<DefaultValue>]
+    static val mutable private dateTime: DateTime
+
+    [<DefaultValue>]
+    static val mutable private timeOnly : TimeOnly
+    [<DefaultValue>]
+    static val mutable private dateOnly : DateOnly
+    [<DefaultValue>]
+    static val mutable private dateTimeOffset : DateTimeOffset
+    [<DefaultValue>]
+    static val mutable private int8 : int8
+    [<DefaultValue>]
+    static val mutable private uInt8 : uint8
+    [<DefaultValue>]
+    static val mutable private int16 : Int16
+    [<DefaultValue>]
+    static val mutable private uInt16 : UInt16
+    [<DefaultValue>]
+    static val mutable private int32 : Int32
+    [<DefaultValue>]
+    static val mutable private uInt32 : UInt32
+    [<DefaultValue>]
+    static val mutable private int64 : Int64
+    [<DefaultValue>]
+    static val mutable private uInt64 : UInt64
+    [<DefaultValue>]
+    static val mutable private bigInt : bigint
+    [<DefaultValue>]
+    static val mutable private nativeInt : nativeint
+    [<DefaultValue>]
+    static val mutable private uNativeInt : unativeint
+    [<DefaultValue>]
+    static val mutable private float32 : float32
+    [<DefaultValue>]
+    static val mutable private float64 : float
+    [<DefaultValue>]
+    static val mutable private decimal : Decimal
+
+    [<DefaultValue>]
+    static val mutable private timeSpan: TimeSpan
+    [<DefaultValue>]
+    static val mutable private allowNullLiteralClass: MyUser
+    [<DefaultValue>]
+    static val mutable private nullableInt: Nullable<int>
+    [<DefaultValue>]
+    static val mutable private tuple2: TimeSpan * DateTime
+    [<DefaultValue>]
+    static val mutable private structTuple2: struct (TimeSpan * DateTime)
+
+    static member IncrCount() =
+        ClassWithDefaultValueStaticFields.int <- ClassWithDefaultValueStaticFields.int + 1
+        ClassWithDefaultValueStaticFields.int
+
+    static member Int = ClassWithDefaultValueStaticFields.int
+    static member Bool = ClassWithDefaultValueStaticFields.bool
+    static member String = ClassWithDefaultValueStaticFields.string
+    static member Guid = ClassWithDefaultValueStaticFields.guid
+    static member Char = ClassWithDefaultValueStaticFields.char
+    static member TimeSpan = ClassWithDefaultValueStaticFields.timeSpan
+    static member AllowNullLiteralClass = ClassWithDefaultValueStaticFields.allowNullLiteralClass
+    static member NullableInt = ClassWithDefaultValueStaticFields.nullableInt
+    static member Tuple2 = ClassWithDefaultValueStaticFields.tuple2
+    static member DateTime = ClassWithDefaultValueStaticFields.dateTime
+    static member TimeOnly = ClassWithDefaultValueStaticFields.timeOnly
+    static member DateOnly = ClassWithDefaultValueStaticFields.dateOnly
+    static member DateTimeOffset = ClassWithDefaultValueStaticFields.dateTimeOffset
+    static member Int8 = ClassWithDefaultValueStaticFields.int8
+    static member UInt8 = ClassWithDefaultValueStaticFields.uInt8
+    static member Int16 = ClassWithDefaultValueStaticFields.int16
+    static member UInt16 = ClassWithDefaultValueStaticFields.uInt16
+    static member Int32 = ClassWithDefaultValueStaticFields.int32
+    static member UInt32 = ClassWithDefaultValueStaticFields.uInt32
+    static member Int64 = ClassWithDefaultValueStaticFields.int64
+    static member UInt64 = ClassWithDefaultValueStaticFields.uInt64
+    static member BigInt = ClassWithDefaultValueStaticFields.bigInt
+    static member NativeInt = ClassWithDefaultValueStaticFields.nativeInt
+    static member UNativeInt = ClassWithDefaultValueStaticFields.uNativeInt
+    static member Float32 = ClassWithDefaultValueStaticFields.float32
+    static member Float64 = ClassWithDefaultValueStaticFields.float64
+    static member Decimal = ClassWithDefaultValueStaticFields.decimal
+    static member StructTuple2 = ClassWithDefaultValueStaticFields.structTuple2
+
+
 type Default1 = int
 
 type Distinct1 =
@@ -1470,4 +1571,33 @@ let tests =
 
         let result3 = getTwoValues<TestTypeB, TestTypeC>()
         result3 |> equal ("B", "C")
+
+    // See https://github.com/fable-compiler/Fable/issues/2739
+    testCase "Static [<DefaultValue>] fields are zero-initialized" <| fun () ->
+        ClassWithDefaultValueStaticFields.Int |> equal 0
+        ClassWithDefaultValueStaticFields.Bool |> equal false
+        ClassWithDefaultValueStaticFields.String |> equal null
+        ClassWithDefaultValueStaticFields.Guid |> equal Guid.Empty
+        ClassWithDefaultValueStaticFields.Char |> equal '\000'
+        ClassWithDefaultValueStaticFields.TimeSpan |> equal TimeSpan.Zero
+        ClassWithDefaultValueStaticFields.TimeOnly |> equal TimeOnly.MinValue
+        ClassWithDefaultValueStaticFields.DateOnly |> equal DateOnly.MinValue
+        ClassWithDefaultValueStaticFields.DateTime |> equal DateTime.MinValue
+        ClassWithDefaultValueStaticFields.DateTimeOffset |> equal DateTimeOffset.MinValue
+        ClassWithDefaultValueStaticFields.Int8 |> equal 0y
+        ClassWithDefaultValueStaticFields.UInt8 |> equal 0uy
+        ClassWithDefaultValueStaticFields.Int16 |> equal 0s
+        ClassWithDefaultValueStaticFields.UInt16 |> equal 0us
+        ClassWithDefaultValueStaticFields.Int32 |> equal 0
+        ClassWithDefaultValueStaticFields.UInt32 |> equal 0u
+        ClassWithDefaultValueStaticFields.Int64 |> equal 0L
+        ClassWithDefaultValueStaticFields.UInt64 |> equal 0UL
+        ClassWithDefaultValueStaticFields.BigInt |> equal 0I
+        ClassWithDefaultValueStaticFields.NativeInt |> equal 0n
+        ClassWithDefaultValueStaticFields.UNativeInt |> equal 0un
+        ClassWithDefaultValueStaticFields.Float32 |> equal 0.f
+        ClassWithDefaultValueStaticFields.Float64 |> equal 0.
+        ClassWithDefaultValueStaticFields.Decimal |> equal 0M
+
+        ClassWithDefaultValueStaticFields.IncrCount() |> equal 1
   ]