WIP

Author: siegfriedpammer

ICSharpCode.Decompiler.Tests/PrettyTestRunner.cs

@@ -538,7 +538,7 @@ public async Task Records([ValueSource(nameof(roslyn3OrNewerOptions))] CompilerO
 		[Test]
 		public async Task ExtensionProperties([ValueSource(nameof(roslyn4OrNewerOptions))] CompilerOptions cscOptions)
 		{
-			await RunForLibrary(cscOptions: cscOptions | CompilerOptions.Preview);
+			await RunForLibrary(cscOptions: cscOptions | CompilerOptions.Preview | CompilerOptions.NullableEnable);
 		}
 
 		[Test]

ICSharpCode.Decompiler/CSharp/CallBuilder.cs

@@ -1438,7 +1438,7 @@ private ExpressionWithResolveResult HandleImplicitConversion(IMethod method, Tra
 			var conversions = CSharpConversions.Get(expressionBuilder.compilation);
 			IType targetType = method.ReturnType;
 			var conv = conversions.ImplicitConversion(argument.Type, targetType);
-			if (!(conv.IsUserDefined && conv.IsValid && conv.Method.Equals(method)))
+			if (!(conv.IsUserDefined && conv.IsValid && conv.Method.Equals(method, NormalizeTypeVisitor.IgnoreNullabilityAndTuples)))
 			{
 				// implicit conversion to targetType isn't directly possible, so first insert a cast to the argument type
 				argument = argument.ConvertTo(method.Parameters[0].Type, expressionBuilder);

ICSharpCode.Decompiler/CSharp/Resolver/CSharpConversions.cs

@@ -1229,6 +1229,41 @@ List<OperatorInfo> GetApplicableConversionOperators(ResolveResult fromResult, IT
 		}
 		#endregion
 
+		#region Implicit Span Conversion
+
+		public bool IsImplicitSpanConversion(IType fromType, IType toType)
+		{
+			// An implicit span conversion permits array_types, System.Span<T>, System.ReadOnlySpan<T>,
+			// and string to be converted between each other 
+			// see https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-14.0/first-class-span-types#span-conversions
+
+			switch (fromType)
+			{
+				case ArrayType { Dimensions: 1, ElementType: var elementType }:
+					if (toType.IsKnownType(KnownTypeCode.SpanOfT) ||
+						toType.IsKnownType(KnownTypeCode.ReadOnlySpanOfT))
+					{
+						return ImplicitReferenceConversion(elementType, toType.TypeArguments[0], 0)
+							|| IdentityConversion(elementType, toType.TypeArguments[0]);
+					}
+					break;
+				case ParameterizedType pt when pt.IsKnownType(KnownTypeCode.SpanOfT) || pt.IsKnownType(KnownTypeCode.ReadOnlySpanOfT):
+					if (toType.IsKnownType(KnownTypeCode.ReadOnlySpanOfT))
+					{
+						return ImplicitReferenceConversion(pt.TypeArguments[0], toType.TypeArguments[0], 0)
+							|| IdentityConversion(pt.TypeArguments[0], toType.TypeArguments[0]);
+					}
+					break;
+				case var s when s.IsKnownType(KnownTypeCode.String):
+					return toType.IsKnownType(KnownTypeCode.ReadOnlySpanOfT)
+						&& toType.TypeArguments[0].IsKnownType(KnownTypeCode.Char);
+			}
+
+			return false;
+		}
+
+		#endregion
+
 		#region AnonymousFunctionConversion
 		Conversion AnonymousFunctionConversion(ResolveResult resolveResult, IType toType)
 		{
@@ -1487,11 +1522,30 @@ Conversion TupleConversion(IType fromType, IType toType, bool isExplicit)
 
 		#region BetterConversion
 		/// <summary>
-		/// Gets the better conversion (C# 4.0 spec, §7.5.3.3)
+		/// Gets the better conversion (from expression) (C# 8.0 spec, §12.6.4.5)
 		/// </summary>
 		/// <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
 		public int BetterConversion(ResolveResult resolveResult, IType t1, IType t2)
 		{
+			bool t1Exact = IsExactlyMatching(resolveResult, t1);
+			bool t2Exact = IsExactlyMatching(resolveResult, t2);
+			if (t1Exact && !t2Exact)
+				return 1;
+			if (t2Exact && !t1Exact)
+				return 2;
+			if (!t1Exact && !t2Exact)
+			{
+				bool c1ImplicitSpanConversion = IsImplicitSpanConversion(resolveResult.Type, t1);
+				bool c2ImplicitSpanConversion = IsImplicitSpanConversion(resolveResult.Type, t2);
+				if (c1ImplicitSpanConversion && !c2ImplicitSpanConversion)
+					return 1;
+				if (c2ImplicitSpanConversion && !c1ImplicitSpanConversion)
+					return 2;
+			}
+			if (t1Exact == t2Exact)
+			{
+				return BetterConversionTarget(t1, t2);
+			}
 			LambdaResolveResult lambda = resolveResult as LambdaResolveResult;
 			if (lambda != null)
 			{
@@ -1542,20 +1596,56 @@ public int BetterConversion(ResolveResult resolveResult, IType t1, IType t2)
 		}
 
 		/// <summary>
-		/// Unpacks the generic Task[T]. Returns null if the input is not Task[T].
+		/// Gets whether an expression E exactly matches a type T (C# 8.0 spec, §12.6.4.6)
 		/// </summary>
-		static IType UnpackTask(IType type)
+		bool IsExactlyMatching(ResolveResult e, IType t)
 		{
-			ParameterizedType pt = type as ParameterizedType;
-			if (pt != null && pt.TypeParameterCount == 1 && pt.Name == "Task" && pt.Namespace == "System.Threading.Tasks")
+			var s = e.Type;
+			if (IdentityConversion(s, t))
+				return true;
+			if (e is LambdaResolveResult lambda)
 			{
-				return pt.GetTypeArgument(0);
+				if (!lambda.IsAnonymousMethod)
+				{
+					t = UnpackExpressionTreeType(t);
+				}
+				IMethod m = t.GetDelegateInvokeMethod();
+				if (m == null)
+					return false;
+				IType[] parameterTypes = new IType[m.Parameters.Count];
+				for (int i = 0; i < parameterTypes.Length; i++)
+					parameterTypes[i] = m.Parameters[i].Type;
+				var x = lambda.GetInferredReturnType(parameterTypes);
+				var y = m.ReturnType;
+				if (IdentityConversion(x, y))
+					return true;
+				if (lambda.IsAsync)
+				{
+					x = UnpackTask(x);
+					y = UnpackTask(y);
+				}
+				if (x != null && y != null)
+					return IsExactlyMatching(new ResolveResult(x), y);
+				return false;
+			}
+			else
+			{
+				return false;
 			}
-			return null;
 		}
 
 		/// <summary>
-		/// Gets the better conversion (C# 4.0 spec, §7.5.3.4)
+		/// Unpacks the generic TaskType[T]. Returns null if the input is not TaskType[T].
+		/// </summary>
+		static IType UnpackTask(IType type)
+		{
+			return (TaskType.IsTask(type) || TaskType.IsCustomTask(type, out _)) && type.TypeParameterCount == 1
+				? type.TypeArguments[0]
+				: null;
+		}
+
+		/// <summary>
+		/// Gets the better conversion (from type) (C# 4.0 spec, §7.5.3.4)
 		/// </summary>
 		/// <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
 		public int BetterConversion(IType s, IType t1, IType t2)
@@ -1570,17 +1660,57 @@ public int BetterConversion(IType s, IType t1, IType t2)
 		}
 
 		/// <summary>
-		/// Gets the better conversion target (C# 4.0 spec, §7.5.3.5)
+		/// Gets the better conversion target (C# 9.0 spec, §12.6.4.7)
 		/// </summary>
 		/// <returns>0 = neither is better; 1 = t1 is better; 2 = t2 is better</returns>
 		int BetterConversionTarget(IType t1, IType t2)
 		{
-			bool t1To2 = ImplicitConversion(t1, t2).IsValid;
-			bool t2To1 = ImplicitConversion(t2, t1).IsValid;
-			if (t1To2 && !t2To1)
-				return 1;
-			if (t2To1 && !t1To2)
-				return 2;
+			if (t1.IsKnownType(KnownTypeCode.ReadOnlySpanOfT))
+			{
+				if (t2.IsKnownType(KnownTypeCode.SpanOfT))
+				{
+					if (IdentityConversion(t1.TypeArguments[0], t2.TypeArguments[0]))
+						return 1;
+				}
+				if (t2.IsKnownType(KnownTypeCode.ReadOnlySpanOfT))
+				{
+					bool t1To2 = ImplicitConversion(t1.TypeArguments[0], t2.TypeArguments[0]).IsValid;
+					bool t2To1 = ImplicitConversion(t2.TypeArguments[0], t1.TypeArguments[0]).IsValid;
+					if (t1To2 && !t2To1)
+						return 1;
+				}
+			}
+
+			if (t2.IsKnownType(KnownTypeCode.ReadOnlySpanOfT))
+			{
+				if (t1.IsKnownType(KnownTypeCode.SpanOfT))
+				{
+					if (IdentityConversion(t2.TypeArguments[0], t1.TypeArguments[0]))
+						return 2;
+				}
+				if (t1.IsKnownType(KnownTypeCode.ReadOnlySpanOfT))
+				{
+					bool t1To2 = ImplicitConversion(t1.TypeArguments[0], t2.TypeArguments[0]).IsValid;
+					bool t2To1 = ImplicitConversion(t2.TypeArguments[0], t1.TypeArguments[0]).IsValid;
+					if (t2To1 && !t1To2)
+						return 2;
+				}
+			}
+
+			{
+				bool t1To2 = ImplicitConversion(t1, t2).IsValid;
+				bool t2To1 = ImplicitConversion(t2, t1).IsValid;
+				if (t1To2 && !t2To1)
+					return 1;
+				if (t2To1 && !t1To2)
+					return 2;
+			}
+
+			var s1 = UnpackTask(t1);
+			var s2 = UnpackTask(t2);
+			if (s1 != null && s2 != null)
+				return BetterConversionTarget(s1, s2);
+
 			TypeCode t1Code = ReflectionHelper.GetTypeCode(t1);
 			TypeCode t2Code = ReflectionHelper.GetTypeCode(t2);
 			if (IsBetterIntegralType(t1Code, t2Code))

ICSharpCode.Decompiler/CSharp/Resolver/CSharpResolver.cs

@@ -2171,7 +2171,8 @@ static bool IsEligibleExtensionMethod(ICompilation compilation, CSharpConversion
 				thisParameterType = thisParameterType.AcceptVisitor(substitution);
 			}
 			Conversion c = conversions.ImplicitConversion(targetType, thisParameterType);
-			return c.IsValid && (c.IsIdentityConversion || c.IsReferenceConversion || c.IsBoxingConversion);
+			return (c.IsValid && (c.IsIdentityConversion || c.IsReferenceConversion || c.IsBoxingConversion))
+				|| conversions.IsImplicitSpanConversion(targetType, thisParameterType);
 		}
 
 		/// <summary>

ICSharpCode.Decompiler/CSharp/Resolver/Log.cs

@@ -29,7 +29,7 @@ namespace ICSharpCode.Decompiler.CSharp.Resolver
 	/// </summary>
 	static class Log
 	{
-		const bool logEnabled = false;
+		const bool logEnabled = true;
 #if __MonoCS__
 		[Conditional("MCS_DEBUG")]
 #else

ICSharpCode.Decompiler/CSharp/Resolver/MemberLookup.cs

@@ -103,6 +103,32 @@ public bool IsAccessible(IEntity entity, bool allowProtectedAccess)
 		{
 			if (entity == null)
 				throw new ArgumentNullException(nameof(entity));
+
+			var entityModule = entity.ParentModule.MetadataFile;
+			var sourceModule = currentModule.MetadataFile;
+
+			if (entityModule != sourceModule)
+			{
+
+				bool found = false;
+
+				foreach (var item in sourceModule.AssemblyReferences)
+				{
+					if (item.Name == entityModule.Name)
+					{
+						found = true;
+						break;
+					}
+				}
+
+				if (!found)
+				{
+					// The entity is defined in an assembly that is not referenced by the current assembly.
+					// Therefore, it is not accessible.
+					return false;
+				}
+			}
+
 			// C# 4.0 spec, §3.5.2 Accessiblity domains
 			switch (entity.Accessibility)
 			{

ICSharpCode.Decompiler/CSharp/Resolver/OverloadResolution.cs

@@ -377,11 +377,12 @@ public void AddMethodLists(IReadOnlyList<MethodListWithDeclaringType> methodList
 		internal void LogCandidateAddingResult(string text, IParameterizedMember method, OverloadResolutionErrors errors)
 		{
 #if DEBUG
-			Log.WriteLine(string.Format("{0} {1} = {2}{3}",
+			Log.WriteLine(string.Format("{0} {1} from {4} = {2}{3}",
 										text, method,
 										errors == OverloadResolutionErrors.None ? "Success" : errors.ToString(),
 										this.BestCandidate == method ? " (best candidate so far)" :
-										this.BestCandidateAmbiguousWith == method ? " (ambiguous)" : ""
+										this.BestCandidateAmbiguousWith == method ? " (ambiguous)" : "",
+										method.ParentModule.AssemblyName
 									   ));
 #endif
 		}
@@ -711,7 +712,7 @@ void CheckApplicability(Candidate candidate)
 				if (IsExtensionMethodInvocation && parameterIndex == 0)
 				{
 					// First parameter to extension method must be an identity, reference or boxing conversion
-					if (!(c == Conversion.IdentityConversion || c == Conversion.ImplicitReferenceConversion || c == Conversion.BoxingConversion))
+					if (!(c == Conversion.IdentityConversion || c == Conversion.ImplicitReferenceConversion || c == Conversion.BoxingConversion || (c.IsUserDefined && conversions.IsImplicitSpanConversion(arguments[i].Type, parameterType))))
 						candidate.AddError(OverloadResolutionErrors.ArgumentTypeMismatch);
 				}
 				else

ICSharpCode.Decompiler/CSharp/TranslatedExpression.cs

@@ -650,6 +650,10 @@ bool CastCanBeMadeImplicit(Resolver.CSharpConversions conversions, Conversion co
 				return newTargetType.IsKnownType(KnownTypeCode.FormattableString)
 					|| newTargetType.IsKnownType(KnownTypeCode.IFormattable);
 			}
+			if (conversion.IsUserDefined)
+			{
+				return conversions.IsImplicitSpanConversion(inputType, newTargetType);
+			}
 			return conversions.IdentityConversion(oldTargetType, newTargetType);
 		}