2009-08-14 Marek Safar <marek.safar@gmail.com>

	* decl.cs, expression.cs, namespace.cs, ecore.cs, class.cs,
	codegen.cs: Add IResolveContext::LookupExtensionMethod.

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

diff --git a/mcs/mcs/ChangeLog b/mcs/mcs/ChangeLog
index 470e7e7262ed46d2991152b5036a788b482373d7..a1ae4aa115109516aa63cae1a7b6111a745c69e6 100644 (file)
--- a/mcs/mcs/ChangeLog
+++ b/mcs/mcs/ChangeLog
@@ -1,3 +1,12 @@
+2009-08-14  Marek Safar  <marek.safar@gmail.com>
+
+       * decl.cs, expression.cs, namespace.cs, ecore.cs, class.cs,
+       codegen.cs: Add IResolveContext::LookupExtensionMethod.
+
+2009-08-14  Marek Safar  <marek.safar@gmail.com>
+
+       * *.cs: Removed TypeContainer and ContainerType from EmitContext.
+
 2009-08-13  Marek Safar  <marek.safar@gmail.com>
 
        * decl.cs: Look in PartialContainer for parent type parameters.

diff --git a/mcs/mcs/class.cs b/mcs/mcs/class.cs
index 956146da018522cc8ffa90f728e92640155314ff..fc31abd8d6c12eaeb0fee29b965c0ff3cf93a4ad 100644 (file)
--- a/mcs/mcs/class.cs
+++ b/mcs/mcs/class.cs
@@ -182,6 +182,11 @@ namespace Mono.CSharp {
                                get { return tc.IsInUnsafeScope; }
                        }
 
+                       public ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
+                       {
+                               return null;
+                       }
+
                        public FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)
                        {
                                return tc.Parent.LookupNamespaceOrType (name, loc, ignore_cs0104);
@@ -2658,7 +2663,17 @@ namespace Mono.CSharp {
 
                public override ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
                {
-                       return NamespaceEntry.LookupExtensionMethod (extensionType, this, name, loc);
+                       DeclSpace top_level = Parent;
+                       if (top_level != null) {
+                               while (top_level.Parent != null)
+                                       top_level = top_level.Parent;
+
+                               ArrayList candidates = NamespaceEntry.NS.LookupExtensionMethod (extensionType, this, name);
+                               if (candidates != null)
+                                       return new ExtensionMethodGroupExpr (candidates, NamespaceEntry, extensionType, loc);
+                       }
+
+                       return NamespaceEntry.LookupExtensionMethod (extensionType, name, loc);
                }
 
                protected override TypeAttributes TypeAttr {

diff --git a/mcs/mcs/codegen.cs b/mcs/mcs/codegen.cs
index a189283d21767a1fb4613133438fd58eeb8aea7a..badc7bc91293dafe63be287e1592563bcea7467f 100644 (file)
--- a/mcs/mcs/codegen.cs
+++ b/mcs/mcs/codegen.cs
@@ -257,6 +257,7 @@ namespace Mono.CSharp {
                bool IsInObsoleteScope { get; }
                bool IsInUnsafeScope { get; }
 
+               ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc);
                FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104);
                Type LookupTypeParameter (string name);
 
@@ -1053,6 +1054,11 @@ namespace Mono.CSharp {
 
                #region IResolveContext Members
 
+               public ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
+               {
+                       return ResolveContext.LookupExtensionMethod (extensionType, name, loc);
+               }
+
                public FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)
                {
                        return ResolveContext.LookupNamespaceOrType (name, loc, ignore_cs0104);
@@ -1116,6 +1122,11 @@ namespace Mono.CSharp {
                        get { return false; }
                }
 
+               public ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
+               {
+                       throw new NotImplementedException ();
+               }
+
                public FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)
                {
                        return RootContext.ToplevelTypes.LookupNamespaceOrType (name, loc, ignore_cs0104);

diff --git a/mcs/mcs/decl.cs b/mcs/mcs/decl.cs
index 1c4d0b0f959970aa24cdae8920b226bc8e309e10..f4a30530d2b274d16b02720b01b2ad90e81e157c 100644 (file)
--- a/mcs/mcs/decl.cs
+++ b/mcs/mcs/decl.cs
@@ -670,6 +670,11 @@ namespace Mono.CSharp {
                        return true;
                }
 
+               public virtual ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
+               {
+                       return Parent.LookupExtensionMethod (extensionType, name, loc);
+               }
+
                public virtual FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)
                {
                        return Parent.LookupNamespaceOrType (name, loc, ignore_cs0104);
@@ -1198,11 +1203,6 @@ namespace Mono.CSharp {
                        return null;
                }
 
-               public virtual ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
-               {
-                       return null;
-               }
-
                //
                // Public function used to locate types.
                //

diff --git a/mcs/mcs/ecore.cs b/mcs/mcs/ecore.cs
index c8eec124407851959995418ea0c7a29874e73b98..0c7972a3206bc6c6b09b8f53169611e562739e8d 100644 (file)
--- a/mcs/mcs/ecore.cs
+++ b/mcs/mcs/ecore.cs
@@ -3206,7 +3206,7 @@ namespace Mono.CSharp {
                                return null;
 
                        // Search continues
-                       ExtensionMethodGroupExpr e = ns.LookupExtensionMethod (type, null, Name, loc);
+                       ExtensionMethodGroupExpr e = ns.LookupExtensionMethod (type, Name, loc);
                        if (e == null)
                                return base.OverloadResolve (ec, ref arguments, false, loc);
 
@@ -4201,7 +4201,7 @@ namespace Mono.CSharp {
                                // not an extension method. We start extension methods lookup from here
                                //
                                if (InstanceExpression != null) {
-                                       ExtensionMethodGroupExpr ex_method_lookup = ec.TypeContainer.LookupExtensionMethod (type, Name, loc);
+                                       ExtensionMethodGroupExpr ex_method_lookup = ec.LookupExtensionMethod (type, Name, loc);
                                        if (ex_method_lookup != null) {
                                                ex_method_lookup.ExtensionExpression = InstanceExpression;
                                                ex_method_lookup.SetTypeArguments (type_arguments);

diff --git a/mcs/mcs/expression.cs b/mcs/mcs/expression.cs
index d8d3937263d7ec80cdca5ab3aee645c50f44b5f7..b6d02eace713fe7eba7d2f5045d084684bb92a38 100644 (file)
--- a/mcs/mcs/expression.cs
+++ b/mcs/mcs/expression.cs
@@ -4817,7 +4817,7 @@ namespace Mono.CSharp {
                                        return null;
                                }
                                
-                               mg = ec.TypeContainer.LookupExtensionMethod (me.Type, me.Name, loc);
+                               mg = ec.LookupExtensionMethod (me.Type, me.Name, loc);
                                if (mg == null) {
                                        Report.Error (1955, loc, "The member `{0}' cannot be used as method or delegate",
                                                expr_resolved.GetSignatureForError ());
@@ -7383,7 +7383,7 @@ namespace Mono.CSharp {
                                if (expr_eclass == ExprClass.Value || expr_eclass == ExprClass.Variable ||
                                        expr_eclass == ExprClass.IndexerAccess || expr_eclass == ExprClass.PropertyAccess ||
                                        expr_eclass == ExprClass.EventAccess) {
-                                       ExtensionMethodGroupExpr ex_method_lookup = ec.TypeContainer.LookupExtensionMethod (expr_type, Name, loc);
+                                       ExtensionMethodGroupExpr ex_method_lookup = ec.LookupExtensionMethod (expr_type, Name, loc);
                                        if (ex_method_lookup != null) {
                                                ex_method_lookup.ExtensionExpression = expr_resolved;
 

diff --git a/mcs/mcs/namespace.cs b/mcs/mcs/namespace.cs
index 72e0dcc6438575187a0eaad4799e2d928d120201..f08e26e3d4f4f560863aaa328ff8c8ce865d5968 100644 (file)
--- a/mcs/mcs/namespace.cs
+++ b/mcs/mcs/namespace.cs
@@ -1035,15 +1035,9 @@ namespace Mono.CSharp {
                /// Does extension methods look up to find a method which matches name and extensionType.
                /// Search starts from this namespace and continues hierarchically up to top level.
                ///
-               public ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, ClassOrStruct currentClass, string name, Location loc)
+               public ExtensionMethodGroupExpr LookupExtensionMethod (Type extensionType, string name, Location loc)
                {
                        ArrayList candidates = null;
-                       if (currentClass != null) {
-                               candidates = ns.LookupExtensionMethod (extensionType, currentClass, name);
-                               if (candidates != null)
-                                       return new ExtensionMethodGroupExpr (candidates, this, extensionType, loc);
-                       }
-
                        foreach (Namespace n in GetUsingTable ()) {
                                ArrayList a = n.LookupExtensionMethod (extensionType, null, name);
                                if (a == null)
@@ -1076,7 +1070,7 @@ namespace Mono.CSharp {
                        //
                        // Continue in parent scope
                        //
-                       return parent.LookupExtensionMethod (extensionType, currentClass, name, loc);
+                       return parent.LookupExtensionMethod (extensionType, name, loc);
                }
 
                public FullNamedExpression LookupNamespaceOrType (string name, Location loc, bool ignore_cs0104)