Handle constexpr, auto (#126)

These changes use the new and existing support inside the parser to handle constexpr in Qt6 files and to ignore (with a warning) 'auto' functions.
MeVisLab · Oct 29, 2023 · a4cafc5 · a4cafc5
1 parent 8db0ff4
commit a4cafc5
Show file tree

Hide file tree

Showing 3 changed files with 32 additions and 0 deletions.
diff --git a/generator/abstractmetabuilder.cpp b/generator/abstractmetabuilder.cpp
@@ -1489,6 +1489,19 @@ AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
       return 0;
     }
 
+    if (function_item->isAuto()) {
+        /*TODO: it might work just to output 'auto', but this would require
+         * understanding what AbstractMetabuild::translateType() does and
+         * changing it.  auto is only used once anyway.
+         */
+        ReportHandler::warning(QString("%1: skipping auto function type '%2'")
+                .arg(function_name)
+                .arg(function_item->type().toString()));
+        m_rejected_functions[class_name + "::" + function_name + " " + function_item->type().toString()] =
+                UnmatchedReturnType;
+        return 0;
+    }
+
     QString cast_type;
 
     if (function_name.startsWith("operator")) {
@@ -1504,6 +1517,8 @@ AbstractMetaFunction *AbstractMetaBuilder::traverseFunction(FunctionModelItem fu
 
     AbstractMetaFunction *meta_function = createMetaFunction();
     meta_function->setConstant(function_item->isConstant());
+    meta_function->setConstexpr(function_item->isConstexpr());
+    meta_function->setAuto(function_item->isAuto());
     meta_function->setException(function_item->exception());
 
     ReportHandler::debugMedium(QString(" - %2()").arg(function_name));
@@ -1707,10 +1722,12 @@ AbstractMetaType *AbstractMetaBuilder::translateType(const TypeInfo &_typei, boo
             //newInfo.setArguments(typei.arguments());
             newInfo.setIndirections(typei.indirections());
             newInfo.setConstant(typei.isConstant());
+            newInfo.setConstexpr(typei.isConstexpr());
             newInfo.setFunctionPointer(typei.isFunctionPointer());
             newInfo.setQualifiedName(typei.qualifiedName());
             newInfo.setReference(typei.isReference());
             newInfo.setVolatile(typei.isVolatile());
+            newInfo.setMutable(typei.isMutable());
 
             AbstractMetaType *elementType = translateType(newInfo, ok);
             if (!(*ok))

diff --git a/generator/abstractmetalang.cpp b/generator/abstractmetalang.cpp
@@ -315,6 +315,8 @@ AbstractMetaFunction *AbstractMetaFunction::copy() const
     if (type())
         cpy->setType(type()->copy());
     cpy->setConstant(isConstant());
+    cpy->setConstexpr(isConstexpr());
+    cpy->setAuto(isAuto());
     cpy->setException(exception());
     cpy->setOriginalAttributes(originalAttributes());
 
@@ -366,6 +368,8 @@ QString AbstractMetaFunction::signature() const
 
     if (isConstant())
         s += " const";
+    if (isConstexpr())
+        s += " constexpr";
 
     return s;
 }
@@ -657,6 +661,8 @@ QString AbstractMetaFunction::minimalSignature() const
     minimalSignature += ")";
     if (isConstant())
         minimalSignature += "const";
+    if (isConstexpr())
+        minimalSignature += "constexpr";
 
     minimalSignature = TypeSystem::normalizedSignature(minimalSignature.toLocal8Bit().constData());
     m_cached_minimal_signature = minimalSignature;

diff --git a/generator/abstractmetalang.h b/generator/abstractmetalang.h
@@ -410,6 +410,7 @@ class AbstractMetaFunction : public AbstractMetaAttributes
 
     AbstractMetaFunction() :
           m_constant(false),
+          m_constexpr(false),
           m_invalid(false)
     {
     }
@@ -487,6 +488,12 @@ class AbstractMetaFunction : public AbstractMetaAttributes
     bool isConstant() const { return m_constant; }
     void setConstant(bool constant) { m_constant = constant; }
 
+    bool isConstexpr() const { return m_constexpr; }
+    void setConstexpr(bool constant) { m_constexpr = constant; }
+
+    bool isAuto() const { return m_auto; }
+    void setAuto(bool isAuto) { m_auto = isAuto; }
+
     QString exception() const { return m_exception; }
     void setException(const QString &exception) { m_exception = exception; }
     QString toString() const { return m_name; }
@@ -550,6 +557,8 @@ class AbstractMetaFunction : public AbstractMetaAttributes
     AbstractMetaArgumentList m_arguments;
     QString m_exception;
     uint m_constant                 : 1;
+    uint m_constexpr                : 1;
+    uint m_auto                     : 1;
     uint m_invalid                  : 1;
 };