Fixed the walking of pointer types to use the correct qualifiers.

Signed-off-by: Dimitar Dobrev <dpldobrev@protonmail.com>

src/AST/CppTypePrinter.cs

@@ -92,7 +92,8 @@ namespace CppSharp.AST
                 return string.Format("{0} (*)({1})", returnType.Visit(this), args);
             }
 
-            var qual = PrintTypeQualifiers && quals.IsConst ? "const " : string.Empty;
+            var qual = PrintTypeQualifiers &&
+                pointer.GetFinalQualifiedPointee().Qualifiers.IsConst ? "const " : string.Empty;
             var pointeeType = pointee.Visit(this, quals);
             var mod = PrintTypeModifiers ? ConvertModifierToString(pointer.Modifier) : string.Empty;
             return string.Format("{0}{1}{2}", qual, pointeeType, mod);

src/AST/FunctionExtensions.cs

@@ -77,7 +77,7 @@ namespace CppSharp.AST
         public static bool CanOverride(this Method @override, Method method)
         {
             return (method.OriginalName == @override.OriginalName &&
-                method.ReturnType.ResolvesTo(@override.ReturnType) &&
+                method.OriginalReturnType.ResolvesTo(@override.OriginalReturnType) &&
                 method.Parameters.SequenceEqual(@override.Parameters, ParameterTypeComparer.Instance)) ||
                 (@override.IsDestructor && method.IsDestructor && method.IsVirtual);
         }

src/AST/Type.cs

@@ -324,7 +324,7 @@ namespace CppSharp.AST
 
         public override T Visit<T>(ITypeVisitor<T> visitor, TypeQualifiers quals = new TypeQualifiers())
         {
-            return visitor.VisitPointerType(this, QualifiedPointee.Qualifiers);
+            return visitor.VisitPointerType(this, quals);
         }
 
         public override object Clone()

src/AST/TypeExtensions.cs

@@ -258,6 +258,39 @@
             return finalPointee;
         }
 
+        /// <summary>
+        /// If t is a pointer type the type pointed to by t will be returned.
+        /// Otherwise the default qualified type.
+        /// </summary>
+        public static QualifiedType GetQualifiedPointee(this Type t)
+        {
+            var ptr = t as PointerType;
+            if (ptr != null)
+                return ptr.QualifiedPointee;
+            var memberPtr = t as MemberPointerType;
+            if (memberPtr != null)
+                return memberPtr.QualifiedPointee;
+            return new QualifiedType();
+        }
+
+        /// <summary>
+        /// If t is a pointer type the type pointed to by t will be returned
+        /// after fully dereferencing it. Otherwise the default qualified type.
+        /// For example int** -> int.
+        /// </summary>
+        public static QualifiedType GetFinalQualifiedPointee(this Type t)
+        {
+            var finalPointee = t.GetQualifiedPointee();
+            var pointee = finalPointee;
+            while (pointee.Type != null)
+            {
+                pointee = pointee.Type.GetQualifiedPointee();
+                if (pointee.Type != null)
+                    finalPointee = pointee;
+            }
+            return finalPointee;
+        }
+
         public static PointerType GetFinalPointer(this Type t)
         {
             var type = t as PointerType;

src/Generator/Generators/CLI/CLIMarshal.cs

@@ -122,7 +122,8 @@ namespace CppSharp.Generators.CLI
             if (pointee.IsPrimitiveType(out primitive))
             {
                 var returnVarName = Context.ReturnVarName;
-                if (quals.IsConst != Context.ReturnType.Qualifiers.IsConst)
+                if (pointer.GetFinalQualifiedPointee().Qualifiers.IsConst !=
+                    Context.ReturnType.Qualifiers.IsConst)
                 {
                     var nativeTypePrinter = new CppTypePrinter { PrintTypeQualifiers = false };
                     var returnType = Context.ReturnType.Type.Desugar();
@@ -559,7 +560,8 @@ namespace CppSharp.Generators.CLI
             if (finalPointee.IsPrimitiveType())
             {
                 var cppTypePrinter = new CppTypePrinter();
-                var cppTypeName = pointer.Visit(cppTypePrinter, quals);
+                var cppTypeName = pointer.Visit(cppTypePrinter,
+                    pointer.GetFinalQualifiedPointee().Qualifiers);
 
                 Context.Return.Write("({0})", cppTypeName);
                 Context.Return.Write(Context.Parameter.Name);

tests/CSharp/CSharp.cpp

@@ -262,6 +262,11 @@ long Proprietor::prop()
     return m_property;
 }
 
+const Baz& Proprietor::covariant()
+{
+    return Baz();
+}
+
 Bar::Items Proprietor::items() const
 {
     return _items;

tests/CSharp/CSharp.h

@@ -144,6 +144,8 @@ public:
     virtual int parent();
     virtual int parent() const;
 
+    virtual const Foo& covariant() = 0;
+
 protected:
     AbstractProprietor();
     AbstractProprietor(int i);
@@ -160,6 +162,8 @@ public:
 
     virtual long prop();
 
+    virtual const Baz& covariant();
+
     Bar::Items items() const;
     void setItems(const Bar::Items& value);