2005-03-02 Martin Baulig <martin@ximian.com>

	* generic.cs (TypeManager.IsEqual): Make this symmetric.

	* expression.cs (Binary.ResolveOperator): When resolving a
	BinaryDelegate, use `TypeManager.IsEqual (l, r)' rather than just
	`=='.  Fixes #71866.  See gen-127.cs.

svn path=/trunk/mcs/; revision=41350

diff --git a/mcs/gmcs/ChangeLog b/mcs/gmcs/ChangeLog
index b152e6d503e702831ad0d517b26e73d3ba9bfc7e..784ee424438b5e8583786624a0dd14fa64ff0d94 100644 (file)
--- a/mcs/gmcs/ChangeLog
+++ b/mcs/gmcs/ChangeLog
@@ -1,3 +1,11 @@
+2005-03-02  Martin Baulig  <martin@ximian.com>
+
+       * generic.cs (TypeManager.IsEqual): Make this symmetric.
+
+       * expression.cs (Binary.ResolveOperator): When resolving a
+       BinaryDelegate, use `TypeManager.IsEqual (l, r)' rather than just
+       `=='.  Fixes #71866.  See gen-127.cs.
+
 2005-03-02  Martin Baulig  <martin@ximian.com>
 
        * class.cs (TypeContainer.DoDefineMembers): We also need a default

diff --git a/mcs/gmcs/expression.cs b/mcs/gmcs/expression.cs
index 6a70ddb7057bbb5324473ecde8efd00a768d9287..01559813233357378b9eb7601276810dcab34365 100644 (file)
--- a/mcs/gmcs/expression.cs
+++ b/mcs/gmcs/expression.cs
@@ -2451,34 +2451,39 @@ namespace Mono.CSharp {
                                        if (((right.eclass == ExprClass.MethodGroup) ||
                                             (r == TypeManager.anonymous_method_type))){
                                                if ((RootContext.Version != LanguageVersion.ISO_1)){
-                                               Expression tmp = Convert.ImplicitConversionRequired (ec, right, l, loc);
-                                               if (tmp == null)
-                                                       return null;
-                                               right = tmp;
-                                               r = right.Type;
-                                       }
+                                                       Expression tmp = Convert.ImplicitConversionRequired (ec, right, l, loc);
+                                                       if (tmp == null)
+                                                               return null;
+                                                       right = tmp;
+                                                       r = right.Type;
+                                               }
                                        }
                                
                                        if (TypeManager.IsDelegateType (r)){
-                                       MethodInfo method;
-                                       ArrayList args = new ArrayList (2);
+                                               MethodInfo method;
+                                               ArrayList args = new ArrayList (2);
                                        
-                                       args = new ArrayList (2);
-                                       args.Add (new Argument (left, Argument.AType.Expression));
-                                       args.Add (new Argument (right, Argument.AType.Expression));
+                                               args = new ArrayList (2);
+                                               args.Add (new Argument (left, Argument.AType.Expression));
+                                               args.Add (new Argument (right, Argument.AType.Expression));
                                        
-                                       if (oper == Operator.Addition)
-                                               method = TypeManager.delegate_combine_delegate_delegate;
-                                       else
-                                               method = TypeManager.delegate_remove_delegate_delegate;
+                                               if (oper == Operator.Addition)
+                                                       method = TypeManager.delegate_combine_delegate_delegate;
+                                               else
+                                                       method = TypeManager.delegate_remove_delegate_delegate;
 
-                                       if (l != r) {
-                                               Error_OperatorCannotBeApplied ();
-                                               return null;
-                                       }
+                                               Report.Debug (64, "BINARY DELEGATE", l, r, l.GetType (), r.GetType (),
+                                                             left, right, l == r, l.Equals (r),
+                                                             TypeManager.IsEqual (l, r), TypeManager.IsEqual (r, l),
+                                                             TypeManager.IsEqualGenericInstance (l, r));
 
-                                       return new BinaryDelegate (l, method, args);
-                               }
+                                               if (!TypeManager.IsEqual (l, r)) {
+                                                       Error_OperatorCannotBeApplied ();
+                                                       return null;
+                                               }
+
+                                               return new BinaryDelegate (l, method, args);
+                                       }
                                }
 
                                //

diff --git a/mcs/gmcs/generic.cs b/mcs/gmcs/generic.cs
index f9ea771a31ccb7203204f556a78939197c0ba364..512975246e8944751b251015350e1b6da9ce4326 100644 (file)
--- a/mcs/gmcs/generic.cs
+++ b/mcs/gmcs/generic.cs
@@ -1759,6 +1759,9 @@ namespace Mono.CSharp {
                                return true;
                        }
 
+                       if ((b is TypeBuilder) && b.IsGenericTypeDefinition && a.IsGenericInstance)
+                               return IsEqual (b, a);
+
                        if (a.IsGenericParameter && b.IsGenericParameter) {
                                if ((a.DeclaringMethod == null) || (b.DeclaringMethod == null))
                                        return false;