1 files changed, 97 insertions, 14 deletions

diff --git a/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp b/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp
index 5191cb38d..f6c70a651 100644
--- a/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp
+++ b/sources/shiboken2/ApiExtractor/tests/testtemplates.cpp
@@ -115,15 +115,15 @@ namespace Namespace {
     QVERIFY(!classB->baseClass());
     QVERIFY(classB->baseClassName().isEmpty());
     const AbstractMetaFunction* func = classB->findFunction(QLatin1String("foo"));
-    AbstractMetaType* argType = func->arguments().first()->type();
+    AbstractMetaType* argType = func->arguments().constFirst()->type();
     QCOMPARE(argType->instantiations().count(), 1);
     QCOMPARE(argType->typeEntry()->qualifiedCppName(), QLatin1String("QList"));
 
-    const AbstractMetaType* instance1 = argType->instantiations().first();
+    const AbstractMetaType* instance1 = argType->instantiations().constFirst();
     QCOMPARE(instance1->instantiations().count(), 1);
     QCOMPARE(instance1->typeEntry()->qualifiedCppName(), QLatin1String("Namespace::A"));
 
-    const AbstractMetaType* instance2 = instance1->instantiations().first();
+    const AbstractMetaType* instance2 = instance1->instantiations().constFirst();
     QCOMPARE(instance2->instantiations().count(), 0);
     QCOMPARE(instance2->typeEntry()->qualifiedCppName(), QLatin1String("Namespace::E1"));
 }
@@ -147,9 +147,10 @@ void func(List<int> arg) {}
     AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 
-    AbstractMetaFunction* func = globalFuncs.first();
+    AbstractMetaFunction *func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>)"));
-    QCOMPARE(func->arguments().first()->type()->cppSignature(), QLatin1String("List<int >"));
+    QCOMPARE(func->arguments().constFirst()->type()->cppSignature(),
+             QLatin1String("List<int >"));
 }
 
 void TestTemplates::testTemplatePointerAsArgument()
@@ -171,9 +172,10 @@ void func(List<int>* arg) {}
     AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 
-    AbstractMetaFunction* func = globalFuncs.first();
+    AbstractMetaFunction* func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>*)"));
-    QCOMPARE(func->arguments().first()->type()->cppSignature(), QLatin1String("List<int > *"));
+    QCOMPARE(func->arguments().constFirst()->type()->cppSignature(),
+             QLatin1String("List<int > *"));
 }
 
 void TestTemplates::testTemplateReferenceAsArgument()
@@ -195,9 +197,10 @@ void func(List<int>& arg) {}
     AbstractMetaFunctionList globalFuncs = builder->globalFunctions();
     QCOMPARE(globalFuncs.count(), 1);
 
-    AbstractMetaFunction* func = globalFuncs.first();
+    AbstractMetaFunction* func = globalFuncs.constFirst();
     QCOMPARE(func->minimalSignature(), QLatin1String("func(List<int>&)"));
-    QCOMPARE(func->arguments().first()->type()->cppSignature(), QLatin1String("List<int > &"));
+    QCOMPARE(func->arguments().constFirst()->type()->cppSignature(),
+             QLatin1String("List<int > &"));
 }
 
 void TestTemplates::testTemplateParameterFixup()
@@ -223,7 +226,7 @@ struct List {
     const AbstractMetaClassList templates = builder->templates();
 
     QCOMPARE(templates.count(), 1);
-    const AbstractMetaClass *list = templates.first();
+    const AbstractMetaClass *list = templates.constFirst();
     // Verify that the parameter of "void append(List l)" gets fixed to "List<T >"
     const AbstractMetaFunction *append = list->findFunction(QStringLiteral("append"));
     QVERIFY(append);
@@ -269,7 +272,7 @@ struct FooBars : public ListContainer<FooBar> {};
     const AbstractMetaClass* foobars = AbstractMetaClass::findClass(classes, QLatin1String("FooBars"));
     QCOMPARE(foobars->functions().count(), 4);
 
-    const AbstractMetaClass* lc = templates.first();
+    const AbstractMetaClass *lc = templates.constFirst();
     QCOMPARE(lc->functions().count(), 2);
 }
 
@@ -391,7 +394,7 @@ typedef BaseTemplateClass<TypeOne> TypeOneClass;
     QVERIFY(one->hasTemplateBaseClassInstantiations());
     AbstractMetaTypeList instantiations = one->templateBaseClassInstantiations();
     QCOMPARE(instantiations.count(), 1);
-    const AbstractMetaType* inst = instantiations.first();
+    const AbstractMetaType *inst = instantiations.constFirst();
     QVERIFY(inst);
     QVERIFY(!inst->isEnum());
     QVERIFY(!inst->typeEntry()->isEnum());
@@ -428,8 +431,10 @@ typedef Vector<int> IntVector;
 
     AbstractMetaClass* vector = AbstractMetaClass::findClass(classes, QLatin1String("IntVector"));
     QVERIFY(vector);
-    QVERIFY(vector->typeEntry()->baseContainerType());
-    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(vector->typeEntry()->baseContainerType())->type(), ContainerTypeEntry::VectorContainer);
+    auto baseContainer = vector->typeEntry()->baseContainerType();
+    QVERIFY(baseContainer);
+    QCOMPARE(reinterpret_cast<const ContainerTypeEntry*>(baseContainer)->containerKind(),
+             ContainerTypeEntry::VectorContainer);
     QCOMPARE(vector->functions().count(), 4);
 
     const AbstractMetaFunction* method = vector->findFunction(QLatin1String("method"));
@@ -443,6 +448,35 @@ typedef Vector<int> IntVector;
     QCOMPARE(otherMethod->type()->cppSignature(), QLatin1String("Vector<int >"));
 }
 
+void TestTemplates::testNonTypeTemplates()
+{
+    // PYSIDe-1296, functions with non type templates parameters.
+    const char cppCode[] = R"CPP(
+template <class T, int Size>
+class Array {
+    T array[Size];
+};
+
+Array<int, 2> foo();
+
+)CPP";
+
+    const char xmlCode[] = R"XML(
+<typesystem package='Foo'>
+    <primitive-type name='int'/>
+    <container-type name='Array' type='vector'/>
+    <function signature="foo()"/>
+</typesystem>)XML";
+
+    QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
+    QVERIFY(!builder.isNull());
+    auto functions = builder->globalFunctions();
+    QCOMPARE(functions.count(), 1);
+    auto foo = functions.constFirst();
+    QCOMPARE(foo->name(), QLatin1String("foo"));
+    QCOMPARE(foo->type()->name(), QLatin1String("Array"));
+}
+
 // Perform checks on template inheritance; a typedef of a template class
 // should result in rewritten types.
 void TestTemplates::testTemplateTypeDefs_data()
@@ -561,4 +595,53 @@ void TestTemplates::testTemplateTypeDefs()
     QCOMPARE(xmlValueField->type()->cppSignature(), QLatin1String("int"));
 }
 
+void TestTemplates::testTemplateTypeAliases()
+{
+    // Model Qt 6's "template<typename T> using QList = QVector<T>"
+    const char cppCode[] = R"CPP(
+template<typename T>
+class Container1 { };
+
+template<typename T>
+using Container2 = Container1<T>;
+
+class Test
+{
+public:
+    Container2<int> m_intContainer;
+};
+
+class Derived : public Container2<int>
+{
+public:
+};
+)CPP";
+
+    const char xmlCode[] = R"XML(
+<typesystem package='Foo'>
+    <primitive-type name='int'/>
+    <value-type name='Container1'/>
+    <value-type name='Derived'/>
+    <object-type name='Test'/>
+</typesystem>)XML";
+
+    QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, true));
+    QVERIFY(!builder.isNull());
+
+    AbstractMetaClassList classes = builder->classes();
+    auto testClass = AbstractMetaClass::findClass(classes, QLatin1String("Test"));
+    QVERIFY(testClass);
+
+    auto fields = testClass->fields();
+    QCOMPARE(fields.count(), 1);
+    auto fieldType = testClass->fields().at(0)->type();
+    QCOMPARE(fieldType->name(), QLatin1String("Container1"));
+    QCOMPARE(fieldType->instantiations().size(), 1);
+
+    auto derived = AbstractMetaClass::findClass(classes, QLatin1String("Derived"));
+    QVERIFY(derived);
+    auto base = derived->templateBaseClass();
+    QCOMPARE(base->name(), QLatin1String("Container1"));
+}
+
 QTEST_APPLESS_MAIN(TestTemplates)