2004-08-24 Martin Baulig <martin@ximian.com>

	* typemanager.cs
	(TypeManager.IsSubclassOf): Renamed to IsFamilyAccessible; use
	this for accessibility checks.
	(TypeManager.IsSubclassOrNestedChildOf): Renamed to
	IsNestedFamilyAccessible.
	(TypeManager.IsSubclassOf): New method, do what the name actually
	says.

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

diff --git a/mcs/gmcs/ChangeLog b/mcs/gmcs/ChangeLog
index 84f6d949ad04fd9cf170ceb83b80b3a191fdddcb..1d4ed270cef41669178ed777b7adc7f07c442d6c 100755 (executable)
--- a/mcs/gmcs/ChangeLog
+++ b/mcs/gmcs/ChangeLog
@@ -1,3 +1,13 @@
+2004-08-24  Martin Baulig  <martin@ximian.com>
+
+       * typemanager.cs
+       (TypeManager.IsSubclassOf): Renamed to IsFamilyAccessible; use
+       this for accessibility checks.
+       (TypeManager.IsSubclassOrNestedChildOf): Renamed to
+       IsNestedFamilyAccessible.
+       (TypeManager.IsSubclassOf): New method, do what the name actually
+       says.   
+
 2004-08-24  Martin Baulig  <martin@ximian.com>
 
        * expression.cs (MemberAccess.DoResolve): When resolving ourselves

diff --git a/mcs/gmcs/ecore.cs b/mcs/gmcs/ecore.cs
index 743b255c62697aaa352b5ec0018ebccd130bb2b8..2789397ee95ae408a209ec7442dffb362f755963 100755 (executable)
--- a/mcs/gmcs/ecore.cs
+++ b/mcs/gmcs/ecore.cs
@@ -2247,9 +2247,9 @@ namespace Mono.CSharp {
                                        return e;
 
                                if (!me.IsStatic &&
-                                   TypeManager.IsSubclassOrNestedChildOf (me.InstanceExpression.Type, me.DeclaringType) &&
+                                   TypeManager.IsNestedFamilyAccessible (me.InstanceExpression.Type, me.DeclaringType) &&
                                    me.InstanceExpression.Type != me.DeclaringType &&
-                                   !TypeManager.IsSubclassOf (me.InstanceExpression.Type, me.DeclaringType) &&
+                                   !TypeManager.IsFamilyAccessible (me.InstanceExpression.Type, me.DeclaringType) &&
                                    (!intermediate || !MemberAccess.IdenticalNameAndTypeName (ec, this, e, loc))) {
                                        Error (38, "Cannot access nonstatic member `" + me.Name + "' of " +
                                               "outer type `" + me.DeclaringType + "' via nested type `" +
@@ -3314,7 +3314,7 @@ namespace Mono.CSharp {
                                Type declaring_type = mi.DeclaringType;
                                        
                                if (invocation_type != declaring_type){
-                                       if (TypeManager.IsSubclassOrNestedChildOf (invocation_type, mi.DeclaringType))
+                                       if (TypeManager.IsNestedFamilyAccessible (invocation_type, mi.DeclaringType))
                                                return mi;
                                        else
                                                return null;
@@ -3344,7 +3344,7 @@ namespace Mono.CSharp {
 
                        // Family and FamANDAssem require that we derive.
                        if ((ma == MethodAttributes.Family) || (ma == MethodAttributes.FamANDAssem) || (ma == MethodAttributes.FamORAssem)){
-                               if (!TypeManager.IsSubclassOrNestedChildOf (invocation_type, mi.DeclaringType))
+                               if (!TypeManager.IsNestedFamilyAccessible (invocation_type, mi.DeclaringType))
                                        return null;
                                else {
                                        if (!TypeManager.IsNestedChildOf (invocation_type, mi.DeclaringType))

diff --git a/mcs/gmcs/typemanager.cs b/mcs/gmcs/typemanager.cs
index 108890c25e424ee043a113732b6c6b2714a2c149..5185d12b6c7ac3003c39b6353c08ddff82b87e5f 100755 (executable)
--- a/mcs/gmcs/typemanager.cs
+++ b/mcs/gmcs/typemanager.cs
@@ -1869,6 +1869,18 @@ public class TypeManager {
        }
 
        public static bool IsSubclassOf (Type type, Type parent)
+       {
+               do {
+                       if (type.Equals (parent))
+                               return true;
+
+                       type = type.BaseType;
+               } while (type != null);
+
+               return false;
+       }
+
+       public static bool IsFamilyAccessible (Type type, Type parent)
        {
                do {
                        if (IsEqualGenericInstance (type, parent))
@@ -1883,10 +1895,10 @@ public class TypeManager {
        //
        // Checks whether `type' is a subclass or nested child of `parent'.
        //
-       public static bool IsSubclassOrNestedChildOf (Type type, Type parent)
+       public static bool IsNestedFamilyAccessible (Type type, Type parent)
        {
                do {
-                       if (IsSubclassOf (type, parent))
+                       if (IsFamilyAccessible (type, parent))
                                return true;
 
                        // Handle nested types.
@@ -2778,14 +2790,14 @@ public class TypeManager {
                                if (invocation_type == null)
                                        return false;
 
-                               if (!IsSubclassOrNestedChildOf (invocation_type, mb.DeclaringType))
+                               if (!IsNestedFamilyAccessible (invocation_type, mb.DeclaringType))
                                        return false;
 
                                // Although a derived class can access protected members of its base class
                                // it cannot do so through an instance of the base class (CS1540).
                                if (!mb.IsStatic && (qualifier_type != null) &&
                                    !IsEqualGenericInstance (invocation_type, qualifier_type) &&
-                                   TypeManager.IsSubclassOf (invocation_type, qualifier_type) &&
+                                   TypeManager.IsFamilyAccessible (invocation_type, qualifier_type) &&
                                    !TypeManager.IsNestedChildOf (invocation_type, qualifier_type))
                                        return false;
 
@@ -2829,14 +2841,14 @@ public class TypeManager {
                                if (invocation_type == null)
                                        return false;
 
-                               if (!IsSubclassOrNestedChildOf (invocation_type, fi.DeclaringType))
+                               if (!IsNestedFamilyAccessible (invocation_type, fi.DeclaringType))
                                        return false;
 
                                // Although a derived class can access protected members of its base class
                                // it cannot do so through an instance of the base class (CS1540).
                                if (!fi.IsStatic && (qualifier_type != null) &&
                                    !IsEqualGenericInstance (invocation_type, qualifier_type) &&
-                                   TypeManager.IsSubclassOf (invocation_type, qualifier_type) &&
+                                   TypeManager.IsFamilyAccessible (invocation_type, qualifier_type) &&
                                    !TypeManager.IsNestedChildOf (invocation_type, qualifier_type))
                                        return false;