Fix/parser improvements (#1919)

* Parser improvements

* Fix AST Converter missing conversion data

* Fix bug in test code

Can't return `T();` if `T` is a const reference type.

* Fix other test compile bug

It's kinda weird to call it pure virtual and then implement it anyway no?

* Fix test compiler error

Don't skip function bodies to force template instantiations

* Fix clang assert

src/CppParser/Bootstrap/StmtCodeGenerators.cs

@@ -341,8 +341,20 @@ namespace CppSharp
                 WriteLine($"_S->{fieldName} = static_cast<AST::{typeName}>(" +
                     $"WalkStatement(S->{methodName}()));");
             else if (typeName.Contains("Expr"))
-                WriteLine($"_S->{fieldName} = static_cast<AST::{typeName}>(" +
-                    $"WalkExpression(S->{methodName}()));");
+            {
+                var expr = $"_S->{fieldName} = static_cast<AST::{typeName}>(WalkExpression(S->{methodName}()));";
+
+                if (fieldName == "base" && typeName is "CXXDependentScopeMemberExpr")
+                {
+                    // Clang asserts that 'getBase()' is not called when 'isImplicitAccess()' returns true
+                    WriteLine("if (!S->isImplicitAccess())");
+                    WriteLineIndent(expr);
+                }
+                else
+                {
+                    WriteLine(expr);
+                }
+            }
             else if (fieldName == "guidDecl")
                 WriteLine($"_S->{fieldName} = S->getGuidDecl()->getNameAsString();");
             else if (typeName.Contains("Decl") || typeName.Contains("Method") ||

src/CppParser/ParseExpr.cpp

@@ -2426,7 +2426,8 @@ AST::Expr* Parser::WalkExpression(const clang::Expr* Expr)
         _S->refersToMatrixElement = S->refersToMatrixElement();
         _S->hasPlaceholderType = S->hasPlaceholderType();
         _S->isImplicitAccess = S->isImplicitAccess();
-        _S->base = static_cast<AST::Expr*>(WalkExpression(S->getBase()));
+        if (!S->isImplicitAccess())
+            _S->base = static_cast<AST::Expr*>(WalkExpression(S->getBase()));
         _S->baseType = GetQualifiedType(S->getBaseType());
         _S->isArrow = S->isArrow();
         _S->firstQualifierFoundInScope = static_cast<AST::Declaration*>(WalkDeclaration(S->getFirstQualifierFoundInScope()));

src/CppParser/Parser.cpp

@@ -165,6 +165,12 @@ Parser::Parser(CppParserOptions* Opts)
 {
     supportedStdTypes.insert("allocator");
     supportedStdTypes.insert("basic_string");
+
+    walkedNamespaces.reserve(8192);
+    walkedTypeTemplateParameters.reserve(8192);
+    walkedTemplateTemplateParameters.reserve(32);
+    walkedNonTypeTemplateParameters.reserve(1024);
+    walkedParameters.reserve(65536);
 }
 
 LayoutField Parser::WalkVTablePointer(Class* Class,
@@ -424,27 +430,23 @@ void Parser::Setup(bool Compile)
     if (opts->verbose)
         HSOpts.Verbose = true;
 
-    for (unsigned I = 0, E = opts->IncludeDirs.size(); I != E; ++I)
+    for (const auto& s : opts->IncludeDirs)
     {
-        const auto& s = opts->IncludeDirs[I];
         HSOpts.AddPath(s, frontend::Angled, false, false);
     }
 
-    for (unsigned I = 0, E = opts->SystemIncludeDirs.size(); I != E; ++I)
+    for (const auto& s : opts->SystemIncludeDirs)
     {
-        const auto& s = opts->SystemIncludeDirs[I];
         HSOpts.AddPath(s, frontend::System, false, false);
     }
 
-    for (unsigned I = 0, E = opts->Defines.size(); I != E; ++I)
+    for (const auto& define : opts->Defines)
     {
-        const auto& define = opts->Defines[I];
         PPOpts.addMacroDef(define);
     }
 
-    for (unsigned I = 0, E = opts->Undefines.size(); I != E; ++I)
+    for (const auto& undefine : opts->Undefines)
     {
-        const auto& undefine = opts->Undefines[I];
         PPOpts.addMacroUndef(undefine);
     }
 
@@ -480,8 +482,7 @@ void Parser::Setup(bool Compile)
         }
     }
 
-    if (TC)
-        delete TC;
+    delete TC;
 
     // Enable preprocessing record.
     PPOpts.DetailedRecord = true;
@@ -2537,7 +2538,7 @@ Type* Parser::WalkType(clang::QualType QualType, const clang::TypeLoc* TL, bool
             EnumDecl* ED = ET->getDecl();
 
             auto TT = new AST::TagType();
-            TT->declaration = TT->declaration = WalkDeclaration(ED);
+            TT->declaration = WalkDeclaration(ED);
 
             Ty = TT;
             break;
@@ -4430,8 +4431,8 @@ Declaration* Parser::WalkDeclaration(const clang::Decl* D)
         {
             auto MD = cast<CXXMethodDecl>(D);
             Decl = WalkMethodCXX(MD);
-            if (Decl == nullptr)
-                return Decl;
+            if (!Decl)
+                return nullptr;
 
             auto NS = GetNamespace(MD);
             Decl->_namespace = NS;
@@ -4609,7 +4610,7 @@ void Parser::SetupLLVMCodegen()
                                                 c->getHeaderSearchOpts(), c->getPreprocessorOpts(),
                                                 c->getCodeGenOpts(), *LLVMModule, c->getDiagnostics()));
 
-    codeGenTypes.reset(new clang::CodeGen::CodeGenTypes(*CGM.get()));
+    codeGenTypes.reset(new clang::CodeGen::CodeGenTypes(*CGM));
 }
 
 bool Parser::SetupSourceFiles(const std::vector<std::string>& SourceFiles,
@@ -4710,7 +4711,7 @@ ParserResult* Parser::Parse(const std::vector<std::string>& SourceFiles)
 
     DiagClient->BeginSourceFile(c->getLangOpts(), &c->getPreprocessor());
 
-    ParseAST(c->getSema());
+    ParseAST(c->getSema(), opts->verbose, opts->skipFunctionBodies);
 
     DiagClient->EndSourceFile();
 

src/Generator/Passes/SymbolsCodeGenerator.cs

@@ -162,8 +162,7 @@ namespace CppSharp.Passes
             bool isAbstract = ((Class)method.Namespace).IsAbstract;
             if (method.Access == AccessSpecifier.Protected || isAbstract)
             {
-                Write($@"{{ ::new ({Helpers.InstanceField}) {
-                    wrapper}{method.Namespace.Name}({@params}); }}");
+                Write($@"{{ ::new ({Helpers.InstanceField}) {wrapper}{method.Namespace.Name}({@params}); }}");
                 WriteLine(!isAbstract ? " };" : string.Empty);
             }
             else
@@ -210,12 +209,10 @@ namespace CppSharp.Passes
             {
                 string @class = wrapper + method.Namespace.Name;
                 WriteLine($"() {{ this->~{@class}(); }} }};");
-                Write($@"extern ""C"" {GetExporting()}void {wrapper}({
-                    @class}* {instance}) {{ {instance}->{wrapper}Protected");
+                Write($@"extern ""C"" {GetExporting()}void {wrapper}({@class}* {instance}) {{ {instance}->{wrapper}Protected");
             }
             else
-                Write($@"({$"{@namespace}*{instance}"}) {{ {
-                    instance}->~{method.Namespace.Name}");
+                Write($@"({$"{@namespace}*{instance}"}) {{ {instance}->~{method.Namespace.Name}");
             WriteLine("(); }");
         }
 
@@ -238,8 +235,7 @@ namespace CppSharp.Passes
 
             var method = function as Method;
             if (function.Namespace.Access == AccessSpecifier.Protected)
-                Write($@"class {wrapper}{function.Namespace.Name} : public {
-                    function.Namespace.Namespace.Visit(cppTypePrinter)} {{ ");
+                Write($@"class {wrapper}{function.Namespace.Name} : public {function.Namespace.Namespace.Visit(cppTypePrinter)} {{ ");
 
             string variable = $@"({(method?.IsStatic == false ?
                 (@namespace + "::") : string.Empty)}*{wrapper}){signature}";

src/Parser/ASTConverter.cs

@@ -41,100 +41,100 @@ namespace CppSharp
             switch (type.Kind)
             {
                 case TypeKind.Tag:
-                    {
-                        var _type = TagType.__CreateInstance(type.__Instance);
-                        return VisitTag(_type);
-                    }
+                {
+                    var _type = TagType.__CreateInstance(type.__Instance);
+                    return VisitTag(_type);
+                }
                 case TypeKind.Array:
-                    {
-                        var _type = ArrayType.__CreateInstance(type.__Instance);
-                        return VisitArray(_type);
-                    }
+                {
+                    var _type = ArrayType.__CreateInstance(type.__Instance);
+                    return VisitArray(_type);
+                }
                 case TypeKind.Function:
-                    {
-                        var _type = FunctionType.__CreateInstance(type.__Instance);
-                        return VisitFunction(_type);
-                    }
+                {
+                    var _type = FunctionType.__CreateInstance(type.__Instance);
+                    return VisitFunction(_type);
+                }
                 case TypeKind.Pointer:
-                    {
-                        var _type = PointerType.__CreateInstance(type.__Instance);
-                        return VisitPointer(_type);
-                    }
+                {
+                    var _type = PointerType.__CreateInstance(type.__Instance);
+                    return VisitPointer(_type);
+                }
                 case TypeKind.MemberPointer:
-                    {
-                        var _type = MemberPointerType.__CreateInstance(type.__Instance);
-                        return VisitMemberPointer(_type);
-                    }
+                {
+                    var _type = MemberPointerType.__CreateInstance(type.__Instance);
+                    return VisitMemberPointer(_type);
+                }
                 case TypeKind.Typedef:
-                    {
-                        var _type = TypedefType.__CreateInstance(type.__Instance);
-                        return VisitTypedef(_type);
-                    }
+                {
+                    var _type = TypedefType.__CreateInstance(type.__Instance);
+                    return VisitTypedef(_type);
+                }
                 case TypeKind.Attributed:
-                    {
-                        var _type = AttributedType.__CreateInstance(type.__Instance);
-                        return VisitAttributed(_type);
-                    }
+                {
+                    var _type = AttributedType.__CreateInstance(type.__Instance);
+                    return VisitAttributed(_type);
+                }
                 case TypeKind.Decayed:
-                    {
-                        var _type = DecayedType.__CreateInstance(type.__Instance);
-                        return VisitDecayed(_type);
-                    }
+                {
+                    var _type = DecayedType.__CreateInstance(type.__Instance);
+                    return VisitDecayed(_type);
+                }
                 case TypeKind.TemplateSpecialization:
-                    {
-                        var _type = TemplateSpecializationType.__CreateInstance(type.__Instance);
-                        return VisitTemplateSpecialization(_type);
-                    }
+                {
+                    var _type = TemplateSpecializationType.__CreateInstance(type.__Instance);
+                    return VisitTemplateSpecialization(_type);
+                }
                 case TypeKind.DependentTemplateSpecialization:
-                    {
-                        var _type = DependentTemplateSpecializationType.__CreateInstance(type.__Instance);
-                        return VisitDependentTemplateSpecialization(_type);
-                    }
+                {
+                    var _type = DependentTemplateSpecializationType.__CreateInstance(type.__Instance);
+                    return VisitDependentTemplateSpecialization(_type);
+                }
                 case TypeKind.TemplateParameter:
-                    {
-                        var _type = TemplateParameterType.__CreateInstance(type.__Instance);
-                        return VisitTemplateParameter(_type);
-                    }
+                {
+                    var _type = TemplateParameterType.__CreateInstance(type.__Instance);
+                    return VisitTemplateParameter(_type);
+                }
                 case TypeKind.TemplateParameterSubstitution:
-                    {
-                        var _type = TemplateParameterSubstitutionType.__CreateInstance(type.__Instance);
-                        return VisitTemplateParameterSubstitution(_type);
-                    }
+                {
+                    var _type = TemplateParameterSubstitutionType.__CreateInstance(type.__Instance);
+                    return VisitTemplateParameterSubstitution(_type);
+                }
                 case TypeKind.InjectedClassName:
-                    {
-                        var _type = InjectedClassNameType.__CreateInstance(type.__Instance);
-                        return VisitInjectedClassName(_type);
-                    }
+                {
+                    var _type = InjectedClassNameType.__CreateInstance(type.__Instance);
+                    return VisitInjectedClassName(_type);
+                }
                 case TypeKind.DependentName:
-                    {
-                        var _type = DependentNameType.__CreateInstance(type.__Instance);
-                        return VisitDependentName(_type);
-                    }
+                {
+                    var _type = DependentNameType.__CreateInstance(type.__Instance);
+                    return VisitDependentName(_type);
+                }
                 case TypeKind.Builtin:
-                    {
-                        var _type = BuiltinType.__CreateInstance(type.__Instance);
-                        return VisitBuiltin(_type);
-                    }
+                {
+                    var _type = BuiltinType.__CreateInstance(type.__Instance);
+                    return VisitBuiltin(_type);
+                }
                 case TypeKind.PackExpansion:
-                    {
-                        var _type = PackExpansionType.__CreateInstance(type.__Instance);
-                        return VisitPackExpansion(_type);
-                    }
+                {
+                    var _type = PackExpansionType.__CreateInstance(type.__Instance);
+                    return VisitPackExpansion(_type);
+                }
                 case TypeKind.UnaryTransform:
-                    {
-                        var _type = UnaryTransformType.__CreateInstance(type.__Instance);
-                        return VisitUnaryTransform(_type);
-                    }
+                {
+                    var _type = UnaryTransformType.__CreateInstance(type.__Instance);
+                    return VisitUnaryTransform(_type);
+                }
                 case TypeKind.UnresolvedUsing:
-                    {
-                        var _type = UnresolvedUsingType.__CreateInstance(type.__Instance);
-                        return VisitUnresolvedUsing(_type);
-                    }
+                {
+                    var _type = UnresolvedUsingType.__CreateInstance(type.__Instance);
+                    return VisitUnresolvedUsing(_type);
+                }
                 case TypeKind.Vector:
-                    {
-                        var _type = VectorType.__CreateInstance(type.__Instance);
-                        return VisitVector(_type);
-                    }
+                {
+                    var _type = VectorType.__CreateInstance(type.__Instance);
+                    return VisitVector(_type);
+                }
             }
 
             throw new ArgumentOutOfRangeException();
@@ -182,135 +182,135 @@ namespace CppSharp
             switch (decl.Kind)
             {
                 case DeclarationKind.TranslationUnit:
-                    {
-                        var _decl = TranslationUnit.__CreateInstance(decl.__Instance);
-                        return VisitTranslationUnit(_decl);
-                    }
+                {
+                    var _decl = TranslationUnit.__CreateInstance(decl.__Instance);
+                    return VisitTranslationUnit(_decl);
+                }
                 case DeclarationKind.Namespace:
-                    {
-                        var _decl = Namespace.__CreateInstance(decl.__Instance);
-                        return VisitNamespace(_decl);
-                    }
+                {
+                    var _decl = Namespace.__CreateInstance(decl.__Instance);
+                    return VisitNamespace(_decl);
+                }
                 case DeclarationKind.Typedef:
-                    {
-                        var _decl = TypedefDecl.__CreateInstance(decl.__Instance);
-                        return VisitTypedef(_decl);
-                    }
+                {
+                    var _decl = TypedefDecl.__CreateInstance(decl.__Instance);
+                    return VisitTypedef(_decl);
+                }
                 case DeclarationKind.TypeAlias:
-                    {
-                        var _decl = TypeAlias.__CreateInstance(decl.__Instance);
-                        return VisitTypeAlias(_decl);
-                    }
+                {
+                    var _decl = TypeAlias.__CreateInstance(decl.__Instance);
+                    return VisitTypeAlias(_decl);
+                }
                 case DeclarationKind.Parameter:
-                    {
-                        var _decl = Parameter.__CreateInstance(decl.__Instance);
-                        return VisitParameter(_decl);
-                    }
+                {
+                    var _decl = Parameter.__CreateInstance(decl.__Instance);
+                    return VisitParameter(_decl);
+                }
                 case DeclarationKind.Function:
-                    {
-                        var _decl = Function.__CreateInstance(decl.__Instance);
-                        return VisitFunction(_decl);
-                    }
+                {
+                    var _decl = Function.__CreateInstance(decl.__Instance);
+                    return VisitFunction(_decl);
+                }
                 case DeclarationKind.Method:
-                    {
-                        var _decl = Method.__CreateInstance(decl.__Instance);
-                        return VisitMethod(_decl);
-                    }
+                {
+                    var _decl = Method.__CreateInstance(decl.__Instance);
+                    return VisitMethod(_decl);
+                }
                 case DeclarationKind.Enumeration:
-                    {
-                        var _decl = Enumeration.__CreateInstance(decl.__Instance);
-                        return VisitEnumeration(_decl);
-                    }
+                {
+                    var _decl = Enumeration.__CreateInstance(decl.__Instance);
+                    return VisitEnumeration(_decl);
+                }
                 case DeclarationKind.EnumerationItem:
-                    {
-                        var _decl = Enumeration.Item.__CreateInstance(decl.__Instance);
-                        return VisitEnumerationItem(_decl);
-                    }
+                {
+                    var _decl = Enumeration.Item.__CreateInstance(decl.__Instance);
+                    return VisitEnumerationItem(_decl);
+                }
                 case DeclarationKind.Variable:
-                    {
-                        var _decl = Variable.__CreateInstance(decl.__Instance);
-                        return VisitVariable(_decl);
-                    }
+                {
+                    var _decl = Variable.__CreateInstance(decl.__Instance);
+                    return VisitVariable(_decl);
+                }
                 case DeclarationKind.VarTemplate:
-                    {
-                        var _decl = VarTemplate.__CreateInstance(decl.__Instance);
-                        return VisitVarTemplate(_decl);
-                    }
+                {
+                    var _decl = VarTemplate.__CreateInstance(decl.__Instance);
+                    return VisitVarTemplate(_decl);
+                }
                 case DeclarationKind.VarTemplateSpecialization:
-                    {
-                        var _decl = VarTemplateSpecialization.__CreateInstance(decl.__Instance);
-                        return VisitVarTemplateSpecialization(_decl);
-                    }
+                {
+                    var _decl = VarTemplateSpecialization.__CreateInstance(decl.__Instance);
+                    return VisitVarTemplateSpecialization(_decl);
+                }
                 case DeclarationKind.VarTemplatePartialSpecialization:
-                    {
-                        var _decl = VarTemplatePartialSpecialization.__CreateInstance(decl.__Instance);
-                        return VisitVarTemplatePartialSpecialization(_decl);
-                    }
+                {
+                    var _decl = VarTemplatePartialSpecialization.__CreateInstance(decl.__Instance);
+                    return VisitVarTemplatePartialSpecialization(_decl);
+                }
                 case DeclarationKind.Friend:
-                    {
-                        var _decl = Friend.__CreateInstance(decl.__Instance);
-                        return VisitFriend(_decl);
-                    }
+                {
+                    var _decl = Friend.__CreateInstance(decl.__Instance);
+                    return VisitFriend(_decl);
+                }
                 case DeclarationKind.Field:
-                    {
-                        var _decl = Field.__CreateInstance(decl.__Instance);
-                        return VisitField(_decl);
-                    }
+                {
+                    var _decl = Field.__CreateInstance(decl.__Instance);
+                    return VisitField(_decl);
+                }
                 case DeclarationKind.AccessSpecifier:
-                    {
-                        var _decl = AccessSpecifierDecl.__CreateInstance(decl.__Instance);
-                        return VisitAccessSpecifier(_decl);
-                    }
+                {
+                    var _decl = AccessSpecifierDecl.__CreateInstance(decl.__Instance);
+                    return VisitAccessSpecifier(_decl);
+                }
                 case DeclarationKind.Class:
-                    {
-                        var _decl = Class.__CreateInstance(decl.__Instance);
-                        return VisitClass(_decl);
-                    }
+                {
+                    var _decl = Class.__CreateInstance(decl.__Instance);
+                    return VisitClass(_decl);
+                }
                 case DeclarationKind.ClassTemplate:
-                    {
-                        var _decl = ClassTemplate.__CreateInstance(decl.__Instance);
-                        return VisitClassTemplate(_decl);
-                    }
+                {
+                    var _decl = ClassTemplate.__CreateInstance(decl.__Instance);
+                    return VisitClassTemplate(_decl);
+                }
                 case DeclarationKind.ClassTemplateSpecialization:
-                    {
-                        var _decl = ClassTemplateSpecialization.__CreateInstance(decl.__Instance);
-                        return VisitClassTemplateSpecialization(_decl);
-                    }
+                {
+                    var _decl = ClassTemplateSpecialization.__CreateInstance(decl.__Instance);
+                    return VisitClassTemplateSpecialization(_decl);
+                }
                 case DeclarationKind.ClassTemplatePartialSpecialization:
-                    {
-                        var _decl = ClassTemplatePartialSpecialization.__CreateInstance(decl.__Instance);
-                        return VisitClassTemplatePartialSpecialization(_decl);
-                    }
+                {
+                    var _decl = ClassTemplatePartialSpecialization.__CreateInstance(decl.__Instance);
+                    return VisitClassTemplatePartialSpecialization(_decl);
+                }
                 case DeclarationKind.FunctionTemplate:
-                    {
-                        var _decl = FunctionTemplate.__CreateInstance(decl.__Instance);
-                        return VisitFunctionTemplate(_decl);
-                    }
+                {
+                    var _decl = FunctionTemplate.__CreateInstance(decl.__Instance);
+                    return VisitFunctionTemplate(_decl);
+                }
                 case DeclarationKind.TypeAliasTemplate:
-                    {
-                        var _decl = TypeAliasTemplate.__CreateInstance(decl.__Instance);
-                        return VisitTypeAliasTemplate(_decl);
-                    }
+                {
+                    var _decl = TypeAliasTemplate.__CreateInstance(decl.__Instance);
+                    return VisitTypeAliasTemplate(_decl);
+                }
                 case DeclarationKind.TemplateTemplateParm:
-                    {
-                        var _decl = TemplateTemplateParameter.__CreateInstance(decl.__Instance);
-                        return VisitTemplateTemplateParameter(_decl);
-                    }
+                {
+                    var _decl = TemplateTemplateParameter.__CreateInstance(decl.__Instance);
+                    return VisitTemplateTemplateParameter(_decl);
+                }
                 case DeclarationKind.TemplateTypeParm:
-                    {
-                        var _decl = TypeTemplateParameter.__CreateInstance(decl.__Instance);
-                        return VisitTypeTemplateParameter(_decl);
-                    }
+                {
+                    var _decl = TypeTemplateParameter.__CreateInstance(decl.__Instance);
+                    return VisitTypeTemplateParameter(_decl);
+                }
                 case DeclarationKind.NonTypeTemplateParm:
-                    {
-                        var _decl = NonTypeTemplateParameter.__CreateInstance(decl.__Instance);
-                        return VisitNonTypeTemplateParameter(_decl);
-                    }
+                {
+                    var _decl = NonTypeTemplateParameter.__CreateInstance(decl.__Instance);
+                    return VisitNonTypeTemplateParameter(_decl);
+                }
                 case DeclarationKind.UnresolvedUsingTypename:
-                    {
-                        var _decl = UnresolvedUsingTypename.__CreateInstance(decl.__Instance);
-                        return VisitUnresolvedUsingTypename(_decl);
-                    }
+                {
+                    var _decl = UnresolvedUsingTypename.__CreateInstance(decl.__Instance);
+                    return VisitUnresolvedUsingTypename(_decl);
+                }
             }
 
             throw new ArgumentOutOfRangeException();
@@ -1833,6 +1833,8 @@ namespace CppSharp
                 var _spec = (AST.ClassTemplateSpecialization)Visit(spec);
                 _decl.Specializations.Add(_spec);
             }
+            _decl.TemplatedClass.TemplateParameters.AddRange(_decl.Parameters);
+            _decl.TemplatedClass.Specializations.AddRange(_decl.Specializations);
             return _decl;
         }
 
@@ -1927,6 +1929,7 @@ namespace CppSharp
                 var _param = Visit(param);
                 _decl.Parameters.Add(_param);
             }
+            _decl.TemplateParameters.AddRange(_decl.TemplatedDecl.Parameters);
             return _decl;
         }
 

tests/dotnet/CSharp/CSharp.Gen.cs

@@ -25,6 +25,7 @@ namespace CppSharp.Tests
             base.Setup(driver);
 
             driver.ParserOptions.UnityBuild = true;
+            driver.ParserOptions.SkipFunctionBodies = false;
             driver.ParserOptions.AddSupportedFunctionTemplates("FunctionTemplate");
 
             driver.Options.GenerateFreeStandingFunctionsClassName = t => t.FileNameWithoutExtension + "Cool";
@@ -42,7 +43,7 @@ namespace CppSharp.Tests
             driver.Options.GenerateClassTemplates = true;
 
             var disableNativeToManaged = new ClassGenerationOptions { GenerateNativeToManaged = false };
-            driver.Options.GetClassGenerationOptions = e => 
+            driver.Options.GetClassGenerationOptions = e =>
             {
                 return e.Name == "ClassWithoutNativeToManaged" ? disableNativeToManaged : null;
             };
@@ -237,16 +238,12 @@ namespace CppSharp.Tests
                 var specialization = type.GetClassTemplateSpecialization();
                 var typePrinter = new CSharpTypePrinter(null);
                 typePrinter.PushContext(TypePrinterContextKind.Native);
-                return new CustomType(string.Format($@"{
-                    specialization.Visit(typePrinter)}{
-                    (Type.IsAddress() ? "*" : string.Empty)}", specialization.Visit(typePrinter),
+                return new CustomType(string.Format($@"{specialization.Visit(typePrinter)}{(Type.IsAddress() ? "*" : string.Empty)}", specialization.Visit(typePrinter),
                     Type.IsAddress() ? "*" : string.Empty));
             }
 
             return new CustomType(
-                $@"global::System.Collections.Generic.{
-                    (ctx.MarshalKind == MarshalKind.DefaultExpression ? "List" : "IList")}<{
-                    ctx.GetTemplateParameterList()}>");
+                $@"global::System.Collections.Generic.{(ctx.MarshalKind == MarshalKind.DefaultExpression ? "List" : "IList")}<{ctx.GetTemplateParameterList()}>");
         }
 
         public override void MarshalToNative(MarshalContext ctx)
@@ -292,9 +289,7 @@ namespace CppSharp.Tests
         {
             if (ctx.Kind == TypePrinterContextKind.Native)
             {
-                return new CustomType($@"global::CSharp.QString.{
-                    Helpers.InternalStruct}{
-                    (ctx.Type.IsAddress() ? "*" : string.Empty)}");
+                return new CustomType($@"global::CSharp.QString.{Helpers.InternalStruct}{(ctx.Type.IsAddress() ? "*" : string.Empty)}");
             }
             return new CILType(typeof(string));
         }

tests/dotnet/CSharp/CSharpTemplates.h

@@ -163,9 +163,10 @@ T IndependentFields<T>::getDependent(const T& t)
 }
 
 template <typename T>
-T IndependentFields<T>::property()
+typename IndependentFields<T>::Type IndependentFields<T>::property()
 {
-    return T();
+    std::remove_reference_t<std::remove_const_t<Type>> t;
+    return t;
 }
 
 template <typename T>

tests/dotnet/Common/Common.h

@@ -790,13 +790,13 @@ public:
     virtual ~PureDtor() = 0;
 };
 
-class PureImplementedDtor
+class VirtualImplementedDtor
 {
 public:
-    virtual ~PureImplementedDtor() = 0;
+    virtual ~VirtualImplementedDtor();
 };
 
-PureImplementedDtor::~PureImplementedDtor()
+inline VirtualImplementedDtor::~VirtualImplementedDtor()
 {
 }