Move null checking to compiler-side using nullable annotations

alinpahontu2912 · alinpahontu2912 · commit b63214d37e73 · 2026-02-17T10:54:29.000Z
- Remove redundant runtime null checks from non-nullable Parameter weight
  setters in Linear, Bilinear, Convolution, PReLU, GroupNorm, LayerNorm,
  and NormBase (already enforced by #nullable enable)
- Add [DisallowNull] to Parameter? properties in RNNCell, LSTMCell,
  GRUCell, Embedding, and EmbeddingBag where getter can return null but
  setter must not accept null
- Enable #nullable enable in Transforms.cs and remove runtime null check
  from ComposeTransform constructor
- Remove runtime null check from Module.get_buffer() (string parameter
  is non-nullable under #nullable enable)
- Add DisallowNullAttribute polyfill in netstandard.cs for
  netstandard2.0 compatibility
diff --git a/src/TorchSharp/Distributions/Transforms.cs b/src/TorchSharp/Distributions/Transforms.cs
@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.Linq;
 
+#nullable enable
 namespace TorchSharp
 {
 
@@ -26,11 +27,11 @@ public abstract class Transform
                 {
                     protected bool _bijective = false;
 
-                    protected constraints.Constraint _domain;
+                    protected constraints.Constraint _domain = null!;
 
-                    protected constraints.Constraint _codomain;
+                    protected constraints.Constraint _codomain = null!;
 
-                    protected Transform _inv = null;
+                    protected Transform? _inv = null;
 
                     public virtual int event_dim {
                         get {
@@ -42,7 +43,7 @@ public virtual int event_dim {
 
                     public virtual Transform inv {
                         get {
-                            Transform result = null;
+                            Transform? result = null;
                             if (this._inv != null)
                                 result = _inv;
                             if (result == null) {
@@ -118,19 +119,19 @@ public _InverseTransform(torch.distributions.transforms.Transform transform)
 
                     public override constraints.Constraint domain {
                         get {
-                            return _inv.domain;
+                            return _inv!.domain;
                         }
                     }
 
                     public override constraints.Constraint codomain {
                         get {
-                            return _inv.codomain;
+                            return _inv!.codomain;
                         }
                     }
 
                     public override bool bijective {
                         get {
-                            return _inv.bijective;
+                            return _inv!.bijective;
                         }
                     }
 
@@ -140,41 +141,39 @@ public override bool bijective {
 
                     protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)
                     {
-                        return -_inv.log_abs_det_jacobian(y, x);
+                        return -_inv!.log_abs_det_jacobian(y, x);
                     }
 
                     protected internal override Tensor _call(Tensor x)
                     {
-                        return _inv._inverse(x);
+                        return _inv!._inverse(x);
                     }
 
                     protected internal override Tensor _inverse(Tensor y)
                     {
-                        return _inv._call(y);
+                        return _inv!._call(y);
                     }
 
                     protected internal override Tensor _sign()
                     {
-                        return _inv.sign;
+                        return _inv!.sign;
                     }
 
                     public override long[] forward_shape(long[] shape)
                     {
-                        return _inv.forward_shape(shape);
+                        return _inv!.forward_shape(shape);
                     }
 
                     public override long[] inverse_shape(long[] shape)
                     {
-                        return _inv.inverse_shape(shape);
+                        return _inv!.inverse_shape(shape);
                     }
                 }
 
                 public class ComposeTransform : Transform
                 {
                     public ComposeTransform(IEnumerable<Transform> parts, int cache_size = 0)
                     {
-                        if (parts == null) throw new ArgumentNullException("parts cannot be null");
-
                         _parts = parts.ToArray();
                         _reverse_parts = parts.Reverse().ToArray();
                     }
@@ -186,13 +185,13 @@ public ComposeTransform(IEnumerable<Transform> parts, int cache_size = 0)
 
                     public override Transform inv {
                         get {
-                            Transform i = _inv;
+                            Transform? i = _inv;
 
                             if (i == null) {
                                 i = new ComposeTransform(_reverse_parts.Select(p => p.inv));
                                 _inv = i;
                             }
-                            return _inv;
+                            return _inv!;
                         }
                     }
 
diff --git a/src/TorchSharp/NN/Activation/PReLU.cs b/src/TorchSharp/NN/Activation/PReLU.cs
@@ -40,7 +40,6 @@ public override string GetName()
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Bilinear.cs b/src/TorchSharp/NN/Bilinear.cs
@@ -60,7 +60,6 @@ public Parameter? bias {
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Convolution/Convolution.cs b/src/TorchSharp/NN/Convolution/Convolution.cs
@@ -145,7 +145,6 @@ public Parameter? bias {
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Embedding.cs b/src/TorchSharp/NN/Embedding.cs
@@ -1,5 +1,6 @@
 // Copyright (c) .NET Foundation and Contributors.  All Rights Reserved.  See LICENSE in the project root for license information.
 using System;
+using System.Diagnostics.CodeAnalysis;
 using static TorchSharp.torch;
 using static TorchSharp.PInvoke.NativeMethods;
 
@@ -21,16 +22,15 @@ public override Tensor forward(Tensor input)
                 return new Tensor(res);
             }
 
+            [DisallowNull]
             public Parameter? weight {
                 get {
                     var res = THSNN_Embedding_weight(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return (res == IntPtr.Zero) ? null : new Parameter(res);
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight cannot be set to 'null'");
-                    THSNN_Embedding_set_weight(handle, value is null ? IntPtr.Zero : value.Handle);
+                    THSNN_Embedding_set_weight(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("weight", value);
                 }
diff --git a/src/TorchSharp/NN/EmbeddingBag.cs b/src/TorchSharp/NN/EmbeddingBag.cs
@@ -1,5 +1,6 @@
 // Copyright (c) .NET Foundation and Contributors.  All Rights Reserved.  See LICENSE in the project root for license information.
 using System;
+using System.Diagnostics.CodeAnalysis;
 using static TorchSharp.torch;
 using static TorchSharp.PInvoke.NativeMethods;
 
@@ -82,16 +83,15 @@ public Tensor call(Tensor input)
                 return base.call(input, null, null);
             }
 
+            [DisallowNull]
             public Parameter? weight {
                 get {
                     var res = THSNN_EmbeddingBag_weight(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return (res == IntPtr.Zero) ? null : new Parameter(res);
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight cannot be set to 'null'");
-                    THSNN_EmbeddingBag_set_weight(handle, value is null ? IntPtr.Zero : value.Handle);
+                    THSNN_EmbeddingBag_set_weight(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("weight", value);
                 }
diff --git a/src/TorchSharp/NN/Linear.cs b/src/TorchSharp/NN/Linear.cs
@@ -70,7 +70,6 @@ public Parameter? bias {
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Module.cs b/src/TorchSharp/NN/Module.cs
@@ -697,7 +697,6 @@ public virtual bool has_parameter(string target)
                 /// <returns>The tensor referenced by target</returns>
                 public virtual Tensor? get_buffer(string target)
                 {
-                    if (target is null) throw new ArgumentNullException("target");
                     if (_internal_buffers.TryGetValue(target, out var buffer)) {
                         return buffer.Item1;
                     }
diff --git a/src/TorchSharp/NN/Normalization/GroupNorm.cs b/src/TorchSharp/NN/Normalization/GroupNorm.cs
@@ -57,7 +57,6 @@ public Parameter? bias {
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Normalization/LayerNorm.cs b/src/TorchSharp/NN/Normalization/LayerNorm.cs
@@ -75,7 +75,6 @@ public Parameter? bias {
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Normalization/NormBase.cs b/src/TorchSharp/NN/Normalization/NormBase.cs
@@ -87,7 +87,6 @@ public Parameter? bias {
             public Parameter weight {
                 get => _weight!;
                 set {
-                    if (value is null) throw new ArgumentNullException(nameof(weight));
                     if (value.Handle != _weight?.Handle) {
                         _weight?.Dispose();
                         _weight = (value.DetachFromDisposeScope() as Parameter)!;
diff --git a/src/TorchSharp/NN/Recurrent/GRUCell.cs b/src/TorchSharp/NN/Recurrent/GRUCell.cs
@@ -1,5 +1,6 @@
 // Copyright (c) .NET Foundation and Contributors.  All Rights Reserved.  See LICENSE in the project root for license information.
 using System;
+using System.Diagnostics.CodeAnalysis;
 using static TorchSharp.torch;
 using static TorchSharp.torch.nn;
 using static TorchSharp.PInvoke.NativeMethods;
@@ -28,61 +29,57 @@ public override Tensor forward(Tensor input, Tensor? h0 = null)
                 return new Tensor(hN);
             }
 
+            [DisallowNull]
             public Parameter? bias_ih {
                 get {
                     var res = THSNN_GRUCell_bias_ih(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return ((res == IntPtr.Zero) ? null : new Parameter(res));
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("bias_ih cannot be set to 'null'");
-                    THSNN_GRUCell_set_bias_ih(handle, (value is null ? IntPtr.Zero : value.Handle));
+                    THSNN_GRUCell_set_bias_ih(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("bias_ih", value);
                 }
             }
 
+            [DisallowNull]
             public Parameter? bias_hh {
                 get {
                     var res = THSNN_GRUCell_bias_hh(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return ((res == IntPtr.Zero) ? null : new Parameter(res));
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("bias_hh cannot be set to 'null'");
-                    THSNN_GRUCell_set_bias_hh(handle, (value is null ? IntPtr.Zero : value.Handle));
+                    THSNN_GRUCell_set_bias_hh(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("bias_hh", value);
                 }
             }
 
+            [DisallowNull]
             public Parameter? weight_ih {
                 get {
                     var res = THSNN_GRUCell_weight_ih(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return (res == IntPtr.Zero) ? null : new Parameter(res);
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight_ih cannot be set to 'null'");
-                    THSNN_GRUCell_set_weight_ih(handle, value is null ? IntPtr.Zero : value.Handle);
+                    THSNN_GRUCell_set_weight_ih(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("weight_ih", value);
                 }
             }
 
+            [DisallowNull]
             public Parameter? weight_hh {
                 get {
                     var res = THSNN_GRUCell_weight_hh(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return (res == IntPtr.Zero) ? null : new Parameter(res);
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight_hh cannot be set to 'null'");
-                    THSNN_GRUCell_set_weight_hh(handle, value is null ? IntPtr.Zero : value.Handle);
+                    THSNN_GRUCell_set_weight_hh(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("weight_hh", value);
                 }
diff --git a/src/TorchSharp/NN/Recurrent/LSTMCell.cs b/src/TorchSharp/NN/Recurrent/LSTMCell.cs
@@ -1,5 +1,6 @@
 // Copyright (c) .NET Foundation and Contributors.  All Rights Reserved.  See LICENSE in the project root for license information.
 using System;
+using System.Diagnostics.CodeAnalysis;
 using static TorchSharp.torch;
 using static TorchSharp.torch.nn;
 using static TorchSharp.PInvoke.NativeMethods;
@@ -30,61 +31,57 @@ public override (Tensor, Tensor) forward(Tensor input, (Tensor, Tensor)? h0_c0)
 
             public new (Tensor, Tensor) call(Tensor input, (Tensor, Tensor)? h0_c0 = null) => base.call(input, h0_c0);
 
+            [DisallowNull]
             public Parameter? bias_ih {
                 get {
                     var res = THSNN_LSTMCell_bias_ih(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return ((res == IntPtr.Zero) ? null : new Parameter(res));
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("bias_ih cannot be set to 'null'");
-                    THSNN_LSTMCell_set_bias_ih(handle, (value is null ? IntPtr.Zero : value.Handle));
+                    THSNN_LSTMCell_set_bias_ih(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("bias_ih", value);
                 }
             }
 
+            [DisallowNull]
             public Parameter? bias_hh {
                 get {
                     var res = THSNN_LSTMCell_bias_hh(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return ((res == IntPtr.Zero) ? null : new Parameter(res));
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("bias_hh cannot be set to 'null'");
-                    THSNN_LSTMCell_set_bias_hh(handle, (value is null ? IntPtr.Zero : value.Handle));
+                    THSNN_LSTMCell_set_bias_hh(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("bias_hh", value);
                 }
             }
 
+            [DisallowNull]
             public Parameter? weight_ih {
                 get {
                     var res = THSNN_LSTMCell_weight_ih(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return (res == IntPtr.Zero) ? null : new Parameter(res);
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight_ih cannot be set to 'null'");
-                    THSNN_LSTMCell_set_weight_ih(handle, (value is null ? IntPtr.Zero : value.Handle));
+                    THSNN_LSTMCell_set_weight_ih(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("weight_ih", value);
                 }
             }
 
+            [DisallowNull]
             public Parameter? weight_hh {
                 get {
                     var res = THSNN_LSTMCell_weight_hh(handle);
                     if (res == IntPtr.Zero) { torch.CheckForErrors(); }
                     return (res == IntPtr.Zero) ? null : new Parameter(res);
                 }
                 set {
-                    // Please ignore, for now, that the litorch call thinks you *can* set it to null.
-                    if (value is null) throw new ArgumentNullException("weight_hh cannot be set to 'null'");
-                    THSNN_LSTMCell_set_weight_hh(handle, (value is null ? IntPtr.Zero : value.Handle));
+                    THSNN_LSTMCell_set_weight_hh(handle, value.Handle);
                     torch.CheckForErrors();
                     ConditionallyRegisterParameter("weight_hh", value);
                 }
diff --git a/src/TorchSharp/NN/Recurrent/RNNCell.cs b/src/TorchSharp/NN/Recurrent/RNNCell.cs
diff --git a/src/TorchSharp/netstandard.cs b/src/TorchSharp/netstandard.cs

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`using System.Collections.Generic;`
`4`	`4`	`using System.Linq;`
`5`	`5`
	`6`	`+#nullable enable`
`6`	`7`	`namespace TorchSharp`
`7`	`8`	`{`
`8`	`9`
`@@ -26,11 +27,11 @@ public abstract class Transform`
`26`	`27`	`{`
`27`	`28`	`protected bool _bijective = false;`
`28`	`29`
`29`		`- protected constraints.Constraint _domain;`
	`30`	`+ protected constraints.Constraint _domain = null!;`
`30`	`31`
`31`		`- protected constraints.Constraint _codomain;`
	`32`	`+ protected constraints.Constraint _codomain = null!;`
`32`	`33`
`33`		`- protected Transform _inv = null;`
	`34`	`+ protected Transform? _inv = null;`
`34`	`35`
`35`	`36`	`public virtual int event_dim {`
`36`	`37`	`get {`
`@@ -42,7 +43,7 @@ public virtual int event_dim {`
`42`	`43`
`43`	`44`	`public virtual Transform inv {`
`44`	`45`	`get {`
`45`		`- Transform result = null;`
	`46`	`+ Transform? result = null;`
`46`	`47`	`if (this._inv != null)`
`47`	`48`	`result = _inv;`
`48`	`49`	`if (result == null) {`
`@@ -118,19 +119,19 @@ public _InverseTransform(torch.distributions.transforms.Transform transform)`
`118`	`119`
`119`	`120`	`public override constraints.Constraint domain {`
`120`	`121`	`get {`
`121`		`- return _inv.domain;`
	`122`	`+ return _inv!.domain;`
`122`	`123`	`}`
`123`	`124`	`}`
`124`	`125`
`125`	`126`	`public override constraints.Constraint codomain {`
`126`	`127`	`get {`
`127`		`- return _inv.codomain;`
	`128`	`+ return _inv!.codomain;`
`128`	`129`	`}`
`129`	`130`	`}`
`130`	`131`
`131`	`132`	`public override bool bijective {`
`132`	`133`	`get {`
`133`		`- return _inv.bijective;`
	`134`	`+ return _inv!.bijective;`
`134`	`135`	`}`
`135`	`136`	`}`
`136`	`137`
`@@ -140,41 +141,39 @@ public override bool bijective {`
`140`	`141`
`141`	`142`	`protected internal override Tensor log_abs_det_jacobian(Tensor x, Tensor y)`
`142`	`143`	`{`
`143`		`- return -_inv.log_abs_det_jacobian(y, x);`
	`144`	`+ return -_inv!.log_abs_det_jacobian(y, x);`
`144`	`145`	`}`
`145`	`146`
`146`	`147`	`protected internal override Tensor _call(Tensor x)`
`147`	`148`	`{`
`148`		`- return _inv._inverse(x);`
	`149`	`+ return _inv!._inverse(x);`
`149`	`150`	`}`
`150`	`151`
`151`	`152`	`protected internal override Tensor _inverse(Tensor y)`
`152`	`153`	`{`
`153`		`- return _inv._call(y);`
	`154`	`+ return _inv!._call(y);`
`154`	`155`	`}`
`155`	`156`
`156`	`157`	`protected internal override Tensor _sign()`
`157`	`158`	`{`
`158`		`- return _inv.sign;`
	`159`	`+ return _inv!.sign;`
`159`	`160`	`}`
`160`	`161`
`161`	`162`	`public override long[] forward_shape(long[] shape)`
`162`	`163`	`{`
`163`		`- return _inv.forward_shape(shape);`
	`164`	`+ return _inv!.forward_shape(shape);`
`164`	`165`	`}`
`165`	`166`
`166`	`167`	`public override long[] inverse_shape(long[] shape)`
`167`	`168`	`{`
`168`		`- return _inv.inverse_shape(shape);`
	`169`	`+ return _inv!.inverse_shape(shape);`
`169`	`170`	`}`
`170`	`171`	`}`
`171`	`172`
`172`	`173`	`public class ComposeTransform : Transform`
`173`	`174`	`{`
`174`	`175`	`public ComposeTransform(IEnumerable<Transform> parts, int cache_size = 0)`
`175`	`176`	`{`
`176`		`- if (parts == null) throw new ArgumentNullException("parts cannot be null");`
`177`		`-`
`178`	`177`	`_parts = parts.ToArray();`
`179`	`178`	`_reverse_parts = parts.Reverse().ToArray();`
`180`	`179`	`}`
`@@ -186,13 +185,13 @@ public ComposeTransform(IEnumerable<Transform> parts, int cache_size = 0)`
`186`	`185`
`187`	`186`	`public override Transform inv {`
`188`	`187`	`get {`
`189`		`- Transform i = _inv;`
	`188`	`+ Transform? i = _inv;`
`190`	`189`
`191`	`190`	`if (i == null) {`
`192`	`191`	`i = new ComposeTransform(_reverse_parts.Select(p => p.inv));`
`193`	`192`	`_inv = i;`
`194`	`193`	`}`
`195`		`- return _inv;`
	`194`	`+ return _inv!;`
`196`	`195`	`}`
`197`	`196`	`}`
`198`	`197`
Original file line number	Diff line number	Diff line change
`@@ -697,7 +697,6 @@ public virtual bool has_parameter(string target)`
`697`	`697`	`/// <returns>The tensor referenced by target</returns>`
`698`	`698`	`public virtual Tensor? get_buffer(string target)`
`699`	`699`	`{`
`700`		`- if (target is null) throw new ArgumentNullException("target");`
`701`	`700`	`if (_internal_buffers.TryGetValue(target, out var buffer)) {`
`702`	`701`	`return buffer.Item1;`
`703`	`702`	`}`