2007-05-09 Marek Safar <marek.safar@gmail.com>

	* literal.cs (NullConstant): Print null in all cases.

	* expression.cs (Binary.ResolveOperator): Implemented delegate
	 comparison based on C# 2.0 changes.

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

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 71ddc82f08ffcc464ce971b3856c6937244c1a1f..4de94a04aaa823f4733dd2582b8327daecae3c53 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,10 @@
+2007-05-09  Marek Safar  <marek.safar@gmail.com>
+
+       * literal.cs (NullConstant): Print null in all cases.
+       
+       * expression.cs (Binary.ResolveOperator): Implemented delegate
+        comparison based on C# 2.0 changes.
+
 2007-04-28  Scott Peterson  <lunchtimemama@gmail.com>
 
        This code is contributed under the MIT X11 license

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index 5efa892259ce64587220fc3bbdfcb993b616c714..f8abd46a2a5201396e9ab7f86899f583422c060e 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -1760,8 +1760,59 @@ namespace Mono.CSharp {
                                        Type = TypeManager.bool_type;
                                        return this;
                                }
+
+#if GMCS_SOURCE                                                                                                
+                               //
+                               // Delegate equality
+                               //
+                               MethodGroupExpr mg = null;
+                               Type delegate_type = null;
+                               if (left.eclass == ExprClass.MethodGroup) {
+                                       if (!TypeManager.IsDelegateType(r)) {
+                                               Error_OperatorCannotBeApplied(Location, OperName(oper),
+                                                       left.ExprClassName, right.ExprClassName);
+                                               return null;
+                                       }
+                                       mg = (MethodGroupExpr)left;
+                                       delegate_type = r;
+                               } else if (right.eclass == ExprClass.MethodGroup) {
+                                       if (!TypeManager.IsDelegateType(l)) {
+                                               Error_OperatorCannotBeApplied(Location, OperName(oper),
+                                                       left.ExprClassName, right.ExprClassName);
+                                               return null;
+                                       }
+                                       mg = (MethodGroupExpr)right;
+                                       delegate_type = l;
+                               }
+
+                               if (mg != null) {
+                                       Expression e = ImplicitDelegateCreation.Create (ec, mg, delegate_type, loc);
+                                       if (e == null)
+                                               return null;
+
+                                       // Find operator method
+                                       string op = oper_names[(int)oper];
+                                       MemberInfo[] mi = TypeManager.MemberLookup(ec.ContainerType, null,
+                                               TypeManager.delegate_type, MemberTypes.Method, AllBindingFlags, op, null);
+
+                                       ArrayList args = new ArrayList(2);
+                                       args.Add(new Argument(e, Argument.AType.Expression));
+                                       if (delegate_type == l)
+                                               args.Insert(0, new Argument(left, Argument.AType.Expression));
+                                       else
+                                               args.Add(new Argument(right, Argument.AType.Expression));
+
+                                       return new BinaryMethod (TypeManager.bool_type, (MethodInfo)mi [0], args);
+                               }
+#endif                         
+                               if (l == TypeManager.anonymous_method_type || r == TypeManager.anonymous_method_type) {
+                                       Error_OperatorCannotBeApplied(Location, OperName(oper),
+                                               left.ExprClassName, right.ExprClassName);
+                                       return null;
+                               }                               
                        }
 
+
                        //
                        // Do not perform operator overload resolution when both sides are
                        // built-in types

diff --git a/mcs/mcs/literal.cs b/mcs/mcs/literal.cs
index 2efa53975acdf32314661c6d6ea496c848479301..9f035cd4d6f5c8d8212c6150a8db33ce4fe1f91f 100644 (file)
--- a/mcs/mcs/literal.cs
+++ b/mcs/mcs/literal.cs
@@ -68,6 +68,12 @@ namespace Mono.CSharp {
                {
                        ec.ig.Emit(OpCodes.Ldnull);
                }
+               
+               public override string ExprClassName {
+                       get {
+                               return GetSignatureForError ();
+                       }
+               }
 
                public override string GetSignatureForError ()
                {