Improved wide char handling in the C# and CLI.

References #320.

src/Generator/Generators/CLI/CLIMarshal.cs

@@ -3,6 +3,7 @@ using System.Linq;
 using System.Text;
 using CppSharp.AST;
 using CppSharp.AST.Extensions;
+using CppSharp.Generators.CSharp;
 using CppSharp.Types;
 using Delegate = CppSharp.AST.Delegate;
 using Type = CppSharp.AST.Type;
@@ -73,10 +74,10 @@ namespace CppSharp.Generators.CLI
                 return true;
             }
 
-            if (pointee.IsPrimitiveType(PrimitiveType.Char))
+            if (CSharpTypePrinter.IsConstCharString(pointer))
             {
-                Context.Return.Write("clix::marshalString<clix::E_UTF8>({0})",
+                Context.Return.Write(MarshalStringToManaged(Context.ReturnVarName,
-                             Context.ReturnVarName);
+                    pointer.Pointee.Desugar() as BuiltinType));
                 return true;
             }
 
@@ -95,11 +96,12 @@ namespace CppSharp.Generators.CLI
                 if (quals.IsConst != Context.ReturnType.Qualifiers.IsConst)
                 {
                     var nativeTypePrinter = new CppTypePrinter(Context.Driver.TypeDatabase, false);
+                    var returnType = Context.ReturnType.Type.Desugar();
                     var constlessPointer = new PointerType()
                     {
                         IsDependent = pointer.IsDependent,
                         Modifier = pointer.Modifier,
-                        QualifiedPointee = new QualifiedType(Context.ReturnType.Type.GetPointee())
+                        QualifiedPointee = new QualifiedType(returnType.GetPointee())
                     };
                     var nativeConstlessTypeName = constlessPointer.Visit(nativeTypePrinter, new TypeQualifiers());
                     returnVarName = string.Format("const_cast<{0}>({1})",
@@ -138,6 +140,25 @@ namespace CppSharp.Generators.CLI
             return pointer.Pointee.Visit(this, quals);
         }
 
+        private string MarshalStringToManaged(string varName, BuiltinType type)
+        {
+            var encoding = type.Type == PrimitiveType.Char ?
+                Encoding.ASCII : Encoding.Unicode;
+
+            if (Equals(encoding, Encoding.ASCII))
+                encoding = Context.Driver.Options.Encoding;
+
+            if (Equals(encoding, Encoding.ASCII))
+                return string.Format("clix::marshalString<clix::E_UTF8>({0})", varName);
+
+            if (Equals(encoding, Encoding.Unicode) ||
+                Equals(encoding, Encoding.BigEndianUnicode))
+                return string.Format("clix::marshalString<clix::E_UTF16>({0})", varName);
+
+            throw new NotSupportedException(string.Format("{0} is not supported yet.",
+                Context.Driver.Options.Encoding.EncodingName));
+        }
+
         public override bool VisitMemberPointerType(MemberPointerType member,
             TypeQualifiers quals)
         {

src/Generator/Generators/CLI/CLITypePrinter.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using CppSharp.AST;
 using CppSharp.AST.Extensions;
+using CppSharp.Generators.CSharp;
 using CppSharp.Types;
 using Type = CppSharp.AST.Type;
 
@@ -139,10 +140,8 @@ namespace CppSharp.Generators.CLI
                 return string.Format("{0}^", function.Visit(this, quals));
             }
 
-            if (pointee.IsPrimitiveType(PrimitiveType.Char) && quals.IsConst)
+            if (CSharpTypePrinter.IsConstCharString(pointer))
-            {
                 return "System::String^";
-            }
 
             // From http://msdn.microsoft.com/en-us/library/y31yhkeb.aspx
             // Any of the following types may be a pointer type:

src/Generator/Generators/CSharp/CSharpMarshal.cs

@@ -146,7 +146,8 @@ namespace CppSharp.Generators.CSharp
 
             if (CSharpTypePrinter.IsConstCharString(pointer))
             {
-                Context.Return.Write(MarshalStringToManaged(Context.ReturnVarName));
+                Context.Return.Write(MarshalStringToManaged(Context.ReturnVarName,
+                    pointer.Pointee.Desugar() as BuiltinType));
                 return true;
             }
 
@@ -167,17 +168,21 @@ namespace CppSharp.Generators.CSharp
             return pointer.Pointee.Visit(this, quals);
         }
 
-        private string MarshalStringToManaged(string varName)
+        private string MarshalStringToManaged(string varName, BuiltinType type)
         {
-            if (Equals(Context.Driver.Options.Encoding, Encoding.ASCII))
+            var encoding = type.Type == PrimitiveType.Char ?
-            {
+                Encoding.ASCII : Encoding.Unicode;
+
+            if (Equals(encoding, Encoding.ASCII))
+                encoding = Context.Driver.Options.Encoding;
+
+            if (Equals(encoding, Encoding.ASCII))
                 return string.Format("Marshal.PtrToStringAnsi({0})", varName);
-            }
+
-            if (Equals(Context.Driver.Options.Encoding, Encoding.Unicode) ||
+            if (Equals(encoding, Encoding.Unicode) ||
-                Equals(Context.Driver.Options.Encoding, Encoding.BigEndianUnicode))
+                Equals(encoding, Encoding.BigEndianUnicode))
-            {
                 return string.Format("Marshal.PtrToStringUni({0})", varName);
-            }
+
             throw new NotSupportedException(string.Format("{0} is not supported yet.",
                 Context.Driver.Options.Encoding.EncodingName));
         }

src/Generator/Generators/CSharp/CSharpTypePrinter.cs

@@ -176,8 +176,9 @@ namespace CppSharp.Generators.CSharp
             var pointee = pointer.Pointee.Desugar();
 
             return (pointee.IsPrimitiveType(PrimitiveType.Char) ||
+                    pointee.IsPrimitiveType(PrimitiveType.Char16) ||
                     pointee.IsPrimitiveType(PrimitiveType.WideChar)) &&
-                   pointer.QualifiedPointee.Qualifiers.IsConst;
+                    pointer.QualifiedPointee.Qualifiers.IsConst;
         }
 
         public static bool IsConstCharString(QualifiedType qualType)

src/Generator/Types/CppTypePrinter.cs

@@ -103,7 +103,7 @@ namespace CppSharp.Types
                 case PrimitiveType.Bool: return "bool";
                 case PrimitiveType.Void: return "void";
                 case PrimitiveType.Char16:
-                case PrimitiveType.WideChar: return "char";
+                case PrimitiveType.WideChar: return "wchar_t";
                 case PrimitiveType.Char: return "char";
                 case PrimitiveType.UChar: return "unsigned char";
                 case PrimitiveType.Short: return "short";

tests/Basic/Basic.Tests.cs

@@ -369,6 +369,7 @@ public class BasicTests : GeneratorTestFixture
         Assert.That(prop.FieldValue, Is.EqualTo(10));
     }
 
+    [Test]
     public void TestVariable()
     {
         // Test field property
@@ -377,6 +378,14 @@ public class BasicTests : GeneratorTestFixture
         Assert.That(TestVariables.VALUE, Is.EqualTo(10));
     }
 
+    [Test]
+    public void TestWideStrings()
+    {
+        var ws = new TestWideStrings();
+        var s = ws.WidePointer;
+        Assert.That(ws.WidePointer, Is.EqualTo("Hello"));
+    }
+
     [Test]
     public unsafe void TestArraysPointers()
     {

tests/Basic/Basic.h

@@ -508,6 +508,14 @@ struct DLL_API TestVariables
 int TestVariables::VALUE;
 void TestVariables::SetValue(int value) { VALUE = value; }
 
+typedef const wchar_t * LPCWSTR;
+struct DLL_API TestWideStrings
+{
+	LPCWSTR GetWidePointer();
+};
+
+LPCWSTR TestWideStrings::GetWidePointer() { return L"Hello"; }
+
 enum struct MyEnum { A, B, C };
 
 class DLL_API TestArraysPointers