Enabled getting of template specialisations when type locations are invalid.

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

src/AST/ASTContext.cs

@@ -100,14 +100,28 @@ namespace CppSharp.AST
         /// Finds an existing declaration by name.
         public IEnumerable<T> FindDecl<T>(string name) where T : Declaration
         {
-            foreach (var module in TranslationUnits)
+            switch (typeof(T).Name)
             {
-                if (module.FindEnum(name) as T != null)
-                    yield return module.FindEnum(name) as T;
-                else if (module.FindClass(name) as T != null)
-                    yield return module.FindClass(name) as T;
-                else if (module.FindFunction(name) as T != null)
-                    yield return module.FindFunction(name) as T;
+                case "Enumeration":
+                    foreach (var module in TranslationUnits)
+                        yield return module.FindEnum(name) as T;
+                    break;
+                case "Class":
+                    foreach (var module in TranslationUnits)
+                        yield return module.FindClass(name) as T;
+                    break;
+                case "ClassTemplate":
+                    foreach (var module in TranslationUnits)
+                        yield return module.FindClassTemplate(name) as T;
+                    break;
+                case "Function":
+                    foreach (var module in TranslationUnits)
+                        yield return module.FindFunction(name) as T;
+                    break;
+                default:
+                    foreach (var module in TranslationUnits)
+                        yield return module.Declarations.FirstOrDefault(d => d.Name == name) as T;
+                    break;
             }
         }
 

src/CppParser/Parser.cpp

@@ -894,12 +894,17 @@ Parser::WalkClassTemplateSpecialization(clang::ClassTemplateSpecializationDecl*
     TS->TemplatedDecl = CT;
     TS->SpecializationKind = WalkTemplateSpecializationKind(CTS->getSpecializationKind());
     auto &TAL = CTS->getTemplateArgs();
-    if (auto TSI = CTS->getTypeAsWritten())
+    auto TSI = CTS->getTypeAsWritten();
+    if (TSI)
     {
         auto TL = TSI->getTypeLoc();
         auto TSL = TL.getAs<TemplateSpecializationTypeLoc>();
         TS->Arguments = WalkTemplateArgumentList(&TAL, &TSL);
     }
+    else
+    {
+        TS->Arguments = WalkTemplateArgumentList(&TAL, (clang::TemplateSpecializationTypeLoc*) 0);
+    }
     CT->Specializations.push_back(TS);
 
     if (CTS->isCompleteDefinition())

src/Generator.Tests/AST/TestAST.cs

@@ -288,5 +288,12 @@ namespace CppSharp.Generator.Tests.AST
             Assert.IsTrue(AstContext.FindClass("ImplicitCtor").First().Constructors.First(
                 c => c.Parameters.Count == 0).IsImplicit);
         }
+
+        [Test]
+        public void TestSpecializationArguments()
+        {
+            var classTemplate = AstContext.FindDecl<ClassTemplate>("TestSpecializationArguments").FirstOrDefault();
+            Assert.IsTrue(classTemplate.Specializations[0].Arguments[0].Type.Type.IsPrimitiveType(PrimitiveType.Int));
+        }
     }
 }

tests/Native/AST.h

@@ -110,3 +110,15 @@ class Atomics
 class ImplicitCtor
 {
 };
+
+template <typename T>
+class TestSpecializationArguments
+{
+public:
+    TestSpecializationArguments() {}
+};
+
+void instantiatesTemplate(TestSpecializationArguments<int> t)
+{
+}
+