Use implicit conversion instead of constructor

dotnet · May 23, 2024 · 937ef86 · 937ef86
1 parent d77d923
commit 937ef86
Show file tree

Hide file tree

Showing 18 changed files with 1,130 additions and 1,146 deletions.
diff --git a/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs b/src/Compilers/CSharp/Portable/Binder/Binder_Conversions.cs
@@ -489,12 +489,12 @@ void checkConstraintLanguageVersionAndRuntimeSupportForConversion(SyntaxNode syn
                     // PROTOTYPE: Check runtime APIs used for other span conversions once they are implemented.
                     if (destination.OriginalDefinition.Equals(Compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions))
                     {
-                        _ = GetWellKnownTypeMember(WellKnownMember.System_ReadOnlySpan_T__ctor_Array, diagnostics, syntax: syntax);
+                        _ = GetWellKnownTypeMember(WellKnownMember.System_ReadOnlySpan_T__op_Implicit_Array, diagnostics, syntax: syntax);
                     }
                     else
                     {
                         Debug.Assert(destination.OriginalDefinition.Equals(Compilation.GetWellKnownType(WellKnownType.System_Span_T), TypeCompareKind.AllIgnoreOptions));
-                        _ = GetWellKnownTypeMember(WellKnownMember.System_Span_T__ctor_Array, diagnostics, syntax: syntax);
+                        _ = GetWellKnownTypeMember(WellKnownMember.System_Span_T__op_Implicit_Array, diagnostics, syntax: syntax);
                     }
                 }
             }

diff --git a/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs b/src/Compilers/CSharp/Portable/Lowering/LocalRewriter/LocalRewriter_Conversion.cs
@@ -618,24 +618,33 @@ private BoundExpression MakeConversionNodeCore(
                     {
                         var spanType = (NamedTypeSymbol)rewrittenType;
 
-                        WellKnownMember ctorMember;
+                        WellKnownMember member;
                         if (spanType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_ReadOnlySpan_T), TypeCompareKind.AllIgnoreOptions))
                         {
-                            ctorMember = WellKnownMember.System_ReadOnlySpan_T__ctor_Array;
+                            member = WellKnownMember.System_ReadOnlySpan_T__op_Implicit_Array;
                         }
                         else
                         {
                             Debug.Assert(spanType.OriginalDefinition.Equals(_compilation.GetWellKnownType(WellKnownType.System_Span_T), TypeCompareKind.AllIgnoreOptions));
-                            ctorMember = WellKnownMember.System_Span_T__ctor_Array;
+                            member = WellKnownMember.System_Span_T__op_Implicit_Array;
                         }
 
-                        if (!TryGetWellKnownTypeMember(rewrittenOperand.Syntax, ctorMember, out MethodSymbol? ctor))
+                        if (!TryGetWellKnownTypeMember(rewrittenOperand.Syntax, member, out MethodSymbol? symbol))
                         {
                             throw ExceptionUtilities.Unreachable();
                         }
                         else
                         {
-                            return new BoundObjectCreationExpression(rewrittenOperand.Syntax, ctor.AsMember((NamedTypeSymbol)rewrittenType), rewrittenOperand);
+                            MethodSymbol method = symbol.AsMember((NamedTypeSymbol)rewrittenType);
+
+                            rewrittenOperand = _factory.Convert(method.ParameterTypesWithAnnotations[0].Type, rewrittenOperand);
+
+                            if (member == WellKnownMember.System_ReadOnlySpan_T__op_Implicit_Array)
+                            {
+                                return new BoundReadOnlySpanFromArray(syntax, rewrittenOperand, method, rewrittenType) { WasCompilerGenerated = true };
+                            }
+
+                            return _factory.Call(null, method, rewrittenOperand);
                         }
                     }
 

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncSpillTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenAsyncSpillTests.cs
@@ -3575,12 +3575,7 @@ public sealed class JsonSerializerOptions
     }
 }
 ";
-            CreateCompilation(source, options: TestOptions.DebugExe).VerifyDiagnostics(
-                // (12,69): error CS0656: Missing compiler required member 'System.ReadOnlySpan`1..ctor'
-                //         System.Text.Json.Serialization.JsonSerializer.Parse<string>(await TestAsync());
-                Diagnostic(ErrorCode.ERR_MissingPredefinedMember, "await TestAsync()").WithArguments("System.ReadOnlySpan`1", ".ctor").WithLocation(12, 69));
-
-            var v = CompileAndVerify(source, parseOptions: TestOptions.Regular12, options: TestOptions.DebugExe);
+            var v = CompileAndVerify(source, options: TestOptions.DebugExe);
 
             v.VerifyMethodBody("Program.<Serialize>d__1.System.Runtime.CompilerServices.IAsyncStateMachine.MoveNext()", @"
 {

diff --git a/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs b/src/Compilers/CSharp/Test/Emit/CodeGen/CodeGenFunctionPointersTests.cs
@@ -7167,7 +7167,7 @@ .locals init (delegate*<System.Span<char>, System.Span<char>> V_0)
   IL_0000:  ldftn      ""System.Span<char> C.ChopSpan(System.Span<char>)""
   IL_0006:  stloc.0
   IL_0007:  ldsfld     ""char[] C.chars""
-  IL_000c:  newobj     ""System.Span<char>..ctor(char[])""
+  IL_000c:  call       ""System.Span<char> System.Span<char>.op_Implicit(char[])""
   IL_0011:  ldloc.0
   IL_0012:  calli      ""delegate*<System.Span<char>, System.Span<char>>""
   IL_0017:  call       ""System.ReadOnlySpan<char> System.Span<char>.op_Implicit(System.Span<char>)""