Rewrote the generating of properties to additionaly handle property overrides and read-only properties.

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

src/AST/Class.cs

@@ -231,7 +231,7 @@ namespace CppSharp.AST
         public Property GetRootBaseProperty(Property @override, bool onlyFirstBase = false)
         {
             return (from @base in Bases
-                    where !onlyFirstBase || !@base.Class.IsInterface
+                    where (!onlyFirstBase || !@base.Class.IsInterface) && @base.IsClass
                     let baseProperty = (
                         from property in @base.Class.Properties
                         where

src/AST/Property.cs

@@ -28,6 +28,42 @@ namespace CppSharp.AST
 
         public QualifiedType QualifiedType { get; set; }
 
+        public bool IsStatic
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsStatic) ||
+                       (SetMethod != null && SetMethod.IsStatic);
+            }
+        }
+
+        public bool IsPure
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsPure) ||
+                       (SetMethod != null && SetMethod.IsPure);
+            }
+        }
+
+        public bool IsVirtual
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsVirtual) ||
+                       (SetMethod != null && SetMethod.IsVirtual);
+            }
+        }
+
+        public bool IsOverride
+        {
+            get
+            {
+                return (GetMethod != null && GetMethod.IsOverride) ||
+                       (SetMethod != null && SetMethod.IsOverride);
+            }
+        }
+
         public Method GetMethod { get; set; }
 
         public Method SetMethod { get; set; }

src/Generator/Driver.cs

@@ -158,6 +158,7 @@ namespace CppSharp
                 TranslationUnitPasses.AddPass(new MultipleInheritancePass());
                 TranslationUnitPasses.AddPass(new ParamTypeToInterfacePass());
             }
+            TranslationUnitPasses.AddPass(new GetterSetterToPropertyPass());
         }
 
         public void ProcessCode()

src/Generator/Generators/CSharp/CSharpTextTemplate.cs

@@ -784,7 +784,6 @@ namespace CppSharp.Generators.CSharp
         {
             PushBlock(CSharpBlockKind.Method);
             WriteLine("set");
-            WriteStartBraceIndent();
 
             var param = new Parameter
             {
@@ -801,7 +800,14 @@ namespace CppSharp.Generators.CSharp
             if (decl is Function)
             {
                 var function = decl as Function;
+                if (function.IsPure && Driver.Options.GenerateAbstractImpls)
+                {
+                    Write("; ");
+                    PopBlock(NewLineKind.BeforeNextBlock);
+                    return;
+                }
 
+                WriteStartBraceIndent();
                 if (function.Parameters.Count == 0)
                     throw new NotSupportedException("Expected at least one parameter in setter");
 
@@ -810,16 +816,32 @@ namespace CppSharp.Generators.CSharp
                 var method = function as Method;
                 if (method != null && method.OperatorKind == CXXOperatorKind.Subscript)
                 {
-                    GenerateIndexerSetter(returnType, method);
+                    if (method.IsOverride && method.IsSynthetized)
+                    {
+                        GenerateVirtualTableFunctionCall(function, @class);
+                    }
+                    else
+                    {
+                        if (method.OperatorKind == CXXOperatorKind.Subscript)
+                        {
+                            GenerateIndexerSetter(returnType, method);                            
+                        }
+                        else
+                        {
+                            var parameters = new List<Parameter> { param };
+                            GenerateInternalFunctionCall(function, parameters);
+                        }
+                    }
                 }
                 else
                 {
                     var parameters = new List<Parameter> { param };
-                    GenerateInternalFunctionCall(function, parameters);   
+                    GenerateInternalFunctionCall(function, parameters); 
                 }
             }
             else if (decl is Field)
             {
+                WriteStartBraceIndent();
                 var field = decl as Field;
 
                 WriteLine("var {0} = (Internal*){1}.ToPointer();",
@@ -865,22 +887,39 @@ namespace CppSharp.Generators.CSharp
             where T : Declaration, ITypedDecl
         {
             PushBlock(CSharpBlockKind.Method);
-            WriteLine("get");
+            Write("get");
-            WriteStartBraceIndent();
 
             if (decl is Function)
             {
                 var function = decl as Function;
-                bool isPrimitiveIndexer = function.OperatorKind == CXXOperatorKind.Subscript &&
+                if (function.IsPure && Driver.Options.GenerateAbstractImpls)
-                                          function.ReturnType.Type.IsPointerToPrimitiveType();
+                {
-                if (isPrimitiveIndexer)
+                    Write("; ");
-                    TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer);
+                    PopBlock(NewLineKind.BeforeNextBlock);
-                GenerateInternalFunctionCall(function);
+                    return;
-                if (isPrimitiveIndexer)
+                }
-                    TypePrinter.PopContext();
+                WriteLine("");
+                WriteStartBraceIndent();
+                Method method = function as Method;
+                if (method != null && method.IsOverride && method.IsSynthetized)
+                {
+                    GenerateVirtualTableFunctionCall(function, @class);                    
+                }
+                else
+                {
+                    bool isPrimitiveIndexer = function.OperatorKind == CXXOperatorKind.Subscript &&
+                                              function.ReturnType.Type.IsPointerToPrimitiveType();
+                    if (isPrimitiveIndexer)
+                        TypePrinter.PushContext(CSharpTypePrinterContextKind.PrimitiveIndexer);
+                    GenerateInternalFunctionCall(function);
+                    if (isPrimitiveIndexer)
+                        TypePrinter.PopContext();   
+                }
             }
             else if (decl is Field)
             {
+                WriteLine("");
+                WriteStartBraceIndent();
                 var field = decl as Field;
 
                 WriteLine("var {0} = (Internal*){1}.ToPointer();",
@@ -905,6 +944,8 @@ namespace CppSharp.Generators.CSharp
             }
             else if (decl is Variable)
             {
+                WriteLine("");
+                WriteStartBraceIndent();
                 var @var = decl as Variable;
                 var libSymbol = GetDeclarationLibrarySymbol(@var);
 
@@ -990,10 +1031,22 @@ namespace CppSharp.Generators.CSharp
                     type = ((PointerType) prop.Type).Pointee;
 
                 if (prop.ExplicitInterfaceImpl == null)
-                    WriteLine("{0}{1} {2}", Helpers.GetAccess(prop.Access),
+                {
-                        type, GetPropertyName(prop));
+                    Write(Helpers.GetAccess(prop.Access));
+                    if (prop.IsStatic)
+                        Write("static ");
+                    if (prop.IsOverride)
+                        Write("override ");
+                    else if (prop.IsPure && Driver.Options.GenerateAbstractImpls)
+                        Write("abstract ");
+                    else if (prop.IsVirtual)
+                        Write("virtual ");
+                    WriteLine("{0} {1}", type, GetPropertyName(prop));
+                }
                 else
+                {
                     WriteLine("{0} {1}.{2}", type, prop.ExplicitInterfaceImpl.Name, GetPropertyName(prop));
+                }
                 WriteStartBraceIndent();
 
                 if (prop.Field != null)
@@ -1044,7 +1097,9 @@ namespace CppSharp.Generators.CSharp
         public void GenerateVTable(Class @class)
         {
             var entries = VTables.GatherVTableMethodEntries(@class);
-            entries = entries.Where(entry => !entry.Method.Ignore).ToList();
+            entries = entries.Where(e => !e.Method.Ignore ||
+                @class.Properties.Any(p => !p.Ignore &&
+                    (p.GetMethod == e.Method || p.SetMethod == e.Method))).ToList();
 
             if (entries.Count == 0)
                 return;
@@ -1203,7 +1258,16 @@ namespace CppSharp.Generators.CSharp
             if (hasReturn)
                 Write("var _ret = ");
 
-            WriteLine("target.{0}({1});", SafeIdentifier(method.Name), string.Join(", ", marshals));
+            if (method.IsGenerated)
+            {
+                WriteLine("target.{0}({1});", SafeIdentifier(method.Name), string.Join(", ", marshals));              
+            }
+            else
+            {
+                var name = ((Class) method.Namespace).Properties.First(
+                    p => p.GetMethod == method || p.SetMethod == method).Name;
+                WriteLine("target.{0};", name);              
+            }
 
             // TODO: Handle hidden structure return types.
 

src/Generator/Passes/FindSymbolsPass.cs

@@ -12,7 +12,7 @@ namespace CppSharp.Passes
 
             var mangledDecl = decl as IMangledDecl;
             var method = decl as Method;
-            if (mangledDecl != null && !(method != null && method.IsPure) &&
+            if (mangledDecl != null && !(method != null && (method.IsPure || method.IsSynthetized)) &&
                 !VisitMangledDeclaration(mangledDecl))
             {
                 decl.ExplicityIgnored = true;

src/Generator/Passes/GenerateAbstractImplementationsPass.cs

@@ -57,7 +57,8 @@ namespace CppSharp.Passes
                                 {
                                     Name = abstractMethod.Name + "Delegate",
                                     QualifiedType = abstractMethod.GetFunctionType(),
-                                    IgnoreFlags = abstractMethod.IgnoreFlags
+                                    IgnoreFlags = abstractMethod.IgnoreFlags,
+                                    Namespace = internalImpl
                                 };
                 internalImpl.Typedefs.Add(@delegate);
             }
@@ -79,7 +80,7 @@ namespace CppSharp.Passes
             var internalImpl = new Class
                                 {
                                     Name = @class.Name + "Internal",
-                                    Access = AccessSpecifier.Private,
+                                    Access = @class.Access,
                                     Namespace = @class.Namespace
                                 };
             var @base = new BaseClassSpecifier { Type = new TagType(@class) };

src/Generator/Passes/GetterSetterToPropertyPass.cs

@@ -1,5 +1,8 @@
 using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Linq;
+using System.Reflection;
 using CppSharp.AST;
 
 namespace CppSharp.Passes
@@ -10,6 +13,12 @@ namespace CppSharp.Passes
     /// </summary>
     public class GetterSetterToPropertyPass : TranslationUnitPass
     {
+        private readonly List<Method> setters = new List<Method>();
+        private readonly List<Method> setMethods = new List<Method>();
+        private readonly List<Method> nonSetters = new List<Method>();
+        private readonly HashSet<Method> getters = new HashSet<Method>();
+        private readonly HashSet<string> verbs = new HashSet<string>();
+
         public GetterSetterToPropertyPass()
         {
             Options.VisitClassFields = false;
@@ -21,123 +30,169 @@ namespace CppSharp.Passes
             Options.VisitNamespaceVariables = false;
             Options.VisitFunctionParameters = false;
             Options.VisitTemplateArguments = false;
+            using (var resourceStream = Assembly.GetExecutingAssembly()
+                .GetManifestResourceStream("CppSharp.Generator.Passes.verbs.txt"))
+            {
+                using (StreamReader streamReader = new StreamReader(resourceStream))
+                    while (!streamReader.EndOfStream)
+                        verbs.Add(streamReader.ReadLine());
+            }
         }
 
-        static bool IsSetter(Function method)
+        public override bool VisitTranslationUnit(TranslationUnit unit)
         {
-            var isRetVoid = method.ReturnType.Type.IsPrimitiveType(
+            bool result = base.VisitTranslationUnit(unit);
-                PrimitiveType.Void);
+            GenerateProperties();
-
+            return result;
-            var isSetter = method.OriginalName.StartsWith("set",
-                StringComparison.InvariantCultureIgnoreCase);
-
-            return isRetVoid && isSetter && method.Parameters.Count == 1;
         }
 
-        static bool IsGetter(Function method)
+        public override bool VisitMethodDecl(Method method)
         {
-            var isRetVoid = method.ReturnType.Type.IsPrimitiveType(
+            if (!method.IsConstructor && !method.IsDestructor && !method.IsOperator &&
-                PrimitiveType.Void);
+                !method.Ignore)
-
+                DistributeMethod(method);
-            var isGetter = method.OriginalName.StartsWith("get",
+            return base.VisitMethodDecl(method);
-                StringComparison.InvariantCultureIgnoreCase);
-
-            return !isRetVoid && isGetter && method.Parameters.Count == 0;
         }
 
-        Property GetOrCreateProperty(Class @class, string name, QualifiedType type)
+        public void GenerateProperties()
         {
-            var prop = @class.Properties.FirstOrDefault(property => property.Name == name
+            GenerateProperties(setters, false);
-                && property.QualifiedType.Equals(type));
+            GenerateProperties(setMethods, true);
-
+
-            var prop2 = @class.Properties.FirstOrDefault(property => property.Name == name);
+            foreach (Method getter in 
-
+                from getter in getters
-            if (prop == null && prop2 != null)
+                where getter.IsGenerated &&
-                Driver.Diagnostics.EmitWarning(DiagnosticId.PropertySynthetized,
+                      ((Class) getter.Namespace).Methods.All(m => m == getter || m.Name != getter.Name)
-                    "Property {0}::{1} already exist with type {2}", @class.Name, name, type.Type.ToString());
+                select getter)
-
-            if (prop != null)
-                return prop;
-
-            prop = new Property
             {
-                Name = name,
+                // Make it a read-only property
-                Namespace = @class,
+                GenerateProperty(getter.Namespace, getter);
-                QualifiedType = type
+            }
-            };
-
-            @class.Properties.Add(prop);
-            return prop;
         }
 
-        public override bool VisitMethodDecl(Method method)
+        private void GenerateProperties(IEnumerable<Method> settersToUse, bool readOnly)
         {
-            if (AlreadyVisited(method))
+            foreach (var group in settersToUse.GroupBy(m => m.Namespace))
-                return false;
-
-            if (ASTUtils.CheckIgnoreMethod(method))
-                return false;
-
-            var @class = method.Namespace as Class;
-
-            if (@class == null || @class.IsIncomplete)
-                return false;
-
-            if (IsGetter(method))
             {
-                var name = method.Name.Substring("get".Length);
+                foreach (var setter in group)
-                var prop = GetOrCreateProperty(@class, name, method.ReturnType);
+                {
-                prop.GetMethod = method;
+                    Class type = (Class) setter.Namespace;
-                prop.Access = method.Access;
+                    string afterSet = setter.Name.Substring(3);
-
+                    foreach (var getter in nonSetters.Where(m => m.Namespace == type))
-                // Do not generate the original method now that we know it is a getter.
+                    {
-                method.IsGenerated = false;
+                        if (string.Compare(getter.Name, afterSet, StringComparison.OrdinalIgnoreCase) == 0 &&
-
+                            getter.ReturnType == setter.Parameters[0].QualifiedType &&
-                Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized,
+                            !type.Methods.Any(
-                    "Getter created: {0}::{1}", @class.Name, name);
+                                m =>
-
+                                    m != getter &&
-                return false;
+                                    string.Compare(getter.Name, m.Name, StringComparison.OrdinalIgnoreCase) == 0))
+                        {
+                            GenerateProperty(getter.Namespace, getter, readOnly ? null : setter);
+                            goto next;
+                        }
+                    }
+                    Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = afterSet });
+                    if (!type.IsInterface && baseVirtualProperty != null)
+                    {
+                        bool isReadOnly = baseVirtualProperty.SetMethod == null;
+                        GenerateProperty(setter.Namespace, baseVirtualProperty.GetMethod,
+                            readOnly || isReadOnly ? null : setter);
+                    }
+                    next:
+                    ;
+                }
             }
-
+            foreach (Method nonSetter in nonSetters)
-            if (IsSetter(method) && IsValidSetter(method))
             {
-                var name = method.Name.Substring("set".Length);
+                Class type = (Class) nonSetter.Namespace;
-
+                string name = nonSetter.Name;
-                var type = method.Parameters[0].QualifiedType;
+                if (GetFirstWord(name) == "get")
-                var prop = GetOrCreateProperty(@class, name, type);
+                    name = name.Substring(3);
-                prop.SetMethod = method;
+                Property baseVirtualProperty = type.GetRootBaseProperty(new Property { Name = name });
-                prop.Access = method.Access;
+                if (!type.IsInterface && baseVirtualProperty != null)
+                {
+                    bool isReadOnly = baseVirtualProperty.SetMethod == null;
+                    if (readOnly == isReadOnly)
+                    {
+                        GenerateProperty(nonSetter.Namespace, nonSetter,
+                            readOnly ? null : baseVirtualProperty.SetMethod);
+                    }
+                }
+            }
+        }
 
-                // Ignore the original method now that we know it is a setter.
+        private static void GenerateProperty(DeclarationContext context, Method getter, Method setter = null)
-                method.IsGenerated = false;
+        {
+            Class type = (Class) context;
+            if (type.Properties.All(
+                p => string.Compare(getter.Name, p.Name, StringComparison.OrdinalIgnoreCase) != 0 ||
+                     p.ExplicitInterfaceImpl != getter.ExplicitInterfaceImpl))
+            {
+                Property property = new Property();
+                property.Name = getter.Name.Substring(GetFirstWord(getter.Name) == "get" ? 3 : 0);
+                property.Namespace = type;
+                property.QualifiedType = getter.ReturnType;
+                if (getter.IsOverride || (setter != null && setter.IsOverride))
+                {
+                    Property baseVirtualProperty = type.GetRootBaseProperty(property);
+                    if (baseVirtualProperty.SetMethod == null)
+                        setter = null;
+                    foreach (Method method in type.Methods.Where(m => m.Name == property.Name && m.Parameters.Count > 0))
+                        method.Name = "Get" + method.Name;
+                }
+                property.GetMethod = getter;
+                property.SetMethod = setter;
+                property.ExplicitInterfaceImpl = getter.ExplicitInterfaceImpl;
+                if (property.ExplicitInterfaceImpl == null && setter != null)
+                {
+                    property.ExplicitInterfaceImpl = setter.ExplicitInterfaceImpl;
+                }
+                // TODO: add comments
+                type.Properties.Add(property);
+                getter.IsGenerated = false;
+                if (setter != null)
+                    setter.IsGenerated = false;
+            }
+        }
 
-                Driver.Diagnostics.EmitMessage(DiagnosticId.PropertySynthetized,
-                    "Setter created: {0}::{1}", @class.Name, name);
 
-                return false;
+        private void DistributeMethod(Method method)
+        {
+            if (GetFirstWord(method.Name) == "set" &&
+                method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void))
+            {
+                if (method.Parameters.Count == 1)
+                    setters.Add(method);
+                else
+                    setMethods.Add(method);
+            }
+            else
+            {
+                if (IsGetter(method))
+                    getters.Add(method);
+                if (method.Parameters.Count == 0)
+                    nonSetters.Add(method);
             }
-
-            return false;
         }
 
-        // Check if a matching getter exist or no other setter exists.
+        private bool IsGetter(Method method)
-        private bool IsValidSetter(Method method)
         {
-            var @class = method.Namespace as Class;
+            if (method.ReturnType.Type.IsPrimitiveType(PrimitiveType.Void) ||
-            var name = method.Name.Substring("set".Length);
+                method.Parameters.Count > 0 || method.IsDestructor)
-
-            if (method.Parameters.Count == 0)
                 return false;
+            var result = GetFirstWord(method.Name);
+            return result == "get" || result == "is" || result == "has" || 
+                   (result != "to" && result != "new" && !verbs.Contains(result));
+        }
 
-            var type = method.Parameters[0].Type;
+        private static string GetFirstWord(string name)
-
+        {
-            var getter = @class.Methods.FirstOrDefault(m => m.Name == "Get" + name && m.Type.Equals(type));
+            List<char> firstVerb = new List<char>
-
+                                    {
-            var otherSetter = @class.Methods.FirstOrDefault(m => m.Name == method.Name
+                                        char.ToLowerInvariant(name[0])
-                && m.Parameters.Count == 1 
+                                    };
-                && !m.Parameters[0].Type.Equals(type));
+            firstVerb.AddRange(name.Skip(1).TakeWhile(char.IsLower));
-
+            return new string(firstVerb.ToArray());
-            return getter != null || otherSetter == null;
         }
     }
 }

src/Generator/Passes/MultipleInheritancePass.cs

@@ -66,9 +66,15 @@ namespace CppSharp.Passes
                 let i = GetInterface(@base, b.Class)
                 select new BaseClassSpecifier { Type = new TagType(i) });
 
-            @interface.Methods.AddRange(@base.Methods.Where(
+            @interface.Methods.AddRange(
-                m => !m.IsConstructor && !m.IsDestructor && !m.IsStatic && !m.Ignore));
+                from m in @base.Methods
-            @interface.Properties.AddRange(@base.Properties.Where(p => !p.Ignore));
+                where !m.IsConstructor && !m.IsDestructor && !m.IsStatic && !m.Ignore
+                select new Method(m) { Namespace = @interface });
+
+            @interface.Properties.AddRange(
+                from property in @base.Properties
+                where !property.Ignore
+                select new Property(property) { Namespace = @interface });
 
             if (@interface.Bases.Count == 0)
             {

src/Generator/Passes/RenamePass.cs

@@ -39,6 +39,7 @@ namespace CppSharp.Passes
             if (decl is Enumeration) return true;
             if (decl is Property) return true;
             if (decl is Event) return true;
+            if (decl is TypedefDecl) return true;
             return false;
         }
 
@@ -125,6 +126,14 @@ namespace CppSharp.Passes
             return base.VisitProperty(property);
         }
 
+        public override bool VisitTypedefDecl(TypedefDecl typedef)
+        {
+            if (!Targets.HasFlag(RenameTargets.Delegate))
+                return false;
+
+            return base.VisitTypedefDecl(typedef);
+        }
+
         public override bool VisitMethodDecl(Method method)
         {
             if (!Targets.HasFlag(RenameTargets.Method))
@@ -173,7 +182,8 @@ namespace CppSharp.Passes
         EnumItem  = 1 << 6,
         Event     = 1 << 7,
         Property  = 1 << 8,
-        Any = Function | Method | Parameter | Class | Field | Enum | EnumItem | Event | Property,
+        Delegate  = 1 << 9,
+        Any = Function | Method | Parameter | Class | Field | Enum | EnumItem | Event | Property | Delegate,
     }
 
     /// <summary>

tests/Basic/Basic.Tests.cs

@@ -112,17 +112,17 @@ public class BasicTests
     public void TestAbstractReturnType()
     {
         var returnsAbstractFoo = new ReturnsAbstractFoo();
-        var abstractFoo = returnsAbstractFoo.getFoo();
+        var abstractFoo = returnsAbstractFoo.Foo;
-        Assert.AreEqual(abstractFoo.pureFunction(), 5);
+        Assert.AreEqual(abstractFoo.pureFunction, 5);
-        Assert.AreEqual(abstractFoo.pureFunction1(), 10);
+        Assert.AreEqual(abstractFoo.pureFunction1, 10);
-        Assert.AreEqual(abstractFoo.pureFunction2(), 15);
+        Assert.AreEqual(abstractFoo.pureFunction2, 15);
     }
 
     [Test]
     public void TestANSI()
     {
         Foo foo = new Foo();
-        Assert.That(foo.GetANSI(), Is.EqualTo("ANSI"));
+        Assert.That(foo.ANSI, Is.EqualTo("ANSI"));
     }
 }
  

tests/VTables/VTables.Tests.cs

@@ -4,10 +4,13 @@ using VTables;
 
 public class FooDerived : Foo
 {
-    public override int vfoo()
+    public override int vfoo
     {
-        Console.WriteLine("Hello from FooDerived");
+        get
-        return 10;
+        {
+            Console.WriteLine("Hello from FooDerived");
+            return 10;
+        }
     }
 }
 
@@ -18,8 +21,8 @@ public class VTablesTests
     public void TestFoo()
     {
         var foo = new Foo();
-        Assert.That(foo.vfoo(), Is.EqualTo(5));
+        Assert.That(foo.vfoo, Is.EqualTo(5));
-        Assert.That(foo.Vbar(), Is.EqualTo(3));
+        Assert.That(foo.Vbar, Is.EqualTo(3));
         Assert.That(foo.CallFoo(), Is.EqualTo(7));
 
         var foo2 = new FooDerived();