Fix for bug 612002

Undos previous fix that changed the compiler to always emitted a generated property name of __result for EndInvoke.

The new change only adds the underscores if there is a name conflict. In this way, we stay metadata compatible with the prior native compiler.

Also added same fix to generated parameters for BeginInvoke, callback and object.

Added test cases. (changeset 1393061)

Src/Compilers/CSharp/Portable/Symbols/Source/SourceDelegateMethodSymbol.cs

@@ -281,8 +281,8 @@ private sealed class BeginInvokeMethod : SourceDelegateMethodSymbol
                 }
 
                 int paramCount = invoke.ParameterCount;
-                parameters.Add(new SynthesizedParameterSymbol(this, asyncCallbackType, paramCount, RefKind.None, "callback"));
-                parameters.Add(new SynthesizedParameterSymbol(this, objectType, paramCount + 1, RefKind.None, "object"));
+                parameters.Add(new SynthesizedParameterSymbol(this, asyncCallbackType, paramCount, RefKind.None, GetUniqueParameterName(parameters, "callback")));
+                parameters.Add(new SynthesizedParameterSymbol(this, objectType, paramCount + 1, RefKind.None, GetUniqueParameterName(parameters, "object")));
 
                 InitializeParameters(parameters.ToImmutableAndFree());
             }
@@ -311,6 +311,7 @@ private sealed class EndInvokeMethod : SourceDelegateMethodSymbol
             {
                 var parameters = ArrayBuilder<ParameterSymbol>.GetInstance();
                 int ordinal = 0;
+
                 foreach (SourceParameterSymbol p in invoke.Parameters)
                 {
                     if (p.RefKind != RefKind.None)
@@ -320,7 +321,7 @@ private sealed class EndInvokeMethod : SourceDelegateMethodSymbol
                     }
                 }
 
-                parameters.Add(new SynthesizedParameterSymbol(this, iAsyncResultType, ordinal++, RefKind.None, "__result"));
+                parameters.Add(new SynthesizedParameterSymbol(this, iAsyncResultType, ordinal++, RefKind.None, GetUniqueParameterName(parameters, "result")));
                 InitializeParameters(parameters.ToImmutableAndFree());
             }
 
@@ -339,5 +340,27 @@ public override string Name
             }
         }
 
+        private static string GetUniqueParameterName(ArrayBuilder<ParameterSymbol> currentParameters, string name)
+        {
+            while (!IsUnique(currentParameters, name))
+            {
+                name = "__" + name;
+            }
+
+            return name;
+        }
+
+        private static bool IsUnique(ArrayBuilder<ParameterSymbol> currentParameters, string name)
+        {
+            foreach (var p in currentParameters)
+            {
+                if (string.CompareOrdinal(p.Name, name) == 0)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
     }
 }

Src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_MarshalAs.cs

@@ -1244,7 +1244,7 @@ class C
                     { "EndInvoke:p1", marshalAsBstr },
                     { "EndInvoke:p2", marshalAsBstr },
                     { "EndInvoke:p3", marshalAsBstr },
-                    { "EndInvoke:__result", null },
+                    { "EndInvoke:result", null },
                 },
                 isField: false);
         }

Src/Compilers/CSharp/Test/Emit/Attributes/AttributeTests_WellKnownAttributes.cs

@@ -837,7 +837,7 @@ public void DPV_Optional_Delegates()
                             case "BeginInvoke.b":
                             case "BeginInvoke.callback":
                             case "BeginInvoke.object":
-                            case "EndInvoke.__result":
+                            case "EndInvoke.result":
                                 expectedFlags = 0;
                                 break;
 
@@ -1673,7 +1673,7 @@ public void DecimalConstant_Delegates()
                 Signature("D", "EndInvoke",
                     ".method public hidebysig newslot virtual instance System.Void EndInvoke(" +
                     "[System.Runtime.CompilerServices.DecimalConstantAttribute(1, 2, 3, 4, 5)] [opt] System.Decimal& a = -5534023223830852403.7, " +
-                    "System.IAsyncResult __result) " +
+                    "System.IAsyncResult result) " +
                     "runtime managed"),
 
                 Signature("D", "Invoke",
@@ -1812,7 +1812,7 @@ public void InOutAttributes_Delegates()
                         case "callback":
                         case "object":
                         case "method":
-                        case "__result":
+                        case "result":
                             expectedFlags = 0;
                             break;
 

Src/Compilers/CSharp/Test/Emit/Emit/NoPiaEmbedTypes.cs

@@ -1386,7 +1386,7 @@ public void M6(ITest26 x)
                     Assert.Equal(MethodAttributes.Public | MethodAttributes.Virtual | MethodAttributes.HideBySig | MethodAttributes.NewSlot, end.Flags);
                     Assert.Equal(MethodImplAttributes.Runtime, (MethodImplAttributes)end.ImplementationAttributes);
                     Assert.Equal(CallingConvention.Default | CallingConvention.HasThis, end.CallingConvention);
-                    Assert.Equal("void Test11.EndInvoke(System.IAsyncResult __result)", end.ToTestDisplayString());
+                    Assert.Equal("void Test11.EndInvoke(System.IAsyncResult result)", end.ToTestDisplayString());
 
                     var invoke = (PEMethodSymbol)test11.GetMembers("Invoke").Single();
 

Src/Compilers/CSharp/Test/Semantic/Semantics/LookupPositionTests.cs

@@ -401,25 +401,25 @@ static C()
 
             string[] delegate_d1_members = new string[]{
                 "System.IAsyncResult C<T>.D1.BeginInvoke(System.AsyncCallback callback, System.Object @object)",
-                "void C<T>.D1.EndInvoke(System.IAsyncResult __result)",
+                "void C<T>.D1.EndInvoke(System.IAsyncResult result)",
                 "void C<T>.D1.Invoke()"
             }.Concat(CommonDelegateTypeMembers).ToArray();
 
             string[] delegate_d2_members = new string[]{
                 "System.IAsyncResult C<T>.D2.BeginInvoke(System.Int32 t, System.AsyncCallback callback, System.Object @object)",
-                "void C<T>.D2.EndInvoke(System.IAsyncResult __result)",
+                "void C<T>.D2.EndInvoke(System.IAsyncResult result)",
                 "void C<T>.D2.Invoke(System.Int32 t)"
             }.Concat(CommonDelegateTypeMembers).ToArray();
 
             string[] delegate_d3_members = new string[]{
                 "System.IAsyncResult C<T>.D3<U>.BeginInvoke(System.AsyncCallback callback, System.Object @object)",
-                "void C<T>.D3<U>.EndInvoke(System.IAsyncResult __result)",
+                "void C<T>.D3<U>.EndInvoke(System.IAsyncResult result)",
                 "void C<T>.D3<U>.Invoke()"
             }.Concat(CommonDelegateTypeMembers).ToArray();
 
             string[] delegate_d4_members = new string[]{
                 "System.IAsyncResult C<T>.D4<V>.BeginInvoke(V t, System.AsyncCallback callback, System.Object @object)",
-                "void C<T>.D4<V>.EndInvoke(System.IAsyncResult __result)",
+                "void C<T>.D4<V>.EndInvoke(System.IAsyncResult result)",
                 "void C<T>.D4<V>.Invoke(V t)"
             }.Concat(CommonDelegateTypeMembers).ToArray();
 

Src/Compilers/CSharp/Test/Symbol/Symbols/Source/DelegateTests.cs

@@ -350,7 +350,7 @@ public void DelegateMethodParameterNames()
             Assert.Equal(3, endInvokeParameters.Length);
             Assert.Equal("y", endInvokeParameters[0].Name);
             Assert.Equal("z", endInvokeParameters[1].Name);
-            Assert.Equal("__result", endInvokeParameters[2].Name);
+            Assert.Equal("result", endInvokeParameters[2].Name);
         }
 
         [WorkItem(541179, "DevDiv")]
@@ -371,6 +371,134 @@ void M(int i)
             CreateCompilationWithMscorlib(text).VerifyDiagnostics();
         }
 
+        [WorkItem(612002, "DevDiv")]
+        [Fact]
+        public void DelegateWithOutParameterNamedResult()
+        {
+            var text = @"
+delegate void D(out int result);
+";
+            var comp = CreateCompilationWithMscorlib(text);
+            comp.VerifyDiagnostics();
+
+            NamedTypeSymbol d = (NamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembers("D").Single();
+
+            MethodSymbol invoke = d.DelegateInvokeMethod;
+            ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters;
+            Assert.Equal(1, invokeParameters.Length);
+            Assert.Equal("result", invokeParameters[0].Name);
+
+            MethodSymbol beginInvoke = (MethodSymbol)d.GetMembers("BeginInvoke").Single();
+            ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters;
+            Assert.Equal(3, beginInvokeParameters.Length);
+            Assert.Equal("result", beginInvokeParameters[0].Name);
+            Assert.Equal("callback", beginInvokeParameters[1].Name);
+            Assert.Equal("object", beginInvokeParameters[2].Name);
+
+            MethodSymbol endInvoke = (MethodSymbol)d.GetMembers("EndInvoke").Single();
+            ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters;
+            Assert.Equal(2, endInvokeParameters.Length);
+            Assert.Equal("result", endInvokeParameters[0].Name);
+            Assert.Equal("__result", endInvokeParameters[1].Name);
+        }
+
+        [WorkItem(612002, "DevDiv")]
+        [Fact]
+        public void DelegateWithOutParameterNamedResult2()
+        {
+            var text = @"
+delegate void D(out int @__result);
+";
+            var comp = CreateCompilationWithMscorlib(text);
+            comp.VerifyDiagnostics();
+
+            NamedTypeSymbol d = (NamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembers("D").Single();
+
+            MethodSymbol invoke = d.DelegateInvokeMethod;
+            ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters;
+            Assert.Equal(1, invokeParameters.Length);
+            Assert.Equal("__result", invokeParameters[0].Name);
+
+            MethodSymbol beginInvoke = (MethodSymbol)d.GetMembers("BeginInvoke").Single();
+            ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters;
+            Assert.Equal(3, beginInvokeParameters.Length);
+            Assert.Equal("__result", beginInvokeParameters[0].Name);
+            Assert.Equal("callback", beginInvokeParameters[1].Name);
+            Assert.Equal("object", beginInvokeParameters[2].Name);
+
+            MethodSymbol endInvoke = (MethodSymbol)d.GetMembers("EndInvoke").Single();
+            ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters;
+            Assert.Equal(2, endInvokeParameters.Length);
+            Assert.Equal("__result", endInvokeParameters[0].Name);
+            Assert.Equal("result", endInvokeParameters[1].Name);
+        }
+
+        [WorkItem(612002, "DevDiv")]
+        [Fact]
+        public void DelegateWithOutParameterNamedResult3()
+        {
+            var text = @"
+delegate void D(out int result, out int @__result);
+";
+            var comp = CreateCompilationWithMscorlib(text);
+            comp.VerifyDiagnostics();
+
+            NamedTypeSymbol d = (NamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembers("D").Single();
+
+            MethodSymbol invoke = d.DelegateInvokeMethod;
+            ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters;
+            Assert.Equal(2, invokeParameters.Length);
+            Assert.Equal("result", invokeParameters[0].Name);
+            Assert.Equal("__result", invokeParameters[1].Name);
+
+            MethodSymbol beginInvoke = (MethodSymbol)d.GetMembers("BeginInvoke").Single();
+            ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters;
+            Assert.Equal(4, beginInvokeParameters.Length);
+            Assert.Equal("result", invokeParameters[0].Name);
+            Assert.Equal("__result", invokeParameters[1].Name);
+            Assert.Equal("callback", beginInvokeParameters[2].Name);
+            Assert.Equal("object", beginInvokeParameters[3].Name);
+
+            MethodSymbol endInvoke = (MethodSymbol)d.GetMembers("EndInvoke").Single();
+            ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters;
+            Assert.Equal(3, endInvokeParameters.Length);
+            Assert.Equal("result", endInvokeParameters[0].Name);
+            Assert.Equal("__result", endInvokeParameters[1].Name);
+            Assert.Equal("____result", endInvokeParameters[2].Name);
+        }
+
+        [WorkItem(612002, "DevDiv")]
+        [Fact]
+        public void DelegateWithParametersNamedCallbackAndObject()
+        {
+            var text = @"
+delegate void D(int callback, int @object);
+";
+            var comp = CreateCompilationWithMscorlib(text);
+            comp.VerifyDiagnostics();
+
+            NamedTypeSymbol d = (NamedTypeSymbol)comp.SourceModule.GlobalNamespace.GetMembers("D").Single();
+
+            MethodSymbol invoke = d.DelegateInvokeMethod;
+            ImmutableArray<ParameterSymbol> invokeParameters = invoke.Parameters;
+            Assert.Equal(2, invokeParameters.Length);
+            Assert.Equal("callback", invokeParameters[0].Name);
+            Assert.Equal("object", invokeParameters[1].Name);
+
+            MethodSymbol beginInvoke = (MethodSymbol)d.GetMembers("BeginInvoke").Single();
+            ImmutableArray<ParameterSymbol> beginInvokeParameters = beginInvoke.Parameters;
+            Assert.Equal(4, beginInvokeParameters.Length);
+            Assert.Equal("callback", beginInvokeParameters[0].Name);
+            Assert.Equal("object", beginInvokeParameters[1].Name);
+            Assert.Equal("__callback", beginInvokeParameters[2].Name);
+            Assert.Equal("__object", beginInvokeParameters[3].Name);
+
+            MethodSymbol endInvoke = (MethodSymbol)d.GetMembers("EndInvoke").Single();
+            ImmutableArray<ParameterSymbol> endInvokeParameters = endInvoke.Parameters;
+            Assert.Equal(1, endInvokeParameters.Length);
+            Assert.Equal("result", endInvokeParameters[0].Name);
+        }
+
         [Fact]
         public void DelegateConversion()
         {