Reverted a simplification because it caused a regression.

Signed-off-by: Dimitar Dobrev <[email protected]>

Author: ddobrev

src/Generator/Passes/EqualiseAccessOfOverrideAndBasePass.cs

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
 using CppSharp.AST;
 
@@ -21,18 +20,39 @@ public EqualiseAccessOfOverrideAndBasePass()
             VisitOptions.VisitTemplateArguments = false;
         }
 
+        public override bool VisitASTContext(ASTContext context)
+        {
+            var result = base.VisitASTContext(context);
+
+            foreach (var baseOverride in basesOverrides)
+            {
+                var access = baseOverride.Value.Max(o => o.Access);
+                foreach (var @override in baseOverride.Value)
+                    @override.Access = access;
+            }
+
+            return result;
+        }
+
         public override bool VisitMethodDecl(Method method)
         {
-            if (!base.VisitMethodDecl(method) || !method.OverriddenMethods.Any())
+            if (!base.VisitMethodDecl(method) || !method.IsOverride)
+                return false;
+
+            var baseMethod = method.GetRootBaseMethod();
+            if (!baseMethod.IsGenerated)
                 return false;
 
-            var virtuals = new List<Method>(method.OverriddenMethods);
-            virtuals.Add(method);
-            AccessSpecifier access = virtuals.Max(o => o.Access);
-            foreach (var @virtual in virtuals)
-                @virtual.Access = access;
+            HashSet<Method> overrides;
+            if (basesOverrides.ContainsKey(baseMethod))
+                overrides = basesOverrides[baseMethod];
+            else
+                overrides = basesOverrides[baseMethod] = new HashSet<Method> { baseMethod };
+            overrides.Add(method);
 
             return true;
         }
+
+        private Dictionary<Method, HashSet<Method>> basesOverrides = new Dictionary<Method, HashSet<Method>>();
     }
 }

tests/CSharp/CSharp.cpp

@@ -700,6 +700,10 @@ void HasOverridesWithChangedAccessBase::publicOverride()
 {
 }
 
+void HasOverridesWithChangedAccessBase::differentIncreasedAccessOverride()
+{
+}
+
 HasOverridesWithChangedAccess::HasOverridesWithChangedAccess()
 {
 }
@@ -712,6 +716,14 @@ void HasOverridesWithChangedAccess::publicOverride()
 {
 }
 
+HasOverridesWithIncreasedProtectedAccess::HasOverridesWithIncreasedProtectedAccess()
+{
+}
+
+void HasOverridesWithIncreasedProtectedAccess::differentIncreasedAccessOverride()
+{
+}
+
 HasOverridesWithIncreasedAccess::HasOverridesWithIncreasedAccess()
 {
 }
@@ -720,6 +732,10 @@ void HasOverridesWithIncreasedAccess::privateOverride(int i)
 {
 }
 
+void HasOverridesWithIncreasedAccess::differentIncreasedAccessOverride()
+{
+}
+
 IgnoredType PropertyWithIgnoredType::ignoredType()
 {
     return _ignoredType;

tests/CSharp/CSharp.h

@@ -464,6 +464,8 @@ class DLL_API HasOverridesWithChangedAccessBase
     virtual void privateOverride(int i = 5);
 protected:
     virtual void publicOverride();
+private:
+    virtual void differentIncreasedAccessOverride();
 };
 
 class DLL_API HasOverridesWithChangedAccess : public HasOverridesWithChangedAccessBase
@@ -475,11 +477,20 @@ class DLL_API HasOverridesWithChangedAccess : public HasOverridesWithChangedAcce
     virtual void privateOverride(int i);
 };
 
+class DLL_API HasOverridesWithIncreasedProtectedAccess : public HasOverridesWithChangedAccess
+{
+public:
+    HasOverridesWithIncreasedProtectedAccess();
+protected:
+    virtual void differentIncreasedAccessOverride();
+};
+
 class DLL_API HasOverridesWithIncreasedAccess : public HasOverridesWithChangedAccess
 {
 public:
     HasOverridesWithIncreasedAccess();
     virtual void privateOverride(int i);
+    virtual void differentIncreasedAccessOverride();
 };
 
 class DLL_API AbstractWithProperty