Fixed support for C++ conversion operators.

src/Generator/Generators/CLI/CLIHeadersTemplate.cs

@@ -571,8 +571,9 @@ namespace CppSharp.Generators.CLI
             if (method.IsStatic || isBuiltinOperator)
                 Write("static ");
 
-            if (method.Kind == CXXMethodKind.Constructor || method.Kind == CXXMethodKind.Destructor)
-                Write("{0}(", SafeIdentifier(method.Name));
+            if (method.IsConstructor || method.IsDestructor ||
+                method.OperatorKind == CXXOperatorKind.Conversion)
+                Write("{0}(", GetMethodName(method));
             else
                 Write("{0} {1}(", method.ReturnType, SafeIdentifier(method.Name));
 

src/Generator/Generators/CLI/CLISourcesTemplate.cs

@@ -577,8 +577,9 @@ namespace CppSharp.Generators.CLI
         {
             PushBlock(CLIBlockKind.Method, method);
 
-            if (method.IsConstructor || method.IsDestructor)
-                Write("{0}::{1}(", QualifiedIdentifier(@class), SafeIdentifier(method.Name));
+            if (method.IsConstructor || method.IsDestructor ||
+                method.OperatorKind == CXXOperatorKind.Conversion)
+                Write("{0}::{1}(", QualifiedIdentifier(@class), GetMethodName(method));
             else
                 Write("{0} {1}::{2}(", method.ReturnType, QualifiedIdentifier(@class),
                       SafeIdentifier(method.Name));
@@ -752,7 +753,14 @@ namespace CppSharp.Generators.CLI
                 Write("auto {0}{1} = ",(function.ReturnType.Type.IsReference())? "&": string.Empty,
                     Generator.GeneratedIdentifier("ret"));
 
-            if (function.IsOperator)
+            if (function.OperatorKind == CXXOperatorKind.Conversion)
+            {
+                var method = function as Method;
+                var typePrinter = new CppTypePrinter(Driver.TypeDatabase);
+                var typeName = method.ConversionType.Visit(typePrinter);
+                WriteLine("({0}) {1};", typeName, @params[0].Name);
+            }
+            else if (function.IsOperator)
             {
                 var opName = function.Name.Replace("operator", "").Trim();
 

src/Generator/Generators/CLI/CLITextTemplate.cs

@@ -79,6 +79,14 @@ namespace CppSharp.Generators.CLI
             return string.Format("{0}", decl.QualifiedName);
         }
 
+        public string GetMethodName(Method method)
+        {
+            if (method.OperatorKind == CXXOperatorKind.Conversion)
+                return SafeIdentifier("operator " + method.ConversionType);
+
+            return SafeIdentifier(method.Name);
+        }
+
         public void GenerateDeclarationCommon(Declaration decl)
         {
             if (decl.Comment == null)

tests/Basic/Basic.Tests.cs

@@ -124,5 +124,24 @@ public class BasicTests
         Foo foo = new Foo();
         Assert.That(foo.GetANSI(), Is.EqualTo("ANSI"));
     }
+
+    [Test, Ignore]
+    public void TestConversionOperator()
+    {
+        var bar = new Bar2 {A = 1, B = 2, C = 3};
+        Foo2 foo = bar;
+        Assert.AreEqual(foo.A, 1);
+        Assert.AreEqual(foo.B, 2);
+        Assert.AreEqual(foo.C, 3);
+
+        Assert.AreEqual(300, new Bar2.Nested());
+        Assert.AreEqual(500, new Bar2());
+    }
+
+    static void Main(string[] args)
+    {
+        var bar = new Bar2 { A = 1, B = 2, C = 3 };
+        Foo2 foo = bar;
+    }
 }
  

tests/Basic/Basic.cpp

@@ -32,6 +32,26 @@ Bar::Item Bar::RetItem1()
     return Bar::Item1;
 }
 
+Bar2::Nested::operator int() const
+{
+    return 300;
+}
+
+Bar2::operator int() const
+{
+    return 500;
+}
+
+Bar2::operator Foo2()
+{
+    Foo2 f;
+    f.A = A;
+    f.B = B;
+    f.C = C;
+
+    return f;
+}
+
 Hello::Hello ()
 {
     //cout << "Ctor!" << "\n";

tests/Basic/Basic.h

@@ -47,6 +47,19 @@ struct DLL_API Bar
 
 struct DLL_API Bar2 : public Bar
 {
+    // Conversion operators
+
+    struct DLL_API Nested
+    {
+        operator int() const;
+    };
+
+    operator int() const;
+    operator Foo2();
+
+    typedef void *Bar2::*FunctionPointerResolvedAsVoidStar;
+    operator FunctionPointerResolvedAsVoidStar() const { return 0; }
+
     int C;
 };
 

tests/CSharpTemp/CSharpTemp.Tests.cs

@@ -43,7 +43,7 @@ public class CSharpTempTests
     [Test]
     public void TestMultipleInheritance()
     {
-        Baz baz = new Baz();
+        var baz = new Baz();
         Assert.That(baz.Method, Is.EqualTo(1));
         var bar = (IBar) baz;
         Assert.That(bar.Method, Is.EqualTo(2));
@@ -53,11 +53,6 @@ public class CSharpTempTests
         Assert.That(baz.FarAwayFunc, Is.EqualTo(20));
         Assert.That(baz.TakesQux(baz), Is.EqualTo(20));
         Assert.That(baz.ReturnQux().FarAwayFunc, Is.EqualTo(20));
-        int cast = baz;
-        Assert.That(cast, Is.EqualTo(500));
-        var nested = new Baz.Nested();
-        int nestedCast = nested;
-        Assert.That(nestedCast, Is.EqualTo(300));
     }
 
     [Test]

tests/CSharpTemp/CSharpTemp.cpp

@@ -80,11 +80,6 @@ Bar Bar::operator ++(int i)
     return bar;
 }
 
-Baz::Nested::operator int() const
-{
-    return 300;
-}
-
 int Baz::takesQux(const Qux& qux)
 {
     return qux.farAwayFunc();
@@ -95,11 +90,6 @@ Qux Baz::returnQux()
     return Qux();
 }
 
-Baz::operator int() const
-{
-    return 500;
-}
-
 int AbstractProprietor::getValue()
 {
     return m_value;

tests/CSharpTemp/CSharpTemp.h

@@ -46,18 +46,9 @@ private:
 class DLL_API Baz : public Foo, public Bar
 {
 public:
-    class DLL_API Nested
-    {
-    public:
-        operator int() const;
-    };
 
     int takesQux(const Qux& qux);
     Qux returnQux();
-    operator int() const;
-
-    typedef void *Baz::*FunctionPointerResolvedAsVoidStar;
-    operator FunctionPointerResolvedAsVoidStar() const { return 0; }
 };
 
 struct QArrayData