MangelMaxime · Nov 5, 2026 · Nov 5, 2026 · Nov 5, 2026 · Nov 5, 2026 · Nov 5, 2026
diff --git a/src/Fable.Transforms/Beam/Fable2Beam.fs b/src/Fable.Transforms/Beam/Fable2Beam.fs
@@ -1646,7 +1646,12 @@ and transformValue
         match com.TryGetEntity(ref) with
         | Some entity ->
             let fieldEntries =
-                List.zip (entity.FSharpFields |> List.map (fun f -> f.Name)) values
+                let fieldNames =
+                    entity.FSharpFields
+                    |> List.filter (fun f -> not f.IsStatic)
+                    |> List.map (fun f -> f.Name)
+
+                List.zip fieldNames values
                 |> List.map (fun (name, value) ->
                     let fieldKey =
                         if ctx.ClassFieldPrefix then

diff --git a/src/Fable.Transforms/FSharp2Fable.fs b/src/Fable.Transforms/FSharp2Fable.fs
@@ -741,6 +741,35 @@ let private transformUnionCaseTest
             return Fable.Test(unionExpr, Fable.UnionCaseTest(tag), r)
     }
 
+let private withDefaultValueFields (com: IFableCompiler) (ctx: Context) (fsType: FSharpType) (args: Fable.Expr list) =
+    let ent = fsType.TypeDefinition
+
+    let isDefaultValueField (field: FSharpField) =
+        not field.IsStatic && hasAttrib Atts.defaultValue field.FieldAttributes
+
+    let fields =
+        ent.FSharpFields |> Seq.filter (fun field -> not field.IsStatic) |> List.ofSeq
+
+    if not ctx.CapturingQuotation && fields |> List.exists isDefaultValueField then
+        let genArgs =
+            Seq.zip ent.GenericParameters (getGenericArguments fsType)
+            |> Seq.map (fun (param, typ) -> genParamName param, makeType ctx.GenericArgs typ)
+            |> Map.ofSeq
+
+        let rec fill (fields: FSharpField list) args =
+            match fields, args with
+            | field :: fields, _ when isDefaultValueField field ->
+                let value =
+                    makeType genArgs field.FieldType |> Replacements.Api.defaultof com ctx None
+
+                value :: fill fields args
+            | _ :: fields, arg :: args -> arg :: fill fields args
+            | _, args -> args
+
+        fill fields args
+    else
+        args
+
 let rec private transformDecisionTargets
     (com: IFableCompiler)
     (ctx: Context)
@@ -1594,6 +1623,7 @@ let private transformExpr (com: IFableCompiler) (ctx: Context) appliedGenArgs fs
             let r = makeRangeFrom fsExpr
             let! baseValue = transformExpr com ctx [] first
             let! ownArgs = transformExprList com ctx ownArgs
+            let ownArgs = withDefaultValueFields com ctx fsType ownArgs
 
             let baseIdent = getIdentUniqueName com ctx "base" |> makeTypedIdent baseValue.Type
 
@@ -1636,6 +1666,7 @@ let private transformExpr (com: IFableCompiler) (ctx: Context) appliedGenArgs fs
         | FSharpExprPatterns.NewRecord(fsType, argExprs) ->
             let r = makeRangeFrom fsExpr
             let! argExprs = transformExprList com ctx argExprs
+            let argExprs = withDefaultValueFields com ctx fsType argExprs
 
             let genArgs = makeTypeGenArgs ctx.GenericArgs (getGenericArguments fsType)
             let entRef = FsEnt.Ref fsType.TypeDefinition

diff --git a/src/Fable.Transforms/QuotationEmitter.fs b/src/Fable.Transforms/QuotationEmitter.fs
@@ -434,7 +434,11 @@ and private emitQuotedValue (com: Compiler) (bound: Set<string>) (kind: ValueKin
     | NewRecord(values, entRef, _genArgs) ->
         let fieldNames =
             match com.TryGetEntity(entRef) with
-            | Some ent -> ent.FSharpFields |> List.map (fun f -> makeStrConst f.Name) |> makeArray Any
+            | Some ent ->
+                ent.FSharpFields
+                |> List.filter (fun f -> not f.IsStatic && not f.HasDefaultValueAttribute)
+                |> List.map (fun f -> makeStrConst f.Name)
+                |> makeArray Any
             | None -> makeArray Any []
 
         let emittedValues =

diff --git a/src/Fable.Transforms/Rust/Fable2Rust.fs b/src/Fable.Transforms/Rust/Fable2Rust.fs
@@ -4364,6 +4364,7 @@ module Util =
     let getEntityFieldsAsIdents com (ent: Fable.Entity) : Fable.Ident list =
         let fieldIdents =
             ent.FSharpFields
+            |> List.filter (fun field -> not field.IsStatic)
             |> List.map (fun field ->
                 let name = field.Name
                 let typ = FableTransforms.uncurryType field.FieldType

diff --git a/src/fable-library-ts/Util.ts b/src/fable-library-ts/Util.ts
@@ -834,6 +834,7 @@ export function uncurry2<T1, T2, TResult>(f: (a1: T1) => (a2: T2) => TResult) {
 }
 
 export function curry2<T1, T2, TResult>(f: (a1: T1, a2: T2) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as ((a1: T1) => (a2: T2) => TResult) ?? ((a1: T1) => (a2: T2) => f(a1, a2));
 }
 
@@ -845,6 +846,7 @@ export function uncurry3<T1, T2, T3, TResult>(f: (a1: T1) => (a2: T2) => (a3: T3
 }
 
 export function curry3<T1, T2, T3, TResult>(f: (a1: T1, a2: T2, a3: T3) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => f(a1, a2, a3));
 }
@@ -859,6 +861,7 @@ export function uncurry4<T1, T2, T3, T4, TResult>(
 }
 
 export function curry4<T1, T2, T3, T4, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => f(a1, a2, a3, a4));
 }
@@ -873,6 +876,7 @@ export function uncurry5<T1, T2, T3, T4, T5, TResult>(
 }
 
 export function curry5<T1, T2, T3, T4, T5, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => f(a1, a2, a3, a4, a5));
 }
@@ -887,6 +891,7 @@ export function uncurry6<T1, T2, T3, T4, T5, T6, TResult>(
 }
 
 export function curry6<T1, T2, T3, T4, T5, T6, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => f(a1, a2, a3, a4, a5, a6));
 }
@@ -901,6 +906,7 @@ export function uncurry7<T1, T2, T3, T4, T5, T6, T7, TResult>(
 }
 
 export function curry7<T1, T2, T3, T4, T5, T6, T7, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => f(a1, a2, a3, a4, a5, a6, a7));
 }
@@ -915,6 +921,7 @@ export function uncurry8<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(
 }
 
 export function curry8<T1, T2, T3, T4, T5, T6, T7, T8, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => f(a1, a2, a3, a4, a5, a6, a7, a8));
 }
@@ -929,6 +936,7 @@ export function uncurry9<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(
 }
 
 export function curry9<T1, T2, T3, T4, T5, T6, T7, T8, T9, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9));
 }
@@ -943,6 +951,7 @@ export function uncurry10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(
 }
 
 export function curry10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10));
 }
@@ -957,6 +966,7 @@ export function uncurry11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>
 }
 
 export function curry11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11));
 }
@@ -971,6 +981,7 @@ export function uncurry12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TRe
 }
 
 export function curry12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12));
 }
@@ -985,6 +996,7 @@ export function uncurry13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13));
 }
@@ -999,6 +1011,7 @@ export function uncurry14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14));
 }
@@ -1013,6 +1026,7 @@ export function uncurry15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15));
 }
@@ -1027,6 +1041,7 @@ export function uncurry16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16));
 }
@@ -1041,6 +1056,7 @@ export function uncurry17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17));
 }
@@ -1055,6 +1071,7 @@ export function uncurry18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18));
 }
@@ -1069,6 +1086,7 @@ export function uncurry19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18, a19: T19) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19));
 }
@@ -1083,6 +1101,7 @@ export function uncurry20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13
 }
 
 export function curry20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, TResult>(f: (a1: T1, a2: T2, a3: T3, a4: T4, a5: T5, a6: T6, a7: T7, a8: T8, a9: T9, a10: T10, a11: T11, a12: T12, a13: T13, a14: T14, a15: T15, a16: T16, a17: T17, a18: T18, a19: T19, a20: T20) => TResult) {
+  if (f == null) { return null as never; }
   return getCurried(f) as (a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => (a20: T20) => TResult
     ?? ((a1: T1) => (a2: T2) => (a3: T3) => (a4: T4) => (a5: T5) => (a6: T6) => (a7: T7) => (a8: T8) => (a9: T9) => (a10: T10) => (a11: T11) => (a12: T12) => (a13: T13) => (a14: T14) => (a15: T15) => (a16: T16) => (a17: T17) => (a18: T18) => (a19: T19) => (a20: T20) => f(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20));
 }

diff --git a/tests/Beam/TypeTests.fs b/tests/Beam/TypeTests.fs
@@ -60,6 +60,32 @@ type Point2D =
         new(xy: float) = { X = xy; Y = xy }
     end
 
+type ClassWithDefaultValueInstanceFields =
+    val X: int
+    [<DefaultValue>]
+    val mutable D: int
+    [<DefaultValue>]
+    val mutable S: string
+    val Y: string
+    new(x, y) = { X = x; Y = y }
+
+[<Struct>]
+type StructWithDefaultValueInstanceField =
+    val X: int
+    [<DefaultValue(false)>]
+    val mutable D: int
+    val Y: string
+    new(x, y) = { X = x; Y = y }
+
+type ClassWithDefaultValueStaticAndInstanceFields =
+    [<DefaultValue>]
+    static val mutable private count: int
+    val X: int
+    [<DefaultValue>]
+    val mutable D: int
+    val Y: int
+    new(x, y) = { X = x; Y = y }
+
 exception MyEx of int * string
 
 type MyEx2(f: float) =
@@ -652,6 +678,32 @@ let ``test Other Value Types work`` () =
     let p = Point2D(2.)
     p.Y |> equal 2.
 
+[<Fact>]
+let ``test Instance DefaultValue fields are skipped by explicit constructors`` () =
+    let c = ClassWithDefaultValueInstanceFields(1, "y")
+    c.X |> equal 1
+    c.D |> equal 0
+    c.S |> equal null
+    c.Y |> equal "y"
+    c.D <- 5
+    c.S <- "s"
+    c.D |> equal 5
+    c.S |> equal "s"
+
+    let mutable s = StructWithDefaultValueInstanceField(2, "z")
+    s.X |> equal 2
+    s.D |> equal 0
+    s.Y |> equal "z"
+    s.D <- 6
+    s.D |> equal 6
+
+[<Fact>]
+let ``test Explicit constructors skip static fields next to DefaultValue fields`` () =
+    let c = ClassWithDefaultValueStaticAndInstanceFields(1, 2)
+    c.X |> equal 1
+    c.D |> equal 0
+    c.Y |> equal 2
+
 [<Fact>]
 let ``test Struct with mutable fields works`` () =
     let x = ValueTypeR(-10.0)

diff --git a/tests/Js/Main/QuotationTests.fs b/tests/Js/Main/QuotationTests.fs
@@ -16,6 +16,8 @@ type QuotationTestUnion =
 
 let inline quotTestDouble x = x * 2
 
+type QuotationDefaultValueRecord = { A: int; [<DefaultValue>] mutable B: int; C: string }
+
 type QuotationIndexerTest(values: int[]) =
     member _.Item
         with get (i: int) = values.[i]
@@ -321,4 +323,10 @@ let tests =
          | Lambda(_, Var _) -> "Var"
          | _ -> "?")
         |> equal "Var"
+
+    testCase "NewRecord leaves out DefaultValue fields" <| fun () ->
+        (match <@ { A = 1; C = "c" }: QuotationDefaultValueRecord @> with
+         | NewRecord(_, args) -> args |> Seq.map (function Value(v, _) -> string v | _ -> "?") |> String.concat ","
+         | _ -> "other")
+        |> equal "1,c"
   ]