Updated CSharpConversions according to https://github.com/dotnet/csharpstandard/blob/draft-v9/standard/conversions.md

Author: siegfriedpammer

ICSharpCode.Decompiler.Tests/Semantics/ConversionTests.cs

@@ -175,6 +175,16 @@ public void NullableConversions2()
 			Assert.That(ImplicitConversion(typeof(float?), typeof(decimal?)), Is.EqualTo(C.None));
 		}
 
+		[Test]
+		public void NullableEnumerationConversion()
+		{
+			ResolveResult zero = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 0);
+			ResolveResult one = new ConstantResolveResult(compilation.FindType(KnownTypeCode.Int32), 1);
+			C implicitEnumerationConversion = C.EnumerationConversion(true, true);
+			Assert.That(conversions.ImplicitConversion(zero, compilation.FindType(typeof(StringComparison?))), Is.EqualTo(implicitEnumerationConversion));
+			Assert.That(conversions.ImplicitConversion(one, compilation.FindType(typeof(StringComparison?))), Is.EqualTo(C.None));
+		}
+
 		[Test]
 		public void NullLiteralConversions()
 		{

ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs

@@ -109,6 +109,7 @@ private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType,
 				if (ImplicitConstantExpressionConversion(resolveResult, toType))
 					return Conversion.ImplicitConstantExpressionConversion;
 			}
+			// C# 9.0 spec: §10.2.5
 			if (resolveResult is InterpolatedStringResolveResult)
 			{
 				if (toType.IsKnownType(KnownTypeCode.IFormattable) || toType.IsKnownType(KnownTypeCode.FormattableString))
@@ -122,6 +123,8 @@ private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType,
 			c = MethodGroupConversion(resolveResult, toType);
 			if (c != Conversion.None)
 				return c;
+			// C# 9.0 spec: §10.2.16 default literal conversions
+			// TODO
 			if (resolveResult.IsCompileTimeConstant)
 			{
 				c = StandardImplicitConversion(resolveResult.Type, toType, allowTuple);
@@ -142,6 +145,7 @@ private Conversion ImplicitConversion(ResolveResult resolveResult, IType toType,
 					if (c != Conversion.None)
 						return c;
 				}
+				// C# 9.0 spec: §10.2.17
 				if (resolveResult is ThrowResolveResult)
 				{
 					return Conversion.ThrowExpressionConversion;
@@ -205,7 +209,7 @@ public Conversion StandardImplicitConversion(IType fromType, IType toType)
 
 		Conversion StandardImplicitConversion(IType fromType, IType toType, bool allowTupleConversion)
 		{
-			// C# 4.0 spec: §6.3.1
+			// C# 9.0 spec: §10.4.2
 			if (IdentityConversion(fromType, toType))
 				return Conversion.IdentityConversion;
 			if (ImplicitNumericConversion(fromType, toType))
@@ -229,6 +233,8 @@ Conversion StandardImplicitConversion(IType fromType, IType toType, bool allowTu
 				return Conversion.ImplicitPointerConversion;
 			if (allowTupleConversion)
 			{
+				// TODO are tuple conversions really standard implicit conversions?
+				// the C# 9.0 spec doesn't list them as standard implicit conversions.
 				c = TupleConversion(fromType, toType, isExplicit: false);
 				if (c != Conversion.None)
 					return c;
@@ -380,7 +386,7 @@ public bool IdentityConversion(IType fromType, IType toType)
 
 		bool ImplicitNumericConversion(IType fromType, IType toType)
 		{
-			// C# 4.0 spec: §6.1.2
+			// C# 9.0 spec: §10.2.3
 
 			TypeCode from = ReflectionHelper.GetTypeCode(fromType);
 			if (from == TypeCode.Empty)
@@ -448,7 +454,7 @@ bool AnyNumericConversion(IType fromType, IType toType)
 		#region Enumeration Conversions
 		Conversion ImplicitEnumerationConversion(ResolveResult rr, IType toType)
 		{
-			// C# 4.0 spec: §6.1.3
+			// C# 9.0 spec: §10.2.4 + enum part of §10.2.6 (Nullable conversions)
 			Debug.Assert(rr.IsCompileTimeConstant);
 			TypeCode constantType = ReflectionHelper.GetTypeCode(rr.Type);
 			if (constantType >= TypeCode.SByte && constantType <= TypeCode.Decimal && Convert.ToDouble(rr.ConstantValue) == 0)
@@ -479,7 +485,7 @@ bool ExplicitEnumerationConversion(IType fromType, IType toType)
 		#region Nullable Conversions
 		Conversion ImplicitNullableConversion(IType fromType, IType toType)
 		{
-			// C# 4.0 spec: §6.1.4
+			// C# 9.0 spec: §10.2.6
 			if (NullableType.IsNullable(toType))
 			{
 				IType t = NullableType.GetUnderlyingType(toType);
@@ -513,7 +519,7 @@ Conversion ExplicitNullableConversion(IType fromType, IType toType)
 		#region Null Literal Conversion
 		bool NullLiteralConversion(IType fromType, IType toType)
 		{
-			// C# 4.0 spec: §6.1.5
+			// C# 9.0 spec: §10.2.7
 			if (fromType.Kind == TypeKind.Null)
 			{
 				return NullableType.IsNullable(toType) || toType.IsReferenceType == true;
@@ -533,7 +539,7 @@ public bool IsImplicitReferenceConversion(IType fromType, IType toType)
 
 		bool ImplicitReferenceConversion(IType fromType, IType toType, int subtypeCheckNestingDepth)
 		{
-			// C# 4.0 spec: §6.1.6
+			// C# 9.0 spec: §10.2.8
 
 			// reference conversions are possible:
 			// - if both types are known to be reference types
@@ -552,7 +558,7 @@ bool ImplicitReferenceConversion(IType fromType, IType toType, int subtypeCheckN
 					return fromArray.Dimensions == toArray.Dimensions
 						&& ImplicitReferenceConversion(fromArray.ElementType, toArray.ElementType, subtypeCheckNestingDepth);
 				}
-				// conversion from single-dimensional array S[] to IList<T>:
+				// conversion from single-dimensional array S[] to IList<T>/IReadOnlyList<T> + base interfaces:
 				IType toTypeArgument = UnpackGenericArrayInterface(toType);
 				if (fromArray.Dimensions == 1 && toTypeArgument != null)
 				{
@@ -570,20 +576,20 @@ bool ImplicitReferenceConversion(IType fromType, IType toType, int subtypeCheckN
 		}
 
 		/// <summary>
-		/// For IList{T}, ICollection{T}, IEnumerable{T} and IReadOnlyList{T}, returns T.
+		/// For <see cref="IList{T}"/>, <see cref="ICollection{T}"/>, <see cref="IEnumerable{T}"/> and <see cref="IReadOnlyList{T}"/>, returns T.
 		/// Otherwise, returns null.
 		/// </summary>
 		IType UnpackGenericArrayInterface(IType interfaceType)
 		{
-			ParameterizedType pt = interfaceType as ParameterizedType;
-			if (pt != null)
+			if (interfaceType is ParameterizedType pt)
 			{
 				switch (pt.GetDefinition()?.KnownTypeCode)
 				{
 					case KnownTypeCode.IListOfT:
 					case KnownTypeCode.ICollectionOfT:
 					case KnownTypeCode.IEnumerableOfT:
 					case KnownTypeCode.IReadOnlyListOfT:
+					case KnownTypeCode.IReadOnlyCollectionOfT:
 						return pt.GetTypeArgument(0);
 				}
 			}
@@ -780,7 +786,7 @@ bool IsSealedReferenceType(IType type)
 		#region Boxing Conversions
 		bool IsBoxingConversion(IType fromType, IType toType)
 		{
-			// C# 4.0 spec: §6.1.7
+			// C# 9.0 spec: §10.2.9
 			fromType = NullableType.GetUnderlyingType(fromType);
 			if (fromType.IsReferenceType == false && !fromType.IsByRefLike && toType.IsReferenceType == true)
 				return IsSubtypeOf(fromType, toType, 0);
@@ -815,7 +821,7 @@ bool ImplicitConstantExpressionConversion(ResolveResult rr, IType toType)
 		{
 			if (rr == null || !rr.IsCompileTimeConstant)
 				return false;
-			// C# 4.0 spec: §6.1.9
+			// C# 9.0 spec: §10.2.11 + part of §10.2.6 (Nullable conversions)
 			TypeCode fromTypeCode = ReflectionHelper.GetTypeCode(rr.Type);
 			toType = NullableType.GetUnderlyingType(toType);
 			TypeCode toTypeCode = ReflectionHelper.GetTypeCode(toType);
@@ -859,10 +865,11 @@ bool ImplicitConstantExpressionConversion(ResolveResult rr, IType toType)
 		/// </summary>
 		bool ImplicitTypeParameterConversion(IType fromType, IType toType)
 		{
+			// C# 9.0 spec: §10.2.12
 			if (fromType.Kind != TypeKind.TypeParameter)
 				return false; // not a type parameter
-			if (fromType.IsReferenceType == true)
-				return false; // already handled by ImplicitReferenceConversion
+			if (fromType.IsReferenceType.HasValue)
+				return false; // already handled by ImplicitReferenceConversion/BoxingConversion
 			return IsSubtypeOf(fromType, toType, 0);
 		}
 
@@ -1212,7 +1219,7 @@ List<OperatorInfo> GetApplicableConversionOperators(ResolveResult fromResult, IT
 		#region AnonymousFunctionConversion
 		Conversion AnonymousFunctionConversion(ResolveResult resolveResult, IType toType)
 		{
-			// C# 5.0 spec §6.5 Anonymous function conversions
+			// C# 9.0 spec §10.7 Anonymous function conversions
 			LambdaResolveResult f = resolveResult as LambdaResolveResult;
 			if (f == null)
 				return Conversion.None;
@@ -1242,6 +1249,7 @@ Conversion AnonymousFunctionConversion(ResolveResult resolveResult, IType toType
 				if (f.IsImplicitlyTyped)
 				{
 					// If F has an implicitly typed parameter list, D has no ref or out parameters.
+					// TODO: what about in parameters?
 					foreach (IParameter p in d.Parameters)
 					{
 						if (p.ReferenceKind != ReferenceKind.None)
@@ -1294,9 +1302,8 @@ static IType UnpackExpressionTreeType(IType type)
 		#region MethodGroupConversion
 		Conversion MethodGroupConversion(ResolveResult resolveResult, IType toType)
 		{
-			// C# 4.0 spec §6.6 Method group conversions
-			MethodGroupResolveResult rr = resolveResult as MethodGroupResolveResult;
-			if (rr == null)
+			// C# 9.0 spec §10.8 Method group conversions
+			if (resolveResult is not MethodGroupResolveResult rr)
 				return Conversion.None;
 			IMethod invoke = toType.GetDelegateInvokeMethod();
 			if (invoke == null)
@@ -1312,6 +1319,10 @@ Conversion MethodGroupConversion(ResolveResult resolveResult, IType toType)
 					parameterType = ((ByReferenceType)parameterType).ElementType;
 					args[i] = new ByReferenceResolveResult(parameterType, param.ReferenceKind);
 				}
+				else if (param.Type.Kind == TypeKind.Dynamic)
+				{
+					args[i] = new ResolveResult(compilation.FindType(KnownTypeCode.Object));
+				}
 				else
 				{
 					args[i] = new ResolveResult(parameterType);
@@ -1327,8 +1338,7 @@ Conversion MethodGroupConversion(ResolveResult resolveResult, IType toType)
 			if (or.FoundApplicableCandidate)
 			{
 				IMethod method = (IMethod)or.GetBestCandidateWithSubstitutedTypeArguments();
-				var thisRR = rr.TargetResult as ThisResolveResult;
-				bool isVirtual = method.IsOverridable && !(thisRR != null && thisRR.CausesNonVirtualInvocation);
+				bool isVirtual = method.IsOverridable && !(rr.TargetResult is ThisResolveResult { CausesNonVirtualInvocation: true });
 				bool isValid = !or.IsAmbiguous && IsDelegateCompatible(method, invoke, or.IsExtensionMethodInvocation);
 				bool delegateCapturesFirstArgument = or.IsExtensionMethodInvocation || !method.IsStatic;
 				if (isValid)
@@ -1362,32 +1372,33 @@ public bool IsDelegateCompatible(IMethod method, IType delegateType)
 
 		/// <summary>
 		/// Gets whether a method <paramref name="m"/> is compatible with a delegate type.
-		/// §15.2 Delegate compatibility
 		/// </summary>
 		/// <param name="m">The method to test for compatibility</param>
-		/// <param name="invoke">The invoke method of the delegate</param>
+		/// <param name="d">The invoke method of the delegate</param>
 		/// <param name="isExtensionMethodInvocation">Gets whether m is accessed using extension method syntax.
 		/// If this parameter is true, the first parameter of <paramref name="m"/> will be ignored.</param>
-		bool IsDelegateCompatible(IMethod m, IMethod invoke, bool isExtensionMethodInvocation)
+		bool IsDelegateCompatible(IMethod m, IMethod d, bool isExtensionMethodInvocation)
 		{
+			// C# 9.0 §20.4 Delegate compatibility
 			if (m == null)
 				throw new ArgumentNullException(nameof(m));
-			if (invoke == null)
-				throw new ArgumentNullException(nameof(invoke));
+			if (d == null)
+				throw new ArgumentNullException(nameof(d));
 			int firstParameterInM = isExtensionMethodInvocation ? 1 : 0;
-			if (m.Parameters.Count - firstParameterInM != invoke.Parameters.Count)
+			if (m.Parameters.Count - firstParameterInM != d.Parameters.Count)
 				return false;
-			for (int i = 0; i < invoke.Parameters.Count; i++)
+			for (int i = 0; i < d.Parameters.Count; i++)
 			{
 				var pm = m.Parameters[firstParameterInM + i];
-				var pd = invoke.Parameters[i];
+				var pd = d.Parameters[i];
 				// ret/out/in must match
 				if (pm.ReferenceKind != pd.ReferenceKind)
 					return false;
 				if (pm.ReferenceKind != ReferenceKind.None)
 				{
 					// ref/out/in parameters must have same types
-					if (!pm.Type.Equals(pd.Type))
+					// according to the spec, but Roslyn seems to allow identity conversions
+					if (!IdentityConversion(pd.Type, pm.Type))
 						return false;
 				}
 				else
@@ -1397,15 +1408,18 @@ bool IsDelegateCompatible(IMethod m, IMethod invoke, bool isExtensionMethodInvoc
 						return false;
 				}
 			}
+			if (m.ReturnTypeIsRefReadOnly != d.ReturnTypeIsRefReadOnly)
+				return false;
 			// check return type compatibility
-			return IdentityConversion(m.ReturnType, invoke.ReturnType)
-				|| IsImplicitReferenceConversion(m.ReturnType, invoke.ReturnType);
+			return IdentityConversion(m.ReturnType, d.ReturnType)
+				|| IsImplicitReferenceConversion(m.ReturnType, d.ReturnType);
 		}
 		#endregion
 
 		#region Tuple Conversion
 		Conversion TupleConversion(TupleResolveResult fromRR, IType toType, bool isExplicit)
 		{
+			// C# 9.0 spec: §10.2.13 (implicit tuple conversions) + $10.3.6 (explicit tuple conversions)
 			var fromElements = fromRR.Elements;
 			var toElements = TupleType.GetTupleElementTypes(toType);
 			if (toElements.IsDefault || fromElements.Length != toElements.Length)
@@ -1431,6 +1445,7 @@ Conversion TupleConversion(TupleResolveResult fromRR, IType toType, bool isExpli
 
 		Conversion TupleConversion(IType fromType, IType toType, bool isExplicit)
 		{
+			// C# 9.0 spec: §10.2.13 (implicit tuple conversions) + $10.3.6 (explicit tuple conversions)
 			var fromElements = TupleType.GetTupleElementTypes(fromType);
 			if (fromElements.IsDefaultOrEmpty)
 				return Conversion.None;