1 files changed, 66 insertions, 13 deletions

diff --git a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
index 8b8f02a8f..67ebcc606 100644
--- a/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
+++ b/sources/shiboken6/ApiExtractor/tests/testresolvetype.cpp
@@ -3,10 +3,15 @@
 
 #include "testresolvetype.h"
 #include "testutil.h"
+#include <abstractmetaargument.h>
+#include <abstractmetaenum.h>
 #include <abstractmetafunction.h>
 #include <abstractmetalang.h>
 #include <abstractmetatype.h>
 #include <complextypeentry.h>
+#include <enumtypeentry.h>
+#include <primitivetypeentry.h>
+#include <typedatabase.h>
 
 #include <qtcompat.h>
 
@@ -22,7 +27,7 @@ void TestResolveType::initTestCase()
 
 void TestResolveType::testResolveReturnTypeFromParentScope()
 {
-    const char* cppCode = "\n\
+    const char cppCode[] = "\n\
     namespace A {\n\
         struct B {\n\
             struct C {};\n\
@@ -32,7 +37,7 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
             C* method();\n\
         };\n\
     };";
-    const char* xmlCode = R"XML(
+    const char xmlCode[] = R"XML(
     <typesystem package='Foo'>
         <namespace-type name='A'>
             <value-type name='B'>
@@ -42,12 +47,12 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
         </namespace-type>
     </typesystem>)XML";
     QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
-    QVERIFY(!builder.isNull());
+    QVERIFY(builder);
     AbstractMetaClassList classes = builder->classes();
-    const AbstractMetaClass *classD = AbstractMetaClass::findClass(classes, u"A::D");
+    const auto classD = AbstractMetaClass::findClass(classes, "A::D");
     QVERIFY(classD);
-    const auto meth = classD->findFunction(u"method");
-    QVERIFY(!meth.isNull());
+    const auto meth = classD->findFunction("method");
+    QVERIFY(meth);
     QVERIFY(meth);
 }
 
@@ -57,13 +62,14 @@ void TestResolveType::testResolveReturnTypeFromParentScope()
 
 struct DefaultValuesFixture
 {
-    QSharedPointer<AbstractMetaBuilder> builder;
+    std::shared_ptr<AbstractMetaBuilder> builder;
 
     AbstractMetaType intType;
     AbstractMetaType stringType;
     AbstractMetaType classType;
     AbstractMetaType listType;
-    const AbstractMetaClass *klass{};
+    AbstractMetaType enumType;
+    AbstractMetaClassCPtr klass{};
 };
 
 Q_DECLARE_METATYPE(DefaultValuesFixture)
@@ -88,6 +94,7 @@ public:
 
     static const int INT_FIELD_1 = 42;
     static const char *CHAR_FIELD_1;
+    static const Enum DefaultValue = enumValue1;
 };
 } // Namespace
 )";
@@ -103,7 +110,7 @@ public:
 )";
 
     fixture->builder.reset(TestUtil::parse(cppCode, xmlCode, false));
-    if (fixture->builder.isNull())
+    if (!fixture->builder)
         return -1;
 
     for (const auto &klass : fixture->builder->classes()) {
@@ -118,7 +125,7 @@ public:
     fixture->classType = AbstractMetaType(fixture->klass->typeEntry());
     fixture->classType.decideUsagePattern();
 
-    for (const auto &f : fixture->klass->findFunctions(u"Test"_s)) {
+    for (const auto &f : fixture->klass->findFunctions("Test")) {
         if (f->functionType() == AbstractMetaFunction::ConstructorFunction
             && f->arguments().size() == 1) {
             const auto type = f->arguments().constFirst().type();
@@ -131,11 +138,14 @@ public:
     if (fixture->intType.isVoid() || fixture->stringType.isVoid())
         return -3;
 
-    auto listFunc = fixture->klass->findFunction(u"listFunc"_s);
-    if (listFunc.isNull() || listFunc->arguments().size() != 1)
+    auto listFunc = fixture->klass->findFunction("listFunc");
+    if (!listFunc || listFunc->arguments().size() != 1)
         return -3;
     fixture->listType = listFunc->arguments().constFirst().type();
 
+    fixture->enumType = AbstractMetaType(fixture->klass->enums().constFirst().typeEntry());
+    fixture->enumType.decideUsagePattern();
+
     return 0;
 }
 
@@ -210,6 +220,11 @@ void TestResolveType::testFixDefaultArguments_data()
     QTest::newRow("self from enum")
         << fixture << setupOk << fixture.classType
         << "Test(enumValue1)" << expected;
+
+    // Don't qualify fields to "Test::Enum::DefaultValue"
+    QTest::newRow("enum from static field")
+        << fixture << setupOk << fixture.enumType
+        << "DefaultValue" << u"Namespace::Test::DefaultValue"_s;
 }
 
 void TestResolveType::testFixDefaultArguments()
@@ -224,5 +239,43 @@ void TestResolveType::testFixDefaultArguments()
     QCOMPARE(actual, expected);
 }
 
-QTEST_APPLESS_MAIN(TestResolveType)
+// Verify that the typedefs of the C++ 11 integer types (int32_t, ...)
+// are seen by the C++ parser, otherwise they are handled as unknown
+// primitive types, causing invalid code to be generated.
+// (see BuilderPrivate::visitHeader(),
+// sources/shiboken6/ApiExtractor/clangparser/clangbuilder.cpp).
+void TestResolveType::testCppTypes()
+{
+    static const char cppCode[] =R"(
+#include <cstdint>
 
+class Test
+{
+public:
+    explicit Test(int32_t v);
+};
+)";
+    static const char xmlCode[] = R"(
+<typesystem package="Foo">
+    <value-type name='Test'/>
+    <primitive-type name='int32_t'/>
+</typesystem>
+)";
+
+    QScopedPointer<AbstractMetaBuilder> builder(TestUtil::parse(cppCode, xmlCode, false));
+    QVERIFY(builder);
+    AbstractMetaClassList classes = builder->classes();
+    const auto testClass = AbstractMetaClass::findClass(classes, "Test");
+    QVERIFY(testClass);
+
+    auto *tdb = TypeDatabase::instance();
+    auto int32TEntry = tdb->findType(u"int32_t"_s);
+    QVERIFY2(int32TEntry, "int32_t not found");
+    QVERIFY(int32TEntry->isPrimitive());
+    auto int32T = std::static_pointer_cast<const PrimitiveTypeEntry>(int32TEntry);
+    auto basicType = basicReferencedTypeEntry(int32T);
+    QVERIFY2(basicType != int32T,
+             "Typedef for int32_t not found. Check the system include paths.");
+}
+
+QTEST_APPLESS_MAIN(TestResolveType)