From 9a053d5e6c33fe516fdbdac478835be12cdb92b7 Mon Sep 17 00:00:00 2001 From: Daniel Grunwald Date: Sat, 18 Sep 2021 20:42:17 +0200 Subject: [PATCH] nullable enable for CSharpOperators.cs --- .../CSharp/Resolver/CSharpOperators.cs | 138 +++++++++--------- ICSharpCode.Decompiler/Util/CacheManager.cs | 4 +- 2 files changed, 72 insertions(+), 70 deletions(-) diff --git a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs index 1bfef1ecf..868f7fe59 100644 --- a/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs +++ b/ICSharpCode.Decompiler/CSharp/Resolver/CSharpOperators.cs @@ -16,6 +16,8 @@ // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER // DEALINGS IN THE SOFTWARE. +#nullable enable + using System; using System.Collections.Generic; using System.Linq; @@ -45,7 +47,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver public static CSharpOperators Get(ICompilation compilation) { CacheManager cache = compilation.CacheManager; - CSharpOperators operators = (CSharpOperators)cache.GetShared(typeof(CSharpOperators)); + CSharpOperators? operators = (CSharpOperators?)cache.GetShared(typeof(CSharpOperators)); if (operators == null) { operators = (CSharpOperators)cache.GetOrAddShared(typeof(CSharpOperators), new CSharpOperators(compilation)); @@ -59,7 +61,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver List result = new List(methods); foreach (OperatorMethod method in methods) { - OperatorMethod lifted = method.Lift(this); + OperatorMethod? lifted = method.Lift(this); if (lifted != null) result.Add(lifted); } @@ -111,20 +113,20 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return parameters; } } - public IType ReturnType { get; internal set; } + public IType ReturnType { get; internal set; } = null!; // initialized by derived class ctor public ICompilation Compilation { get { return compilation; } } - public virtual OperatorMethod Lift(CSharpOperators operators) + public virtual OperatorMethod? Lift(CSharpOperators operators) { return null; } public System.Reflection.Metadata.EntityHandle MetadataToken => default; - ITypeDefinition IEntity.DeclaringTypeDefinition { + ITypeDefinition? IEntity.DeclaringTypeDefinition { get { return null; } } @@ -226,7 +228,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver return b.ToString(); } - bool IMember.Equals(IMember obj, TypeVisitor typeNormalization) + bool IMember.Equals(IMember? obj, TypeVisitor? typeNormalization) { return this == obj; } @@ -238,7 +240,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver { public virtual bool CanEvaluateAtCompileTime { get { return false; } } - public virtual object Invoke(CSharpResolver resolver, object input) + public virtual object? Invoke(CSharpResolver resolver, object? input) { throw new NotSupportedException(); } @@ -265,7 +267,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return true; } } - public override object Invoke(CSharpResolver resolver, object input) + public override object? Invoke(CSharpResolver resolver, object? input) { if (input == null) return null; @@ -296,11 +298,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver #region Unary operator definitions // C# 4.0 spec: §7.7.1 Unary plus operator - OperatorMethod[] unaryPlusOperators; + OperatorMethod[]? unaryPlusOperators; public OperatorMethod[] UnaryPlusOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref unaryPlusOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref unaryPlusOperators); if (ops != null) { return ops; @@ -321,11 +323,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.7.2 Unary minus operator - OperatorMethod[] uncheckedUnaryMinusOperators; + OperatorMethod[]? uncheckedUnaryMinusOperators; public OperatorMethod[] UncheckedUnaryMinusOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref uncheckedUnaryMinusOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref uncheckedUnaryMinusOperators); if (ops != null) { return ops; @@ -343,11 +345,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] checkedUnaryMinusOperators; + OperatorMethod[]? checkedUnaryMinusOperators; public OperatorMethod[] CheckedUnaryMinusOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref checkedUnaryMinusOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref checkedUnaryMinusOperators); if (ops != null) { return ops; @@ -366,11 +368,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.7.3 Logical negation operator - OperatorMethod[] logicalNegationOperators; + OperatorMethod[]? logicalNegationOperators; public OperatorMethod[] LogicalNegationOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref logicalNegationOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref logicalNegationOperators); if (ops != null) { return ops; @@ -385,11 +387,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.7.4 Bitwise complement operator - OperatorMethod[] bitwiseComplementOperators; + OperatorMethod[]? bitwiseComplementOperators; public OperatorMethod[] BitwiseComplementOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref bitwiseComplementOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref bitwiseComplementOperators); if (ops != null) { return ops; @@ -411,7 +413,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver internal class BinaryOperatorMethod : OperatorMethod { public virtual bool CanEvaluateAtCompileTime { get { return false; } } - public virtual object Invoke(CSharpResolver resolver, object lhs, object rhs) + public virtual object? Invoke(CSharpResolver resolver, object? lhs, object? rhs) { throw new NotSupportedException(); } @@ -444,7 +446,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return true; } } - public override object Invoke(CSharpResolver resolver, object lhs, object rhs) + public override object? Invoke(CSharpResolver resolver, object? lhs, object? rhs) { if (lhs == null || rhs == null) return null; @@ -480,11 +482,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver #region Arithmetic operators // C# 4.0 spec: §7.8.1 Multiplication operator - OperatorMethod[] multiplicationOperators; + OperatorMethod[]? multiplicationOperators; public OperatorMethod[] MultiplicationOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref multiplicationOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref multiplicationOperators); if (ops != null) { return ops; @@ -505,11 +507,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.8.2 Division operator - OperatorMethod[] divisionOperators; + OperatorMethod[]? divisionOperators; public OperatorMethod[] DivisionOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref divisionOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref divisionOperators); if (ops != null) { return ops; @@ -530,11 +532,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.8.3 Remainder operator - OperatorMethod[] remainderOperators; + OperatorMethod[]? remainderOperators; public OperatorMethod[] RemainderOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref remainderOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref remainderOperators); if (ops != null) { return ops; @@ -555,11 +557,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.8.3 Addition operator - OperatorMethod[] additionOperators; + OperatorMethod[]? additionOperators; public OperatorMethod[] AdditionOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref additionOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref additionOperators); if (ops != null) { return ops; @@ -600,18 +602,18 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return canEvaluateAtCompileTime; } } - public override object Invoke(CSharpResolver resolver, object lhs, object rhs) + public override object? Invoke(CSharpResolver? resolver, object? lhs, object? rhs) { return string.Concat(lhs, rhs); } } // C# 4.0 spec: §7.8.4 Subtraction operator - OperatorMethod[] subtractionOperators; + OperatorMethod[]? subtractionOperators; public OperatorMethod[] SubtractionOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref subtractionOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref subtractionOperators); if (ops != null) { return ops; @@ -632,11 +634,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } // C# 4.0 spec: §7.8.5 Shift operators - OperatorMethod[] shiftLeftOperators; + OperatorMethod[]? shiftLeftOperators; public OperatorMethod[] ShiftLeftOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref shiftLeftOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref shiftLeftOperators); if (ops != null) { return ops; @@ -653,11 +655,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] shiftRightOperators; + OperatorMethod[]? shiftRightOperators; public OperatorMethod[] ShiftRightOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref shiftRightOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref shiftRightOperators); if (ops != null) { return ops; @@ -695,7 +697,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return Type != TypeCode.Object; } } - public override object Invoke(CSharpResolver resolver, object lhs, object rhs) + public override object Invoke(CSharpResolver resolver, object? lhs, object? rhs) { if (lhs == null && rhs == null) return !Negate; // ==: true; !=: false @@ -719,7 +721,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver return equal ^ Negate; } - public override OperatorMethod Lift(CSharpOperators operators) + public override OperatorMethod? Lift(CSharpOperators operators) { if (Type == TypeCode.Object || Type == TypeCode.String) return null; @@ -746,7 +748,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return baseMethod.CanEvaluateAtCompileTime; } } - public override object Invoke(CSharpResolver resolver, object lhs, object rhs) + public override object Invoke(CSharpResolver resolver, object? lhs, object? rhs) { return baseMethod.Invoke(resolver, lhs, rhs); } @@ -764,11 +766,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver TypeCode.Boolean }; - OperatorMethod[] valueEqualityOperators; + OperatorMethod[]? valueEqualityOperators; public OperatorMethod[] ValueEqualityOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref valueEqualityOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref valueEqualityOperators); if (ops != null) { return ops; @@ -782,11 +784,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] valueInequalityOperators; + OperatorMethod[]? valueInequalityOperators; public OperatorMethod[] ValueInequalityOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref valueInequalityOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref valueInequalityOperators); if (ops != null) { return ops; @@ -800,11 +802,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] referenceEqualityOperators; + OperatorMethod[]? referenceEqualityOperators; public OperatorMethod[] ReferenceEqualityOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref referenceEqualityOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref referenceEqualityOperators); if (ops != null) { return ops; @@ -819,11 +821,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] referenceInequalityOperators; + OperatorMethod[]? referenceInequalityOperators; public OperatorMethod[] ReferenceInequalityOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref referenceInequalityOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref referenceInequalityOperators); if (ops != null) { return ops; @@ -857,7 +859,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver get { return true; } } - public override object Invoke(CSharpResolver resolver, object lhs, object rhs) + public override object? Invoke(CSharpResolver resolver, object? lhs, object? rhs) { if (lhs == null || rhs == null) return null; @@ -873,11 +875,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] lessThanOperators; + OperatorMethod[]? lessThanOperators; public OperatorMethod[] LessThanOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref lessThanOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref lessThanOperators); if (ops != null) { return ops; @@ -897,11 +899,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] lessThanOrEqualOperators; + OperatorMethod[]? lessThanOrEqualOperators; public OperatorMethod[] LessThanOrEqualOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref lessThanOrEqualOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref lessThanOrEqualOperators); if (ops != null) { return ops; @@ -921,11 +923,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] greaterThanOperators; + OperatorMethod[]? greaterThanOperators; public OperatorMethod[] GreaterThanOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref greaterThanOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref greaterThanOperators); if (ops != null) { return ops; @@ -945,11 +947,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] greaterThanOrEqualOperators; + OperatorMethod[]? greaterThanOrEqualOperators; public OperatorMethod[] GreaterThanOrEqualOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref greaterThanOrEqualOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref greaterThanOrEqualOperators); if (ops != null) { return ops; @@ -971,11 +973,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver #endregion #region Bitwise operators - OperatorMethod[] logicalAndOperators; + OperatorMethod[]? logicalAndOperators; public OperatorMethod[] LogicalAndOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref logicalAndOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref logicalAndOperators); if (ops != null) { return ops; @@ -990,11 +992,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } - OperatorMethod[] bitwiseAndOperators; + OperatorMethod[]? bitwiseAndOperators; public OperatorMethod[] BitwiseAndOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref bitwiseAndOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref bitwiseAndOperators); if (ops != null) { return ops; @@ -1013,11 +1015,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } - OperatorMethod[] logicalOrOperators; + OperatorMethod[]? logicalOrOperators; public OperatorMethod[] LogicalOrOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref logicalOrOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref logicalOrOperators); if (ops != null) { return ops; @@ -1031,11 +1033,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver } } - OperatorMethod[] bitwiseOrOperators; + OperatorMethod[]? bitwiseOrOperators; public OperatorMethod[] BitwiseOrOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref bitwiseOrOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref bitwiseOrOperators); if (ops != null) { return ops; @@ -1057,11 +1059,11 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver // we produce "true | null" = "null" when it should be true. However, this is irrelevant // because bool? cannot be a compile-time type. - OperatorMethod[] bitwiseXorOperators; + OperatorMethod[]? bitwiseXorOperators; public OperatorMethod[] BitwiseXorOperators { get { - OperatorMethod[] ops = LazyInit.VolatileRead(ref bitwiseXorOperators); + OperatorMethod[]? ops = LazyInit.VolatileRead(ref bitwiseXorOperators); if (ops != null) { return ops; @@ -1081,7 +1083,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver #endregion #region User-defined operators - public static IMethod LiftUserDefinedOperator(IMethod m) + public static IMethod? LiftUserDefinedOperator(IMethod m) { if (IsComparisonOperator(m)) { @@ -1129,9 +1131,9 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver public IReadOnlyList NonLiftedParameters => nonLiftedOperator.Parameters; public IType NonLiftedReturnType => nonLiftedOperator.ReturnType; - public override bool Equals(object obj) + public override bool Equals(object? obj) { - LiftedUserDefinedOperator op = obj as LiftedUserDefinedOperator; + LiftedUserDefinedOperator? op = obj as LiftedUserDefinedOperator; return op != null && this.nonLiftedOperator.Equals(op.nonLiftedOperator); } diff --git a/ICSharpCode.Decompiler/Util/CacheManager.cs b/ICSharpCode.Decompiler/Util/CacheManager.cs index 2c3bae375..6ccb1e141 100644 --- a/ICSharpCode.Decompiler/Util/CacheManager.cs +++ b/ICSharpCode.Decompiler/Util/CacheManager.cs @@ -34,9 +34,9 @@ namespace ICSharpCode.Decompiler.Util // There used to be a thread-local dictionary here, but I removed it as it was causing memory // leaks in some use cases. - public object GetShared(object key) + public object? GetShared(object key) { - object value; + object? value; sharedDict.TryGetValue(key, out value); return value; }