Handled indirect return params in type maps.

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

src/Generator/Generators/CSharp/CSharpTextTemplate.cs

@@ -2262,8 +2262,28 @@ namespace CppSharp.Generators.CSharp
                 Class retClass;
                 indirectRetType.Type.Desugar().TryGetClass(out retClass);
 
-                WriteLine("var {0} = new {1}.Internal();", GeneratedIdentifier("ret"),
+                TypeMap typeMap;
-                    QualifiedIdentifier(retClass.OriginalClass ?? retClass));
+                string construct = null;
+                if (Driver.TypeDatabase.FindTypeMap(retClass, out typeMap))
+                    construct = typeMap.CSharpConstruct();
+
+                if (construct == null)
+                {
+                    WriteLine("var {0} = new {1}.Internal();", GeneratedIdentifier("ret"),
+                        QualifiedIdentifier(retClass.OriginalClass ?? retClass));
+                }
+                else
+                {
+                    if (string.IsNullOrWhiteSpace(construct))
+                        WriteLine("{0} {1};",
+                            typeMap.CSharpSignature(new CSharpTypePrinterContext
+                            {
+                                Type = indirectRetType.Type.Desugar()
+                            }),
+                            GeneratedIdentifier("ret"));
+                    else
+                        WriteLine("var {0} = {1};", construct);
+                }
             }
 
             var names = new List<string>();

src/Generator/Types/TypeMap.cs

@@ -70,6 +70,15 @@ namespace CppSharp.Types
             
         }
 
+        /// <summary>
+        /// Used to construct a new instance of the mapped type.
+        /// </summary>
+        /// <returns></returns>
+        public virtual string CSharpConstruct()
+        {
+            return null;
+        }
+
         #endregion
 
         #region C++/CLI backend

tests/CSharpTemp/CSharpTemp.Tests.cs

@@ -150,4 +150,10 @@ public class CSharpTempTests : GeneratorTestFixture
     {
         new HasPrivateOverride().PrivateOverride();
     }
+
+    [Test]
+    public void TestQFlags()
+    {
+        Assert.AreEqual(TestFlag.Flag2, new ComplexType().ReturnsQFlags);
+    }
 }

tests/CSharpTemp/CSharpTemp.cpp

@@ -130,14 +130,29 @@ long P::prop()
     return m_property + 100;
 }
 
+template <typename T>
+QFlags<T>::QFlags(T t) : flag(t)
+{
+}
+
+template <typename T>
+QFlags<T>::operator T()
+{
+    return flag;
+}
+
+ComplexType::ComplexType() : qFlags(QFlags<TestFlag>(TestFlag::Flag2))
+{
+}
+
 int ComplexType::check()
 {
     return 5;
 }
 
-QFlags<int> ComplexType::returnsQFlags()
+QFlags<TestFlag> ComplexType::returnsQFlags()
 {
-    return QFlags<int>();
+    return qFlags;
 }
 
 void ComplexType::takesQFlags(const QFlags<int> f)

tests/CSharpTemp/CSharpTemp.cs

@@ -13,6 +13,11 @@ namespace CppSharp.Tests
     [TypeMap("QFlags")]
     public class QFlags : TypeMap
     {
+        public override string CSharpConstruct()
+        {
+            return string.Empty;
+        }
+
         public override string CSharpSignature(CSharpTypePrinterContext ctx)
         {
             TemplateArgument templateArgument =

tests/CSharpTemp/CSharpTemp.h

@@ -102,18 +102,30 @@ public:
 Proprietor::Proprietor() {}
 
 template <typename T>
-class QFlags
+class DLL_API QFlags
 {
 public:
-    QFlags() {}
+    QFlags(T t);
+    operator T();
+private:
+    T flag;
+};
+
+enum class TestFlag
+{
+    Flag1,
+    Flag2
 };
 
 class DLL_API ComplexType
 {
 public:
+    ComplexType();
     int check();
-    QFlags<int> returnsQFlags();
+    QFlags<TestFlag> returnsQFlags();
     void takesQFlags(const QFlags<int> f);
+private:
+    QFlags<TestFlag> qFlags;
 };
 
 class DLL_API P : Proprietor