Add TypeUtils::isSmallTrivial()

2 files changed, 44 insertions, 0 deletions

diff --git a/src/TypeUtils.cpp b/src/TypeUtils.cpp
index 78987794..887e6494 100644
--- a/src/TypeUtils.cpp
+++ b/src/TypeUtils.cpp
@@ -79,6 +79,42 @@ bool TypeUtils::classifyQualType(const ClazyContext *context, clang::QualType qu
     return true;
 }
 
+bool TypeUtils::isSmallTrivial(const ClazyContext *context, QualType qualType)
+{
+    if (qualType.isNull())
+        return false;
+
+    if (qualType->isPointerType())
+        qualType = qualType->getPointeeType();
+
+    if (qualType->isPointerType()) // We don't care about ** (We can change this whenever we have a use case)
+        return false;
+
+    QualType unrefQualType = TypeUtils::unrefQualType(qualType);
+    const Type *paramType = unrefQualType.getTypePtrOrNull();
+    if (!paramType || paramType->isIncompleteType())
+        return false;
+
+    if (isUndeducibleAuto(paramType))
+        return false;
+
+    if (qualType->isRValueReferenceType()) // && ref, nothing to do here
+        return false;
+
+     CXXRecordDecl *recordDecl = paramType->getAsCXXRecordDecl();
+     CXXMethodDecl *copyCtor = recordDecl ? Utils::copyCtor(recordDecl) : nullptr;
+     const bool hasDeletedCopyCtor = copyCtor && copyCtor->isDeleted();
+     const bool isTrivial = recordDecl && !recordDecl->hasNonTrivialCopyConstructor() && !recordDecl->hasNonTrivialDestructor() && !hasDeletedCopyCtor;
+
+     if (isTrivial) {
+         const auto typeSize = context->astContext.getTypeSize(unrefQualType) / 8;
+         const bool isSmall = typeSize <= 16;
+         return isSmall;
+     }
+
+     return false;
+}
+
 void TypeUtils::heapOrStackAllocated(Expr *arg, const std::string &type,
                                      const clang::LangOptions &lo,
                                      bool &isStack, bool &isHeap)
diff --git a/src/TypeUtils.h b/src/TypeUtils.h
index f1f7d6b5..686283af 100644
--- a/src/TypeUtils.h
+++ b/src/TypeUtils.h
@@ -83,6 +83,14 @@ bool classifyQualType(const ClazyContext *context, clang::QualType qualType, con
                       clang::Stmt *body = nullptr);
 
 /**
+ * @brief Lighter version of classifyQualType in case you just want to know if it's small and trivially copyable&destructible
+ * @param context The clazy context
+ * @param qualType The QualType we're testing.
+ * @return true if the type specified by QualType (or its pointee) are small and trivially copyable/destructible.
+ */
+bool isSmallTrivial(const ClazyContext *context, clang::QualType qualType);
+
+/**
  * If qt is a reference, return it without a reference.
  * If qt is not a reference, return qt.
  *