Merged the libraries for inlines and templates into one.

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

src/AST/Module.cs

@@ -37,38 +37,21 @@ namespace CppSharp.AST
             set { sharedLibraryName = value; }
         }
 
-        public string InlinesLibraryName
+        public string SymbolsLibraryName
         {
             get
             {
-                if (string.IsNullOrEmpty(inlinesLibraryName))
+                if (string.IsNullOrEmpty(symbolsLibraryName))
                 {
                     if (string.IsNullOrEmpty(OutputNamespace))
-                        return string.Format("{0}-inlines", LibraryName);
+                        return string.Format("{0}-symbols", LibraryName);
 
-                    return string.Format("{0}-inlines", OutputNamespace);
+                    return string.Format("{0}-symbols", OutputNamespace);
                 }
 
-                return inlinesLibraryName;
+                return symbolsLibraryName;
             }
-            set { inlinesLibraryName = value; }
-        }
-
-        public string TemplatesLibraryName
-        {
-            get
-            {
-                if (string.IsNullOrEmpty(templatesLibraryName))
-                {
-                    if (string.IsNullOrEmpty(OutputNamespace))
-                        return string.Format("{0}-templates", LibraryName);
-
-                    return string.Format("{0}-templates", OutputNamespace);
-                }
-
-                return templatesLibraryName;
-            }
-            set { templatesLibraryName = value; }
+            set { symbolsLibraryName = value; }
         }
 
         public string LibraryName { get; set; }
@@ -76,7 +59,7 @@ namespace CppSharp.AST
         public override string ToString() => LibraryName;
 
         private string sharedLibraryName;
-        private string inlinesLibraryName;
+        private string symbolsLibraryName;
         private string templatesLibraryName;
     }
 }

src/Generator/Driver.cs

@@ -288,9 +288,8 @@ namespace CppSharp
             if (Options.IsCSharpGenerator)
             {
                 if (!ParserOptions.IsMicrosoftAbi)
-                    TranslationUnitPasses.AddPass(new GenerateInlinesPass());
+                    TranslationUnitPasses.AddPass(new GenerateSymbolsPass());
                 TranslationUnitPasses.AddPass(new TrimSpecializationsPass());
-                TranslationUnitPasses.AddPass(new GenerateTemplatesCodePass());
             }
 
             library.SetupPasses(this);

src/Generator/Generators/CSharp/CSharpSources.cs

@@ -3106,7 +3106,7 @@ namespace CppSharp.Generators.CSharp
         private string GetLibraryOf(Declaration declaration)
         {
             if (declaration.TranslationUnit.IsSystemHeader)
-                return Context.Options.SystemModule.TemplatesLibraryName;
+                return Context.Options.SystemModule.SymbolsLibraryName;
 
             string libName = declaration.TranslationUnit.Module.SharedLibraryName;
 

src/Generator/Options.cs

@@ -113,18 +113,11 @@ namespace CppSharp
             set { MainModule.LibraryName = value; }
         }
 
-        [Obsolete("Use Modules and Module.InlinesLibraryName instead.")]
-        public string InlinesLibraryName
+        [Obsolete("Use Modules and Module.SymbolsLibraryName instead.")]
+        public string SymbolsLibraryName
         {
-            get { return MainModule.InlinesLibraryName; }
-            set { MainModule.InlinesLibraryName = value; }
-        }
-
-        [Obsolete("Use Modules and Module.TemplatesLibraryName instead.")]
-        public string TemplatesLibraryName
-        {
-            get { return MainModule.TemplatesLibraryName; }
-            set { MainModule.TemplatesLibraryName = value; }
+            get { return MainModule.SymbolsLibraryName; }
+            set { MainModule.SymbolsLibraryName = value; }
         }
 
         public Module AddModule(string libraryName)

src/Generator/Passes/GenerateSymbolsPass.cs

@@ -9,9 +9,9 @@ using CppSharp.Utils;
 
 namespace CppSharp.Passes
 {
-    public class GenerateInlinesPass : TranslationUnitPass
+    public class GenerateSymbolsPass : TranslationUnitPass
     {
-        public GenerateInlinesPass()
+        public GenerateSymbolsPass()
         {
             VisitOptions.VisitClassBases = false;
             VisitOptions.VisitClassFields = false;
@@ -31,33 +31,33 @@ namespace CppSharp.Passes
             var result = base.VisitASTContext(context);
             var findSymbolsPass = Context.TranslationUnitPasses.FindPass<FindSymbolsPass>();
             findSymbolsPass.Wait = true;
-            GenerateInlines();
+            GenerateSymbols();
             return result;
         }
 
-        public event EventHandler<InlinesCodeEventArgs> InlinesCodeGenerated;
+        public event EventHandler<SymbolsCodeEventArgs> SymbolsCodeGenerated;
 
-        private void GenerateInlines()
+        private void GenerateSymbols()
         {
             var modules = (from module in Options.Modules
-                           where inlinesCodeGenerators.ContainsKey(module)
+                           where symbolsCodeGenerators.ContainsKey(module)
                            select module).ToList();
             remainingCompilationTasks = modules.Count;
             foreach (var module in modules)
             {
-                var inlinesCodeGenerator = inlinesCodeGenerators[module];
-                var cpp = $"{module.InlinesLibraryName}.{inlinesCodeGenerator.FileExtension}";
+                var symbolsCodeGenerator = symbolsCodeGenerators[module];
+                var cpp = $"{module.SymbolsLibraryName}.{symbolsCodeGenerator.FileExtension}";
                 Directory.CreateDirectory(Options.OutputDir);
                 var path = Path.Combine(Options.OutputDir, cpp);
-                File.WriteAllText(path, inlinesCodeGenerator.Generate());
+                File.WriteAllText(path, symbolsCodeGenerator.Generate());
 
-                var e = new InlinesCodeEventArgs(module);
-                InlinesCodeGenerated?.Invoke(this, e);
+                var e = new SymbolsCodeEventArgs(module);
+                SymbolsCodeGenerated?.Invoke(this, e);
                 if (string.IsNullOrEmpty(e.CustomCompiler))
                     RemainingCompilationTasks--;
                 else
                     InvokeCompiler(e.CustomCompiler, e.CompilerArguments,
-                        e.OutputDir, module.InlinesLibraryName);
+                        e.OutputDir, module.SymbolsLibraryName);
             }
         }
 
@@ -69,20 +69,20 @@ namespace CppSharp.Passes
             var module = function.TranslationUnit.Module;
             if (module == Options.SystemModule)
             {
-                GetInlinesCodeGenerator(module);
+                GetSymbolsCodeGenerator(module);
                 return false;
             }
 
             if (!NeedsSymbol(function))
                 return false;
 
-            var inlinesCodeGenerator = GetInlinesCodeGenerator(module);
-            return function.Visit(inlinesCodeGenerator);
+            var symbolsCodeGenerator = GetSymbolsCodeGenerator(module);
+            return function.Visit(symbolsCodeGenerator);
         }
 
-        public class InlinesCodeEventArgs : EventArgs
+        public class SymbolsCodeEventArgs : EventArgs
         {
-            public InlinesCodeEventArgs(Module module)
+            public SymbolsCodeEventArgs(Module module)
             {
                 this.Module = module;
             }
@@ -107,19 +107,19 @@ namespace CppSharp.Passes
                 !Context.Symbols.FindSymbol(ref mangled);
         }
 
-        private InlinesCodeGenerator GetInlinesCodeGenerator(Module module)
+        private SymbolsCodeGenerator GetSymbolsCodeGenerator(Module module)
         {
-            if (inlinesCodeGenerators.ContainsKey(module))
-                return inlinesCodeGenerators[module];
+            if (symbolsCodeGenerators.ContainsKey(module))
+                return symbolsCodeGenerators[module];
             
-            var inlinesCodeGenerator = new InlinesCodeGenerator(Context, module.Units);
-            inlinesCodeGenerators[module] = inlinesCodeGenerator;
-            inlinesCodeGenerator.Process();
+            var symbolsCodeGenerator = new SymbolsCodeGenerator(Context, module.Units);
+            symbolsCodeGenerators[module] = symbolsCodeGenerator;
+            symbolsCodeGenerator.Process();
 
-            return inlinesCodeGenerator;
+            return symbolsCodeGenerator;
         }
 
-        private void InvokeCompiler(string compiler, string arguments, string outputDir, string inlines)
+        private void InvokeCompiler(string compiler, string arguments, string outputDir, string symbols)
         {
             new Thread(() =>
                 {
@@ -127,20 +127,20 @@ namespace CppSharp.Passes
                     string errorMessage;
                     ProcessHelper.Run(compiler, arguments, out error, out errorMessage);
                     if (string.IsNullOrEmpty(errorMessage))
-                        CollectInlinedSymbols(outputDir, inlines);
+                        CollectSymbols(outputDir, symbols);
                     else
                         Diagnostics.Error(errorMessage);
                     RemainingCompilationTasks--;
                 }).Start();
         }
 
-        private void CollectInlinedSymbols(string outputDir, string inlines)
+        private void CollectSymbols(string outputDir, string symbols)
         {
             using (var parserOptions = new ParserOptions())
             {
                 parserOptions.AddLibraryDirs(outputDir);
                 var output = Path.GetFileName($@"{(Platform.IsWindows ?
-                    string.Empty : "lib")}{inlines}.{
+                    string.Empty : "lib")}{symbols}.{
                     (Platform.IsMacOS ? "dylib" : Platform.IsWindows ? "dll" : "so")}");
                 parserOptions.LibraryFile = output;
                 using (var parserResult = Parser.ClangParser.ParseLibrary(parserOptions))
@@ -181,7 +181,7 @@ namespace CppSharp.Passes
         private int remainingCompilationTasks;
         private static readonly object @lock = new object();
 
-        private Dictionary<Module, InlinesCodeGenerator> inlinesCodeGenerators =
-            new Dictionary<Module, InlinesCodeGenerator>();
+        private Dictionary<Module, SymbolsCodeGenerator> symbolsCodeGenerators =
+            new Dictionary<Module, SymbolsCodeGenerator>();
     }
 }

src/Generator/Passes/GenerateTemplatesCodePass.cs

@@ -1,67 +0,0 @@
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Text;
-using CppSharp.AST;
-
-namespace CppSharp.Passes
-{
-    public class GenerateTemplatesCodePass : TranslationUnitPass
-    {
-        public override bool VisitASTContext(ASTContext context)
-        {
-            base.VisitASTContext(context);
-            WriteTemplateInstantiations();
-            return true;
-        }
-
-        public override bool VisitClassDecl(Class @class)
-        {
-            if (!base.VisitClassDecl(@class) || !@class.IsDependent)
-                return false;
-
-            var cppTypePrinter = new CppTypePrinter
-            {
-                PrintScopeKind = TypePrintScopeKind.Qualified,
-                PrintLogicalNames = true
-            };
-            foreach (var specialization in @class.Specializations.Where(s => !s.IsDependent && !s.Ignore))
-            {
-                var cppCode = specialization.Visit(cppTypePrinter);
-                var module = specialization.TranslationUnit.Module;
-                if (templateInstantiations.ContainsKey(module))
-                    templateInstantiations[module].Add(cppCode);
-                else
-                    templateInstantiations.Add(module, new HashSet<string> { cppCode });
-            }
-            return true;
-        }
-
-        private void WriteTemplateInstantiations()
-        {
-            foreach (var module in Options.Modules.Where(m => templateInstantiations.ContainsKey(m)))
-            {
-                var cppBuilder = new StringBuilder();
-                if (module == Options.SystemModule)
-                {
-                    cppBuilder.Append("#include <string>\n");
-                    cppBuilder.Append("#include <vector>\n");
-                    cppBuilder.Append("#include <map>\n");
-                    cppBuilder.Append("#include <unordered_map>\n");
-                }
-                else
-                    foreach (var header in module.Headers)
-                        cppBuilder.AppendFormat("#include <{0}>\n", header);
-                foreach (var templateInstantiation in templateInstantiations[module])
-                    cppBuilder.AppendFormat("\ntemplate class {0}{1};",
-                        Platform.IsWindows ? "__declspec(dllexport) " : string.Empty, templateInstantiation);
-                var cpp = string.Format("{0}.cpp", module.TemplatesLibraryName);
-                Directory.CreateDirectory(Options.OutputDir);
-                var path = Path.Combine(Options.OutputDir, cpp);
-                File.WriteAllText(path, cppBuilder.ToString());
-            }
-        }
-
-        private Dictionary<Module, HashSet<string>> templateInstantiations = new Dictionary<Module, HashSet<string>>();
-    }
-}

src/Generator/Passes/SymbolsCodeGenerator.cs

@@ -7,11 +7,11 @@ using CppSharp.Generators;
 
 namespace CppSharp.Passes
 {
-    public class InlinesCodeGenerator : CodeGenerator
+    public class SymbolsCodeGenerator : CodeGenerator
     {
         public override string FileExtension => "cpp";
 
-        public InlinesCodeGenerator(BindingContext context, IEnumerable<TranslationUnit> units)
+        public SymbolsCodeGenerator(BindingContext context, IEnumerable<TranslationUnit> units)
             : base(context, units)
         {
         }
@@ -46,11 +46,11 @@ namespace CppSharp.Passes
 
         private string GetWrapper(Module module)
         {
-            var inlinesLibraryName = new StringBuilder(module.InlinesLibraryName);
-            for (int i = 0; i < inlinesLibraryName.Length; i++)
-                if (!char.IsLetterOrDigit(inlinesLibraryName[i]))
-                    inlinesLibraryName[i] = '_';
-            return $"{inlinesLibraryName}{++functionCount}";
+            var symbolsLibraryName = new StringBuilder(module.SymbolsLibraryName);
+            for (int i = 0; i < symbolsLibraryName.Length; i++)
+                if (!char.IsLetterOrDigit(symbolsLibraryName[i]))
+                    symbolsLibraryName[i] = '_';
+            return $"{symbolsLibraryName}{++functionCount}";
         }
 
         private static string GetDerivedType(string @namespace, string wrapper)