Wrapped conversion (cast) operators.

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

src/AST/Method.cs

@@ -61,7 +61,8 @@ namespace CppSharp.AST
         Arrow,
         Call,
         Subscript,
-        Conditional
+        Conditional,
+        Conversion
     }
 
     /// <summary>
@@ -108,7 +109,20 @@ namespace CppSharp.AST
         public bool IsOverride { get; set; }
         public bool IsProxy { get; set; }
 
-        public CXXMethodKind Kind;
+        private CXXMethodKind kind;
+        public CXXMethodKind Kind
+        {
+            get { return kind; }
+            set
+            {
+                if (kind != value)
+                {
+                    kind = value;
+                    if (kind == CXXMethodKind.Conversion)
+                        OperatorKind = CXXOperatorKind.Conversion;
+                }
+            }
+        }
 
         public bool IsConstructor
         {

src/Generator/AST/Utils.cs

@@ -34,9 +34,6 @@ namespace CppSharp.AST
             if (method.OperatorKind == CXXOperatorKind.Equal)
                 return true;
 
-            if (method.Kind == CXXMethodKind.Conversion)
-                return true;
-
             if (method.Access == AccessSpecifier.Private && !method.IsOverride)
                 return true;
 
@@ -166,6 +163,9 @@ namespace CppSharp.AST
                 case CXXOperatorKind.Array_Delete:
                     isBuiltin = false;
                     return "Operator" + kind.ToString();
+
+                case CXXOperatorKind.Conversion:
+                    return "implicit operator";
             }
 
             throw new NotSupportedException();

src/Generator/Generators/CSharp/CSharpTextTemplate.cs

@@ -1607,11 +1607,14 @@ namespace CppSharp.Generators.CSharp
 
             if (method.IsConstructor || method.IsDestructor)
                 Write("{0}(", functionName);
-            else if (method.ExplicitInterfaceImpl == null)
+            else if (method.ExplicitInterfaceImpl != null)
-                Write("{0} {1}(", method.OriginalReturnType, functionName);
-            else
                 Write("{0} {1}.{2}(", method.OriginalReturnType,
                     method.ExplicitInterfaceImpl.Name, functionName);
+            else if (method.OperatorKind == CXXOperatorKind.Conversion)
+                Write("{0} {1}(", functionName, method.OriginalReturnType);
+            else
+                Write("{0} {1}(", method.OriginalReturnType, functionName);
+
 
             Write(FormatMethodParameters(method.Parameters));
 

src/Generator/Passes/CheckOperatorsOverloads.cs

@@ -187,6 +187,7 @@ namespace CppSharp.Passes
                 case CXXOperatorKind.Greater:
                 case CXXOperatorKind.LessEqual:
                 case CXXOperatorKind.GreaterEqual:
+                case CXXOperatorKind.Conversion:
                     return true;
 
                 case CXXOperatorKind.LessLess:

src/Parser/Parser.cpp

@@ -791,7 +791,6 @@ CppSharp::AST::Method^ Parser::WalkMethodCXX(clang::CXXMethodDecl* MD)
 
     CppSharp::AST::Method^ Method = gcnew CppSharp::AST::Method();
     Method->Access = ConvertToAccess(MD->getAccess());
-    Method->Kind = GetMethodKindFromDecl(Name);
     Method->IsStatic = MD->isStatic();
     Method->IsVirtual = MD->isVirtual();
     Method->IsConst = MD->isConst();
@@ -799,6 +798,8 @@ CppSharp::AST::Method^ Parser::WalkMethodCXX(clang::CXXMethodDecl* MD)
 
     WalkFunction(MD, Method);
 
+    Method->Kind = GetMethodKindFromDecl(Name);
+
     if (const CXXConstructorDecl* CD = dyn_cast<CXXConstructorDecl>(MD))
     {
         Method->IsDefaultConstructor = CD->isDefaultConstructor();

tests/CSharpTemp/CSharpTemp.Tests.cs

@@ -44,5 +44,7 @@ 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));
     }
 }

tests/CSharpTemp/CSharpTemp.cpp

@@ -55,3 +55,8 @@ Qux Baz::returnQux()
 {
     return Qux();
 }
+
+Baz::operator int() const
+{
+    return 500;
+}

tests/CSharpTemp/CSharpTemp.h

@@ -40,4 +40,5 @@ class DLL_API Baz : public Foo, public Bar
 public:
     int takesQux(const Qux& qux);
     Qux returnQux();
+    operator int() const;
 };