Updated Qt# to the latest C++#.

ddobrev · ddobrev · commit fc165fa0d3a4 · 2016-09-13T14:03:40.000+03:00
Signed-off-by: Dimitar Dobrev &lt;dpldobrev@protonmail.com&gt;
diff --git a/QtSharp.CLI/packages.config b/QtSharp.CLI/packages.config
@@ -1,5 +1,5 @@
 ﻿<?xml version="1.0" encoding="utf-8"?>
 <packages>
   <package id="Baseclass.Contrib.Nuget.Output" version="2.1.0" targetFramework="net451" />
-  <package id="CppSharp" version="0.5.2" targetFramework="net451" developmentDependency="true" />
+  <package id="CppSharp" version="0.7.0" targetFramework="net451" developmentDependency="true" />
 </packages>
diff --git a/QtSharp/CompileInlinesPass.cs b/QtSharp/CompileInlinesPass.cs
@@ -3,9 +3,9 @@
 using System.Linq;
 using System.Text;
 using CppSharp.AST;
-using CppSharp.Parser;
 using CppSharp.Passes;
 using CppSharp;
+using CppSharp.Parser;
 
 namespace QtSharp
 {
@@ -22,13 +22,13 @@ public CompileInlinesPass(string qmake, string make)
 
         public override bool VisitLibrary(ASTContext context)
         {
-            foreach (var module in Driver.Options.Modules)
+            foreach (var module in this.Context.Options.Modules)
             {
                 string error;
                 const string qtVersionVariable = "QT_VERSION";
                 var qtVersion = ProcessHelper.Run(this.qmake, string.Format("-query {0}", qtVersionVariable), out error);
-                var qtVersionFile = Path.Combine(this.Driver.Options.OutputDir, qtVersionVariable);
-                var dir = Platform.IsMacOS ? this.Driver.Options.OutputDir : Path.Combine(this.Driver.Options.OutputDir, "release");
+                var qtVersionFile = Path.Combine(this.Context.Options.OutputDir, qtVersionVariable);
+                var dir = Platform.IsMacOS ? this.Context.Options.OutputDir : Path.Combine(this.Context.Options.OutputDir, "release");
                 var inlines = Path.GetFileName(string.Format("{0}{1}.{2}", Platform.IsWindows ? string.Empty : "lib",
                     module.InlinesLibraryName, Platform.IsMacOS ? "dylib" : "dll"));
                 var libFile = Path.Combine(dir, inlines);
@@ -56,8 +56,8 @@ public override bool VisitLibrary(ASTContext context)
                     if (parserResult.Kind == ParserResultKind.Success)
                     {
                         var nativeLibrary = CppSharp.ClangParser.ConvertLibrary(parserResult.Library);
-                        this.Driver.Symbols.Libraries.Add(nativeLibrary);
-                        this.Driver.Symbols.IndexSymbols();
+                        this.Context.Symbols.Libraries.Add(nativeLibrary);
+                        this.Context.Symbols.IndexSymbols();
                         parserResult.Library.Dispose();
                     }
                 }
@@ -68,7 +68,7 @@ public override bool VisitLibrary(ASTContext context)
         private bool CompileInlines(Module module)
         {
             var pro = string.Format("{0}.pro", module.InlinesLibraryName);
-            var path = Path.Combine(this.Driver.Options.OutputDir, pro);
+            var path = Path.Combine(this.Context.Options.OutputDir, pro);
             var proBuilder = new StringBuilder();
             var qtModules = string.Join(" ", from header in module.Headers
                                              where !header.EndsWith(".h", StringComparison.Ordinal)
@@ -104,11 +104,11 @@ private bool CompileInlines(Module module)
                 Console.WriteLine(error);
                 return false;
             }
-            var makefile = File.Exists(Path.Combine(Driver.Options.OutputDir, "Makefile.Release")) ? "Makefile.Release" : "Makefile";
+            var makefile = File.Exists(Path.Combine(this.Context.Options.OutputDir, "Makefile.Release")) ? "Makefile.Release" : "Makefile";
             if (Platform.IsMacOS)
             {
                 // HACK: Clang does not support -fkeep-inline-functions so force compilation with (the real) GCC on OS X
-                var makefilePath = Path.Combine(Driver.Options.OutputDir, makefile);
+                var makefilePath = Path.Combine(this.Context.Options.OutputDir, makefile);
                 var script = new StringBuilder(File.ReadAllText(makefilePath));
                 var xcodePath = XcodeToolchain.GetXcodePath();
                 script.Replace(Path.Combine(xcodePath, "Contents", "Developer", "usr", "bin", "gcc"), "/usr/local/bin/gcc");
diff --git a/QtSharp/GenerateEventEventsPass.cs b/QtSharp/GenerateEventEventsPass.cs
@@ -11,11 +11,16 @@ namespace QtSharp
 {
     public class GenerateEventEventsPass : TranslationUnitPass
     {
+        public GenerateEventEventsPass(Generator generator)
+        {
+            this.generator = generator;
+        }
+
         public override bool VisitTranslationUnit(TranslationUnit unit)
         {
             if (!this.eventAdded)
             {
-                this.Driver.Generator.OnUnitGenerated += this.OnUnitGenerated;
+                this.generator.OnUnitGenerated += this.OnUnitGenerated;
                 this.eventAdded = true;
             }
             return base.VisitTranslationUnit(unit);
@@ -78,7 +83,7 @@ public override bool VisitMethodDecl(Method method)
                         baseMethod.IsPure)
                     {
                         this.events.Add(method);
-                        this.Driver.Options.ExplicitlyPatchedVirtualFunctions.Add(method.QualifiedOriginalName);
+                        this.Context.Options.ExplicitlyPatchedVirtualFunctions.Add(method.QualifiedOriginalName);
                     }
                 }
             }
@@ -87,5 +92,6 @@ public override bool VisitMethodDecl(Method method)
 
         private bool eventAdded;
         private readonly HashSet<Method> events = new HashSet<Method>();
+        private Generator generator;
     }
 }
diff --git a/QtSharp/GenerateSignalEventsPass.cs b/QtSharp/GenerateSignalEventsPass.cs
@@ -15,12 +15,18 @@ public class GenerateSignalEventsPass : TranslationUnitPass
     {
         private bool eventAdded;
         private readonly HashSet<Event> events = new HashSet<Event>();
+        private Generator generator;
+
+        public GenerateSignalEventsPass(Generator generator)
+        {
+            this.generator = generator;
+        }
 
         public override bool VisitTranslationUnit(TranslationUnit unit)
         {
             if (!this.eventAdded)
             {
-                this.Driver.Generator.OnUnitGenerated += this.OnUnitGenerated;
+                this.generator.OnUnitGenerated += this.OnUnitGenerated;
                 this.eventAdded = true;
             }
             return base.VisitTranslationUnit(unit);
@@ -115,7 +121,7 @@ from e in @event.Parameters
             var qtMetacall = (
                 from template in generatorOutput.Templates
                 from block in template.FindBlocks(CSharpBlockKind.Method)
-                where block.Declaration != null && block.Declaration.Name == "Qt_metacall" &&
+                where block.Declaration != null && block.Declaration.Name == "QtMetacall" &&
                       block.Declaration.Namespace.Name == "QObject"
                 select block).FirstOrDefault();
             if (qtMetacall != null)
@@ -147,7 +153,7 @@ public override bool VisitClassDecl(Class @class)
             var qtMetaCall = @class.FindMethod("qt_metacall");
             if (qtMetaCall != null)
             {
-                this.Driver.Options.ExplicitlyPatchedVirtualFunctions.Add(qtMetaCall.QualifiedOriginalName);
+                this.Context.Options.ExplicitlyPatchedVirtualFunctions.Add(qtMetaCall.QualifiedOriginalName);
             }
             return true;
         }
diff --git a/QtSharp/GetCommentsFromQtDocsPass.cs b/QtSharp/GetCommentsFromQtDocsPass.cs
@@ -11,12 +11,12 @@ public class GetCommentsFromQtDocsPass : TranslationUnitPass
         public GetCommentsFromQtDocsPass(string docsPath, IEnumerable<string> modules)
         {
             this.documentation = new Documentation(docsPath, modules);
-            this.Options.VisitFunctionReturnType = false;
-            this.Options.VisitFunctionParameters = false;
-            this.Options.VisitEventParameters = false;
-            this.Options.VisitClassBases = false;
-            this.Options.VisitTemplateArguments = false;
-            this.Options.VisitClassFields = false;
+            this.VisitOptions.VisitFunctionReturnType = false;
+            this.VisitOptions.VisitFunctionParameters = false;
+            this.VisitOptions.VisitEventParameters = false;
+            this.VisitOptions.VisitClassBases = false;
+            this.VisitOptions.VisitTemplateArguments = false;
+            this.VisitOptions.VisitClassFields = false;
         }
 
         public override bool VisitLibrary(ASTContext context)
diff --git a/QtSharp/QFlags.cs b/QtSharp/QFlags.cs
@@ -24,15 +24,15 @@ public override string CSharpSignature(CSharpTypePrinterContext ctx)
             return this.CSharpSignatureType(ctx).ToString();
         }
 
-        public override void CSharpMarshalToNative(MarshalContext ctx)
+        public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
         {
             if (ctx.Parameter.Type.Desugar().IsAddress())
                 ctx.Return.Write("new global::System.IntPtr(&{0})", ctx.Parameter.Name);
             else
                 ctx.Return.Write(ctx.Parameter.Name);
         }
 
-        public override void CSharpMarshalToManaged(MarshalContext ctx)
+        public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
         {
             if (ctx.ReturnType.Type.Desugar().IsAddress())
             {
diff --git a/QtSharp/QString.cs b/QtSharp/QString.cs
@@ -1,6 +1,5 @@
 ﻿using CppSharp.AST;
 using CppSharp.AST.Extensions;
-using CppSharp.Generators;
 using CppSharp.Generators.CSharp;
 using CppSharp.Types;
 
@@ -13,12 +12,12 @@ public override string CSharpSignature(CSharpTypePrinterContext ctx)
         {
             if (ctx.CSharpKind == CSharpTypePrinterContextKind.Native)
             {
-                return ctx.Type.IsAddress() ? "QtCore.QString.Internal*" : "QtCore.QString.Internal";
+                return string.Format("QtCore.QString.{0}{1}", Helpers.InternalStruct, ctx.Type.IsAddress() ? "*" : string.Empty);
             }
             return "string";
         }
 
-        public override void CSharpMarshalToNative(MarshalContext ctx)
+        public override void CSharpMarshalToNative(CSharpMarshalContext ctx)
         {
             ctx.SupportBefore.WriteLine("var __stringPtr{0} = ReferenceEquals({1}, null) ? null : (ushort*) Marshal.StringToHGlobalUni({1}).ToPointer();",
                                         ctx.ParameterIndex, ctx.Parameter.Name);
@@ -37,13 +36,13 @@ public override void CSharpMarshalToNative(MarshalContext ctx)
             {
                 this.Type.TryGetClass(out @class);
             }
-            this.typePrinter = this.typePrinter ?? (this.typePrinter = new CSharpTypePrinter(ctx.Driver));
+            this.typePrinter = this.typePrinter ?? (this.typePrinter = new CSharpTypePrinter(ctx.Context));
             var qualifiedIdentifier = (@class.OriginalClass ?? @class).Visit(this.typePrinter);
-            ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.Internal() : *({1}.Internal*) (__qstring{0}.{2})",
-                             ctx.ParameterIndex, qualifiedIdentifier, Helpers.InstanceIdentifier);
+            ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.{2}() : *({1}.{2}*) (__qstring{0}.{3})",
+                             ctx.ParameterIndex, qualifiedIdentifier, Helpers.InternalStruct, Helpers.InstanceIdentifier);
         }
 
-        public override void CSharpMarshalToManaged(MarshalContext ctx)
+        public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)
         {
             ctx.Return.Write("Marshal.PtrToStringUni(new IntPtr(QtCore.QString.{0}({1}).Utf16))",
                 Helpers.CreateInstanceIdentifier, ctx.ReturnVarName);
diff --git a/QtSharp/QtSharp.cs b/QtSharp/QtSharp.cs
@@ -33,13 +33,19 @@ public ICollection<KeyValuePair<string, string>> GetVerifiedWrappedModules()
 
         public void Preprocess(Driver driver, ASTContext lib)
         {
-            foreach (var unit in lib.TranslationUnits.Where(u => u.FilePath != "<invalid>"))
+            foreach (var unit in lib.TranslationUnits.Where(u => u.IsValid))
             {
-                IgnorePrivateDeclarations(unit);
+                // HACK: work around https://github.com/mono/CppSharp/issues/677
+                if (unit.FileName == "locale_classes.tcc")
+                {
+                    unit.ExplicitlyIgnore();
+                }
+                else
+                {
+                    IgnorePrivateDeclarations(unit);
+                }
             }
             lib.SetClassAsValueType("QByteArray");
-            lib.SetClassAsValueType("QListData");
-            lib.SetClassAsValueType("QListData::Data");
             lib.SetClassAsValueType("QLocale");
             lib.SetClassAsValueType("QModelIndex");
             lib.SetClassAsValueType("QPoint");
@@ -51,8 +57,6 @@ public void Preprocess(Driver driver, ASTContext lib)
             lib.SetClassAsValueType("QGenericArgument");
             lib.SetClassAsValueType("QGenericReturnArgument");
             lib.SetClassAsValueType("QVariant");
-            lib.IgnoreClassMethodWithName("QString", "fromStdWString");
-            lib.IgnoreClassMethodWithName("QString", "toStdWString");
 
             // QString is type-mapped to string so we only need two methods for the conversion
             var qString = lib.FindCompleteClass("QString");
@@ -133,6 +137,34 @@ where string.IsNullOrEmpty(@enum.Name)
             {
                 enumeration.Name = "TypeEnum";
             }
+
+            // HACK: work around https://github.com/mono/CppSharp/issues/692
+            foreach (var name in new[] { "QImage", "QPixmap" })
+            {
+                var @class = lib.FindCompleteClass(name);
+                var ctorWithArray = @class.Constructors.FirstOrDefault(
+                    c => c.Parameters.Count == 1 && c.Parameters[0].Type.Desugar() is ArrayType);
+                if (ctorWithArray != null)
+                {
+                    ctorWithArray.ExplicitlyIgnore();
+                }
+            }
+            foreach (var name in new[] { "QGraphicsScene", "QGraphicsView" })
+            {
+                var @class = lib.FindCompleteClass(name);
+                 var drawItems = @class.Methods.FirstOrDefault(m => m.OriginalName == "drawItems");
+                if (drawItems != null)
+                {
+                    drawItems.ExplicitlyIgnore();
+                }
+            }
+            lib.FindCompleteClass("QAbstractPlanarVideoBuffer").ExplicitlyIgnore();
+            var qAbstractVideoBuffer = lib.FindCompleteClass("QAbstractVideoBuffer");
+            var mapPlanes = qAbstractVideoBuffer.Methods.FirstOrDefault(m => m.OriginalName == "mapPlanes");
+            if (mapPlanes != null)
+            {
+                mapPlanes.ExplicitlyIgnore();
+            }
         }
 
         private static void IgnorePrivateDeclarations(DeclarationContext unit)
@@ -163,15 +195,15 @@ private static void IgnorePrivateDeclaration(Declaration declaration)
 
         public void Postprocess(Driver driver, ASTContext lib)
         {
-            new ClearCommentsPass().VisitLibrary(driver.ASTContext);
+            new ClearCommentsPass().VisitLibrary(driver.Context.ASTContext);
             var modules = this.qtInfo.LibFiles.Select(l => GetModuleNameFromLibFile(l));
             var s = System.Diagnostics.Stopwatch.StartNew();
-            new GetCommentsFromQtDocsPass(this.qtInfo.Docs, modules).VisitLibrary(driver.ASTContext);
+            new GetCommentsFromQtDocsPass(this.qtInfo.Docs, modules).VisitLibrary(driver.Context.ASTContext);
             System.Console.WriteLine("Documentation done in: {0}", s.Elapsed);
             new CaseRenamePass(
                 RenameTargets.Function | RenameTargets.Method | RenameTargets.Property | RenameTargets.Delegate |
                 RenameTargets.Field | RenameTargets.Variable,
-                RenameCasePattern.UpperCamelCase).VisitLibrary(driver.ASTContext);
+                RenameCasePattern.UpperCamelCase).VisitLibrary(driver.Context.ASTContext);
 
             var qChar = lib.FindCompleteClass("QChar");
             var op = qChar.FindOperator(CXXOperatorKind.ExplicitConversion)
@@ -203,18 +235,18 @@ public void Postprocess(Driver driver, ASTContext lib)
 
         public void Setup(Driver driver)
         {
+            driver.ParserOptions.MicrosoftMode = false;
+            driver.ParserOptions.NoBuiltinIncludes = true;
+            driver.ParserOptions.TargetTriple = this.qtInfo.Target;
+            driver.ParserOptions.Abi = CppAbi.Itanium;
+            driver.ParserOptions.Verbose = true;
+            driver.ParserOptions.addDefines("__float128=void");
             driver.Options.GeneratorKind = GeneratorKind.CSharp;
-            driver.Options.MicrosoftMode = false;
-            driver.Options.NoBuiltinIncludes = true;
-            driver.Options.TargetTriple = this.qtInfo.Target;
-            driver.Options.Abi = CppAbi.Itanium;
-            driver.Options.Verbose = true;
             driver.Options.GenerateInterfacesForMultipleInheritance = true;
             driver.Options.GeneratePropertiesAdvanced = true;
             driver.Options.UnityBuild = true;
             driver.Options.IgnoreParseWarnings = true;
             driver.Options.CheckSymbols = true;
-            driver.Options.GenerateSingleCSharpFile = true;
             driver.Options.GenerateInlines = true;
             driver.Options.CompileCode = true;
             driver.Options.GenerateDefaultValuesForArguments = true;
@@ -266,25 +298,27 @@ public void Setup(Driver driver)
                     module.CodeFiles.Add(Path.Combine(dir, "QObject.cs"));
                     module.CodeFiles.Add(Path.Combine(dir, "QChar.cs"));
                     module.CodeFiles.Add(Path.Combine(dir, "QEvent.cs"));
-                    module.CodeFiles.Add(Path.Combine(dir, "_iobuf.cs"));
                 }
 
                 driver.Options.Modules.Add(module);
             }
 
             foreach (var systemIncludeDir in this.qtInfo.SystemIncludeDirs)
-                driver.Options.addSystemIncludeDirs(systemIncludeDir);
+                driver.ParserOptions.addSystemIncludeDirs(systemIncludeDir);
             
             if (Platform.IsMacOS)
             {
                 foreach (var frameworkDir in this.qtInfo.FrameworkDirs)
-                    driver.Options.addArguments(string.Format("-F{0}", frameworkDir));
-                driver.Options.addArguments(string.Format("-F{0}", qtInfo.Libs));
+                    driver.ParserOptions.addArguments(string.Format("-F{0}", frameworkDir));
+                driver.ParserOptions.addArguments(string.Format("-F{0}", qtInfo.Libs));
             }
 
-            driver.Options.addIncludeDirs(qtInfo.Headers);
-            
-            driver.Options.addLibraryDirs(Platform.IsWindows ? qtInfo.Bins : qtInfo.Libs);
+            driver.ParserOptions.addIncludeDirs(qtInfo.Headers);
+
+            driver.ParserOptions.addLibraryDirs(Platform.IsWindows ? qtInfo.Bins : qtInfo.Libs);
+
+            // Qt defines its own GUID with the same header guard as the system GUID, so ensure the system GUID is read first
+            driver.Project.AddFile("guiddef.h");
         }
 
         public static string GetModuleNameFromLibFile(string libFile)
@@ -299,10 +333,10 @@ public static string GetModuleNameFromLibFile(string libFile)
 
         public void SetupPasses(Driver driver)
         {
-            driver.TranslationUnitPasses.AddPass(new CompileInlinesPass(this.qtInfo.QMake, this.qtInfo.Make));
-            driver.TranslationUnitPasses.AddPass(new GenerateSignalEventsPass());
-            driver.TranslationUnitPasses.AddPass(new GenerateEventEventsPass());
-            driver.TranslationUnitPasses.AddPass(new RemoveQObjectMembersPass());
+            driver.Context.TranslationUnitPasses.AddPass(new CompileInlinesPass(this.qtInfo.QMake, this.qtInfo.Make));
+            driver.Context.TranslationUnitPasses.AddPass(new GenerateSignalEventsPass(driver.Generator));
+            driver.Context.TranslationUnitPasses.AddPass(new GenerateEventEventsPass(driver.Generator));
+            driver.Context.TranslationUnitPasses.AddPass(new RemoveQObjectMembersPass());
         }
 
         private readonly QtInfo qtInfo;
diff --git a/QtSharp/QtSharp.csproj b/QtSharp/QtSharp.csproj
diff --git a/QtSharp/_iobuf.cs b/QtSharp/_iobuf.cs
diff --git a/QtSharp/packages.config b/QtSharp/packages.config

Original file line number	Diff line number	Diff line change
`@@ -11,11 +11,16 @@ namespace QtSharp`
`11`	`11`	`{`
`12`	`12`	`public class GenerateEventEventsPass : TranslationUnitPass`
`13`	`13`	`{`
	`14`	`+ public GenerateEventEventsPass(Generator generator)`
	`15`	`+ {`
	`16`	`+ this.generator = generator;`
	`17`	`+ }`
	`18`	`+`
`14`	`19`	`public override bool VisitTranslationUnit(TranslationUnit unit)`
`15`	`20`	`{`
`16`	`21`	`if (!this.eventAdded)`
`17`	`22`	`{`
`18`		`- this.Driver.Generator.OnUnitGenerated += this.OnUnitGenerated;`
	`23`	`+ this.generator.OnUnitGenerated += this.OnUnitGenerated;`
`19`	`24`	`this.eventAdded = true;`
`20`	`25`	`}`
`21`	`26`	`return base.VisitTranslationUnit(unit);`
`@@ -78,7 +83,7 @@ public override bool VisitMethodDecl(Method method)`
`78`	`83`	`baseMethod.IsPure)`
`79`	`84`	`{`
`80`	`85`	`this.events.Add(method);`
`81`		`- this.Driver.Options.ExplicitlyPatchedVirtualFunctions.Add(method.QualifiedOriginalName);`
	`86`	`+ this.Context.Options.ExplicitlyPatchedVirtualFunctions.Add(method.QualifiedOriginalName);`
`82`	`87`	`}`
`83`	`88`	`}`
`84`	`89`	`}`
`@@ -87,5 +92,6 @@ public override bool VisitMethodDecl(Method method)`
`87`	`92`
`88`	`93`	`private bool eventAdded;`
`89`	`94`	`private readonly HashSet<Method> events = new HashSet<Method>();`
	`95`	`+ private Generator generator;`
`90`	`96`	`}`
`91`	`97`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,12 +15,18 @@ public class GenerateSignalEventsPass : TranslationUnitPass`
`15`	`15`	`{`
`16`	`16`	`private bool eventAdded;`
`17`	`17`	`private readonly HashSet<Event> events = new HashSet<Event>();`
	`18`	`+ private Generator generator;`
	`19`	`+`
	`20`	`+ public GenerateSignalEventsPass(Generator generator)`
	`21`	`+ {`
	`22`	`+ this.generator = generator;`
	`23`	`+ }`
`18`	`24`
`19`	`25`	`public override bool VisitTranslationUnit(TranslationUnit unit)`
`20`	`26`	`{`
`21`	`27`	`if (!this.eventAdded)`
`22`	`28`	`{`
`23`		`- this.Driver.Generator.OnUnitGenerated += this.OnUnitGenerated;`
	`29`	`+ this.generator.OnUnitGenerated += this.OnUnitGenerated;`
`24`	`30`	`this.eventAdded = true;`
`25`	`31`	`}`
`26`	`32`	`return base.VisitTranslationUnit(unit);`
`@@ -115,7 +121,7 @@ from e in @event.Parameters`
`115`	`121`	`var qtMetacall = (`
`116`	`122`	`from template in generatorOutput.Templates`
`117`	`123`	`from block in template.FindBlocks(CSharpBlockKind.Method)`
`118`		`- where block.Declaration != null && block.Declaration.Name == "Qt_metacall" &&`
	`124`	`+ where block.Declaration != null && block.Declaration.Name == "QtMetacall" &&`
`119`	`125`	`block.Declaration.Namespace.Name == "QObject"`
`120`	`126`	`select block).FirstOrDefault();`
`121`	`127`	`if (qtMetacall != null)`
`@@ -147,7 +153,7 @@ public override bool VisitClassDecl(Class @class)`
`147`	`153`	`var qtMetaCall = @class.FindMethod("qt_metacall");`
`148`	`154`	`if (qtMetaCall != null)`
`149`	`155`	`{`
`150`		`- this.Driver.Options.ExplicitlyPatchedVirtualFunctions.Add(qtMetaCall.QualifiedOriginalName);`
	`156`	`+ this.Context.Options.ExplicitlyPatchedVirtualFunctions.Add(qtMetaCall.QualifiedOriginalName);`
`151`	`157`	`}`
`152`	`158`	`return true;`
`153`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -24,15 +24,15 @@ public override string CSharpSignature(CSharpTypePrinterContext ctx)`
`24`	`24`	`return this.CSharpSignatureType(ctx).ToString();`
`25`	`25`	`}`
`26`	`26`
`27`		`- public override void CSharpMarshalToNative(MarshalContext ctx)`
	`27`	`+ public override void CSharpMarshalToNative(CSharpMarshalContext ctx)`
`28`	`28`	`{`
`29`	`29`	`if (ctx.Parameter.Type.Desugar().IsAddress())`
`30`	`30`	`ctx.Return.Write("new global::System.IntPtr(&{0})", ctx.Parameter.Name);`
`31`	`31`	`else`
`32`	`32`	`ctx.Return.Write(ctx.Parameter.Name);`
`33`	`33`	`}`
`34`	`34`
`35`		`- public override void CSharpMarshalToManaged(MarshalContext ctx)`
	`35`	`+ public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)`
`36`	`36`	`{`
`37`	`37`	`if (ctx.ReturnType.Type.Desugar().IsAddress())`
`38`	`38`	`{`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,5 @@`
`1`	`1`	`using CppSharp.AST;`
`2`	`2`	`using CppSharp.AST.Extensions;`
`3`		`-using CppSharp.Generators;`
`4`	`3`	`using CppSharp.Generators.CSharp;`
`5`	`4`	`using CppSharp.Types;`
`6`	`5`
`@@ -13,12 +12,12 @@ public override string CSharpSignature(CSharpTypePrinterContext ctx)`
`13`	`12`	`{`
`14`	`13`	`if (ctx.CSharpKind == CSharpTypePrinterContextKind.Native)`
`15`	`14`	`{`
`16`		`- return ctx.Type.IsAddress() ? "QtCore.QString.Internal*" : "QtCore.QString.Internal";`
	`15`	`+ return string.Format("QtCore.QString.{0}{1}", Helpers.InternalStruct, ctx.Type.IsAddress() ? "*" : string.Empty);`
`17`	`16`	`}`
`18`	`17`	`return "string";`
`19`	`18`	`}`
`20`	`19`
`21`		`- public override void CSharpMarshalToNative(MarshalContext ctx)`
	`20`	`+ public override void CSharpMarshalToNative(CSharpMarshalContext ctx)`
`22`	`21`	`{`
`23`	`22`	`ctx.SupportBefore.WriteLine("var __stringPtr{0} = ReferenceEquals({1}, null) ? null : (ushort*) Marshal.StringToHGlobalUni({1}).ToPointer();",`
`24`	`23`	`ctx.ParameterIndex, ctx.Parameter.Name);`
`@@ -37,13 +36,13 @@ public override void CSharpMarshalToNative(MarshalContext ctx)`
`37`	`36`	`{`
`38`	`37`	`this.Type.TryGetClass(out @class);`
`39`	`38`	`}`
`40`		`- this.typePrinter = this.typePrinter ?? (this.typePrinter = new CSharpTypePrinter(ctx.Driver));`
	`39`	`+ this.typePrinter = this.typePrinter ?? (this.typePrinter = new CSharpTypePrinter(ctx.Context));`
`41`	`40`	`var qualifiedIdentifier = (@class.OriginalClass ?? @class).Visit(this.typePrinter);`
`42`		`- ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.Internal() : ({1}.Internal) (__qstring{0}.{2})",`
`43`		`- ctx.ParameterIndex, qualifiedIdentifier, Helpers.InstanceIdentifier);`
	`41`	`+ ctx.Return.Write("ReferenceEquals(__qstring{0}, null) ? new {1}.{2}() : ({1}.{2}) (__qstring{0}.{3})",`
	`42`	`+ ctx.ParameterIndex, qualifiedIdentifier, Helpers.InternalStruct, Helpers.InstanceIdentifier);`
`44`	`43`	`}`
`45`	`44`
`46`		`- public override void CSharpMarshalToManaged(MarshalContext ctx)`
	`45`	`+ public override void CSharpMarshalToManaged(CSharpMarshalContext ctx)`
`47`	`46`	`{`
`48`	`47`	`ctx.Return.Write("Marshal.PtrToStringUni(new IntPtr(QtCore.QString.{0}({1}).Utf16))",`
`49`	`48`	`Helpers.CreateInstanceIdentifier, ctx.ReturnVarName);`