Some more refactoring

Author: MDoerner

Rubberduck.Parsing/Symbols/AccessibilityCheck.cs

@@ -19,14 +19,12 @@ public static bool IsAccessible(Declaration callingProject, Declaration callingM
         }
 
         public static bool IsModuleAccessible(Declaration callingProject, Declaration callingModule, Declaration calleeModule)
-        { 
-            bool enclosingModule = callingModule.Equals(calleeModule);
-            if (enclosingModule)
+        {
+            if (IsEnclosingModuleOfModule(callingModule, calleeModule))
             {
                 return true;
             }
-            bool sameProject = callingModule.ParentScopeDeclaration.Equals(calleeModule.ParentScopeDeclaration);
-            if (sameProject)
+            else if (IsInTheSameProject(callingModule, calleeModule))
             {
                 return IsValidAccessibility(calleeModule);
             }
@@ -42,6 +40,17 @@ public static bool IsModuleAccessible(Declaration callingProject, Declaration ca
             }
         }
 
+            private static bool IsEnclosingModuleOfModule(Declaration callingModule, Declaration calleeModule)
+            {
+                return callingModule.Equals(calleeModule);
+            }
+
+            private static bool IsInTheSameProject(Declaration callingModule, Declaration calleeModule)
+            {
+                return callingModule.ParentScopeDeclaration.Equals(calleeModule.ParentScopeDeclaration);
+            }
+
+
         public static bool IsValidAccessibility(Declaration moduleOrMember)
         {
             return moduleOrMember != null
@@ -53,7 +62,7 @@ public static bool IsValidAccessibility(Declaration moduleOrMember)
 
         public static bool IsMemberAccessible(Declaration callingProject, Declaration callingModule, Declaration callingParent, Declaration calleeMember)
         {
-            if (IsEnclosingModule(callingModule, calleeMember) || (CallerIsSubroutineOrProperty(callingParent) && CaleeHasSameParentAsCaller(callingParent, calleeMember)))
+            if (IsEnclosingModuleOfInstanceMember(callingModule, calleeMember) || (CallerIsSubroutineOrProperty(callingParent) && CaleeHasSameParentAsCaller(callingParent, calleeMember)))
             {
                 return true;
             }
@@ -72,15 +81,15 @@ public static bool IsMemberAccessible(Declaration callingProject, Declaration ca
             return false;
         }
 
-            private static bool IsEnclosingModule(Declaration callingModule, Declaration calleeMember)
+            private static bool IsEnclosingModuleOfInstanceMember(Declaration callingModule, Declaration calleeMember)
             {
                 if (callingModule.Equals(calleeMember.ParentScopeDeclaration))
                 {
                     return true;
                 }
                 foreach (var supertype in ClassModuleDeclaration.GetSupertypes(callingModule))
                 {
-                    if (IsEnclosingModule(supertype, calleeMember))
+                    if (IsEnclosingModuleOfInstanceMember(supertype, calleeMember))
                     {
                         return true;
                     }

Rubberduck.Parsing/Symbols/ClassModuleDeclaration.cs

@@ -53,7 +53,10 @@ public static IEnumerable<Declaration> GetSupertypes(Declaration type)
             {
                 return new List<Declaration>();
             }
-            return ((ClassModuleDeclaration)type).Supertypes;
+            else
+            {
+                return ((ClassModuleDeclaration)type).Supertypes;
+            }
         }
 
 
@@ -70,24 +73,38 @@ public bool IsExposed
                 {
                     return _isExposed.Value;
                 }
-                // TODO: Find out if there's info about "being exposed" in type libraries.
-                // We take the conservative approach of treating all type library modules as exposed.
-                if (IsBuiltIn)
+                else if (IsBuiltIn)
                 {
-                    _isExposed = true;
+                    _isExposed = IsExposedForBuiltInModules();
                     return _isExposed.Value;
                 }
-                var attributeIsExposed = false;
-                IEnumerable<string> value;
-                if (Attributes.TryGetValue("VB_Exposed", out value))
+                else
                 {
-                    attributeIsExposed = value.Single() == "True";
+                    _isExposed = HasAttribute("VB_Exposed");
+                    return _isExposed.Value;
                 }
-                _isExposed = attributeIsExposed;
-                return _isExposed.Value;
             }
         }
 
+            // TODO: Find out if there's info about "being exposed" in type libraries.
+            // We take the conservative approach of treating all type library modules as exposed.
+            private static bool IsExposedForBuiltInModules()
+            {
+                return true;
+            }
+
+            private bool HasAttribute(string attributeName)
+            {
+                var hasAttribute = false;
+                IEnumerable<string> value;
+                if (Attributes.TryGetValue(attributeName, out value))
+                {
+                    hasAttribute = value.Single() == "True";
+                }
+                return hasAttribute;
+            }
+              
+
         private bool? _isGlobal;
         public bool IsGlobalClassModule
         {
@@ -97,30 +114,25 @@ public bool IsGlobalClassModule
                 {
                     return _isGlobal.Value;
                 }
+                _isGlobal = HasAttribute("VB_GlobalNamespace") || IsGlobalFromSubtypes();
+                return _isGlobal.Value;
+            }
+        }
 
-                var attributeIsGlobalClassModule = false;
-                IEnumerable<string> value;
-                if (Attributes.TryGetValue("VB_GlobalNamespace", out value))
-                {
-                    attributeIsGlobalClassModule = value.Single() == "True";
-                }
-                _isGlobal = attributeIsGlobalClassModule;
-
-                if (!_isGlobal.Value)
+            private bool IsGlobalFromSubtypes()
+            {
+                var isGlobal = false;
+                foreach (var type in Subtypes)
                 {
-                    foreach (var type in Subtypes)
+                    if (type is ClassModuleDeclaration && ((ClassModuleDeclaration)type).IsGlobalClassModule)
                     {
-                        if (type is ClassModuleDeclaration && ((ClassModuleDeclaration) type).IsGlobalClassModule)
-                        {
-                            _isGlobal = true;
-                            break;
-                        }
+                        isGlobal = true;
+                        break;
                     }
                 }
-
-                return _isGlobal.Value;
+                return isGlobal;
             }
-        }
+
 
         private bool? _hasPredeclaredId;
         /// <summary>
@@ -135,18 +147,12 @@ public bool HasPredeclaredId
                 {
                     return _hasPredeclaredId.Value;
                 }
-
-                var attributeHasDefaultInstanceVariable = false;
-                IEnumerable<string> value;
-                if (Attributes.TryGetValue("VB_PredeclaredId", out value))
-                {
-                    attributeHasDefaultInstanceVariable = value.Single() == "True";
-                }
-                _hasPredeclaredId = attributeHasDefaultInstanceVariable;
+                _hasPredeclaredId = HasAttribute("VB_PredeclaredId");
                 return _hasPredeclaredId.Value;
             }
         }
 
+
         public bool HasDefaultInstanceVariable
         {
             get