Use clazy namespace instead of TypeUtils

30 files changed, 75 insertions, 75 deletions

diff --git a/src/ContextUtils.cpp b/src/ContextUtils.cpp
index 3ea373a1..b08af47a 100644
--- a/src/ContextUtils.cpp
+++ b/src/ContextUtils.cpp
@@ -180,10 +180,10 @@ bool clazy::canTakeAddressOf(CXXMethodDecl *method, DeclContext *context, bool &
         return false;
 
     // For protected there's still hope, since record might be a derived or base class
-    if (TypeUtils::derivesFrom(record, contextRecord))
+    if (clazy::derivesFrom(record, contextRecord))
         return true;
 
-    if (TypeUtils::derivesFrom(contextRecord, record)) {
+    if (clazy::derivesFrom(contextRecord, record)) {
         isSpecialProtectedCase = true;
         return true;
     }
diff --git a/src/ContextUtils.h b/src/ContextUtils.h
index 4773367b..2ebebd1e 100644
--- a/src/ContextUtils.h
+++ b/src/ContextUtils.h
@@ -98,7 +98,7 @@ inline clang::NamespaceDecl *namespaceForType(clang::QualType q)
     if (q.isNull())
         return nullptr;
 
-    q = TypeUtils::pointeeQualType(q);
+    q = clazy::pointeeQualType(q);
     // Check if it's a class, struct, union or enum
     clang::TagDecl *rec = q->getAsTagDecl();
     if (rec)
diff --git a/src/QtUtils.cpp b/src/QtUtils.cpp
index f94e4ae3..4bc61e6b 100644
--- a/src/QtUtils.cpp
+++ b/src/QtUtils.cpp
@@ -130,12 +130,12 @@ bool clazy::isQtAssociativeContainer(StringRef className)
 
 bool clazy::isQObject(const CXXRecordDecl *decl)
 {
-    return TypeUtils::derivesFrom(decl, "QObject");
+    return clazy::derivesFrom(decl, "QObject");
 }
 
 bool clazy::isQObject(clang::QualType qt)
 {
-    qt = TypeUtils::pointeeQualType(qt);
+    qt = clazy::pointeeQualType(qt);
     const auto t = qt.getTypePtrOrNull();
     return t ? isQObject(t->getAsCXXRecordDecl()) : false;
 }
@@ -161,9 +161,9 @@ bool clazy::isConvertibleTo(const Type *source, const Type *target)
         return true;
 
     // "QString" can convert to "const QString &" and vice versa
-    if (TypeUtils::isConstRef(source) && source->getPointeeType().getTypePtrOrNull() == target)
+    if (clazy::isConstRef(source) && source->getPointeeType().getTypePtrOrNull() == target)
         return true;
-    if (TypeUtils::isConstRef(target) && target->getPointeeType().getTypePtrOrNull() == source)
+    if (clazy::isConstRef(target) && target->getPointeeType().getTypePtrOrNull() == source)
         return true;
 
     return false;
@@ -190,7 +190,7 @@ bool clazy::isJavaIterator(CXXMemberCallExpr *call)
 
 bool clazy::isQtContainer(QualType t)
 {
-    CXXRecordDecl *record = TypeUtils::typeAsRecord(t);
+    CXXRecordDecl *record = clazy::typeAsRecord(t);
     if (!record)
         return false;
 
@@ -233,7 +233,7 @@ bool clazy::isAReserveClass(CXXRecordDecl *recordDecl)
     static const std::vector<std::string> classes = {"QVector", "std::vector", "QList", "QSet"};
 
     return clazy::any_of(classes, [recordDecl](const string &className) {
-        return TypeUtils::derivesFrom(recordDecl, className);
+        return clazy::derivesFrom(recordDecl, className);
     });
 }
 
@@ -243,7 +243,7 @@ clang::CXXRecordDecl *clazy::getQObjectBaseClass(clang::CXXRecordDecl *recordDec
         return nullptr;
 
     for (auto baseClass : recordDecl->bases()) {
-        CXXRecordDecl *record = TypeUtils::recordFromBaseSpecifier(baseClass);
+        CXXRecordDecl *record = clazy::recordFromBaseSpecifier(baseClass);
         if (isQObject(record))
             return record;
     }
@@ -362,8 +362,8 @@ bool clazy::recordHasCtorWithParam(clang::CXXRecordDecl *record, const std::stri
             continue;
         numCtors++;
         for (auto param : ctor->parameters()) {
-            QualType qt = TypeUtils::pointeeQualType(param->getType());
-            if (!qt.isConstQualified() && TypeUtils::derivesFrom(qt, paramType)) {
+            QualType qt = clazy::pointeeQualType(param->getType());
+            if (!qt.isConstQualified() && clazy::derivesFrom(qt, paramType)) {
                 return true;
             }
         }
diff --git a/src/QtUtils.h b/src/QtUtils.h
index caad2076..88070672 100644
--- a/src/QtUtils.h
+++ b/src/QtUtils.h
@@ -186,7 +186,7 @@ bool isJavaIterator(clang::CXXMemberCallExpr *call);
  */
 inline bool isTooBigForQList(clang::QualType qt, const clang::ASTContext *context)
 {
-    return (int)context->getTypeSize(qt) <= TypeUtils::sizeOfPointer(context, qt);
+    return (int)context->getTypeSize(qt) <= clazy::sizeOfPointer(context, qt);
 }
 
 /**
@@ -295,7 +295,7 @@ inline bool is_qobject_cast(clang::Stmt *s, clang::CXXRecordDecl **castTo = null
                     expr = implicitCast->getSubExpr();
                 }
             }
-            clang::QualType qt = TypeUtils::pointeeQualType(expr->getType());
+            clang::QualType qt = clazy::pointeeQualType(expr->getType());
             if (!qt.isNull()) {
                 clang::CXXRecordDecl *record = qt->getAsCXXRecordDecl();
                 *castFrom = record ? record->getCanonicalDecl() : nullptr;
@@ -306,7 +306,7 @@ inline bool is_qobject_cast(clang::Stmt *s, clang::CXXRecordDecl **castTo = null
             auto templateArgs = func->getTemplateSpecializationArgs();
             if (templateArgs->size() == 1) {
                 const clang::TemplateArgument &arg = templateArgs->get(0);
-                clang::QualType qt = TypeUtils::pointeeQualType(arg.getAsType());
+                clang::QualType qt = clazy::pointeeQualType(arg.getAsType());
                 if (!qt.isNull()) {
                     clang::CXXRecordDecl *record = qt->getAsCXXRecordDecl();
                     *castTo = record ? record->getCanonicalDecl() : nullptr;
diff --git a/src/TypeUtils.cpp b/src/TypeUtils.cpp
index 887e6494..9a8188fa 100644
--- a/src/TypeUtils.cpp
+++ b/src/TypeUtils.cpp
@@ -36,11 +36,11 @@
 
 using namespace clang;
 
-bool TypeUtils::classifyQualType(const ClazyContext *context, clang::QualType qualType,
-                                 const VarDecl *varDecl, QualTypeClassification &classif,
-                                 clang::Stmt *body)
+bool clazy::classifyQualType(const ClazyContext *context, clang::QualType qualType,
+                             const VarDecl *varDecl, QualTypeClassification &classif,
+                             clang::Stmt *body)
 {
-    QualType unrefQualType = TypeUtils::unrefQualType(qualType);
+    QualType unrefQualType = clazy::unrefQualType(qualType);
     const Type *paramType = unrefQualType.getTypePtrOrNull();
     if (!paramType || paramType->isIncompleteType())
         return false;
@@ -79,7 +79,7 @@ bool TypeUtils::classifyQualType(const ClazyContext *context, clang::QualType qu
     return true;
 }
 
-bool TypeUtils::isSmallTrivial(const ClazyContext *context, QualType qualType)
+bool clazy::isSmallTrivial(const ClazyContext *context, QualType qualType)
 {
     if (qualType.isNull())
         return false;
@@ -90,7 +90,7 @@ bool TypeUtils::isSmallTrivial(const ClazyContext *context, QualType qualType)
     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);
+    QualType unrefQualType = clazy::unrefQualType(qualType);
     const Type *paramType = unrefQualType.getTypePtrOrNull();
     if (!paramType || paramType->isIncompleteType())
         return false;
@@ -115,7 +115,7 @@ bool TypeUtils::isSmallTrivial(const ClazyContext *context, QualType qualType)
      return false;
 }
 
-void TypeUtils::heapOrStackAllocated(Expr *arg, const std::string &type,
+void clazy::heapOrStackAllocated(Expr *arg, const std::string &type,
                                      const clang::LangOptions &lo,
                                      bool &isStack, bool &isHeap)
 {
@@ -156,7 +156,7 @@ void TypeUtils::heapOrStackAllocated(Expr *arg, const std::string &type,
     }
 }
 
-bool TypeUtils::derivesFrom(const CXXRecordDecl *derived, const CXXRecordDecl *possibleBase,
+bool clazy::derivesFrom(const CXXRecordDecl *derived, const CXXRecordDecl *possibleBase,
                             std::vector<CXXRecordDecl*> *baseClasses)
 {
     if (!derived || !possibleBase || derived == possibleBase)
@@ -178,7 +178,7 @@ bool TypeUtils::derivesFrom(const CXXRecordDecl *derived, const CXXRecordDecl *p
     return false;
 }
 
-bool TypeUtils::derivesFrom(const clang::CXXRecordDecl *derived, const std::string &possibleBase)
+bool clazy::derivesFrom(const clang::CXXRecordDecl *derived, const std::string &possibleBase)
 {
     if (!derived || !derived->hasDefinition())
         return false;
@@ -194,7 +194,7 @@ bool TypeUtils::derivesFrom(const clang::CXXRecordDecl *derived, const std::stri
     return false;
 }
 
-bool TypeUtils::derivesFrom(QualType derivedQT, const std::string &possibleBase)
+bool clazy::derivesFrom(QualType derivedQT, const std::string &possibleBase)
 {
     derivedQT = pointeeQualType(derivedQT);
     const auto t = derivedQT.getTypePtrOrNull();
diff --git a/src/TypeUtils.h b/src/TypeUtils.h
index 686283af..60ce4e4d 100644
--- a/src/TypeUtils.h
+++ b/src/TypeUtils.h
@@ -47,7 +47,7 @@ class CXXBaseSpecifier;
 
 class ClazyContext;
 
-namespace TypeUtils
+namespace clazy
 {
 /**
  * Returns the sizeof(void*) for the platform we're compiling for, in bits.
diff --git a/src/checks/inefficientqlistbase.cpp b/src/checks/inefficientqlistbase.cpp
index d75a2426..2e2ed07f 100644
--- a/src/checks/inefficientqlistbase.cpp
+++ b/src/checks/inefficientqlistbase.cpp
@@ -107,7 +107,7 @@ void InefficientQListBase::VisitDecl(clang::Decl *decl)
     if (!qt2.getTypePtrOrNull() || qt2->isIncompleteType())
         return;
 
-    const int size_of_ptr = TypeUtils::sizeOfPointer(&m_astContext, qt2); // in bits
+    const int size_of_ptr = clazy::sizeOfPointer(&m_astContext, qt2); // in bits
     const int size_of_T = m_astContext.getTypeSize(qt2);
 
     if (size_of_T > size_of_ptr && !shouldIgnoreVariable(varDecl)) {
diff --git a/src/checks/level0/fully-qualified-moc-types.cpp b/src/checks/level0/fully-qualified-moc-types.cpp
index 5558d692..ef2cd650 100644
--- a/src/checks/level0/fully-qualified-moc-types.cpp
+++ b/src/checks/level0/fully-qualified-moc-types.cpp
@@ -80,14 +80,14 @@ void FullyQualifiedMocTypes::VisitDecl(clang::Decl *decl)
     string qualifiedTypeName;
     string typeName;
     for (auto param : method->parameters()) {
-        QualType t = TypeUtils::pointeeQualType(param->getType());
+        QualType t = clazy::pointeeQualType(param->getType());
         if (!typeIsFullyQualified(t, /*by-ref*/ qualifiedTypeName, /*by-ref*/ typeName)) {
             emitWarning(method, string(accessSpecifierManager->qtAccessSpecifierTypeStr(qst)) + " arguments need to be fully-qualified (" + qualifiedTypeName + " instead of " + typeName + ")");
         }
     }
 
     if (qst == QtAccessSpecifier_Slot || qst == QtAccessSpecifier_Invokable) {
-        QualType returnT = TypeUtils::pointeeQualType(method->getReturnType());
+        QualType returnT = clazy::pointeeQualType(method->getReturnType());
         if (!typeIsFullyQualified(returnT, /*by-ref*/ qualifiedTypeName, /*by-ref*/ typeName)) {
             emitWarning(method, string(accessSpecifierManager->qtAccessSpecifierTypeStr(qst)) + " return types need to be fully-qualified (" + qualifiedTypeName + " instead of " + typeName + ")");
         }
@@ -158,7 +158,7 @@ bool FullyQualifiedMocTypes::handleQ_PROPERTY(CXXMethodDecl *method)
                 for (auto s : switches) {
                     auto reinterprets = clazy::getStatements<CXXReinterpretCastExpr>(s);
                     for (auto reinterpret : reinterprets) {
-                        QualType qt = TypeUtils::pointeeQualType(reinterpret->getTypeAsWritten());
+                        QualType qt = clazy::pointeeQualType(reinterpret->getTypeAsWritten());
                         auto record = qt->getAsCXXRecordDecl();
                         if (!record || !isGadget(record))
                             continue;
diff --git a/src/checks/level0/strict-iterators.cpp b/src/checks/level0/strict-iterators.cpp
index 3012145d..0bdce6fc 100644
--- a/src/checks/level0/strict-iterators.cpp
+++ b/src/checks/level0/strict-iterators.cpp
@@ -83,11 +83,11 @@ bool StrictIterators::handleImplicitCast(ImplicitCastExpr *implicitCast)
     const string nameTo = clazy::simpleTypeName(implicitCast->getType(), m_context->ci.getLangOpts());
 
     const QualType typeTo = implicitCast->getType();
-    CXXRecordDecl *recordTo = TypeUtils::parentRecordForTypedef(typeTo);
+    CXXRecordDecl *recordTo = clazy::parentRecordForTypedef(typeTo);
     if (recordTo && !clazy::isQtCOWIterableClass(recordTo))
         return false;
 
-    recordTo = TypeUtils::typeAsRecord(typeTo);
+    recordTo = clazy::typeAsRecord(typeTo);
     if (recordTo && !clazy::isQtCOWIterator(recordTo))
         return false;
 
@@ -99,12 +99,12 @@ bool StrictIterators::handleImplicitCast(ImplicitCastExpr *implicitCast)
     }
 
     QualType typeFrom = implicitCast->getSubExpr()->getType();
-    CXXRecordDecl *recordFrom = TypeUtils::parentRecordForTypedef(typeFrom);
+    CXXRecordDecl *recordFrom = clazy::parentRecordForTypedef(typeFrom);
     if (recordFrom && !clazy::isQtCOWIterableClass(recordFrom))
         return false;
 
     // const_iterator might be a typedef to pointer, like const T *, instead of a class, so just check for const qualification in that case
-    if (!(TypeUtils::pointeeQualType(typeTo).isConstQualified() || clazy::endsWith(nameTo, "const_iterator")))
+    if (!(clazy::pointeeQualType(typeTo).isConstQualified() || clazy::endsWith(nameTo, "const_iterator")))
         return false;
 
     if (implicitCast->getCastKind() == CK_ConstructorConversion) {
@@ -149,7 +149,7 @@ bool StrictIterators::handleOperator(CXXOperatorCallExpr *op)
         return false;
 
     ParmVarDecl *p = method->getParamDecl(0);
-    CXXRecordDecl *paramClass = p ? TypeUtils::typeAsRecord(TypeUtils::pointeeQualType(p->getType())) : nullptr;
+    CXXRecordDecl *paramClass = p ? clazy::typeAsRecord(clazy::pointeeQualType(p->getType())) : nullptr;
     if (!paramClass || clazy::name(paramClass) != "const_iterator")
         return false;
 
diff --git a/src/checks/level0/unused-non-trivial-variable.cpp b/src/checks/level0/unused-non-trivial-variable.cpp
index af32f803..4e4b8303 100644
--- a/src/checks/level0/unused-non-trivial-variable.cpp
+++ b/src/checks/level0/unused-non-trivial-variable.cpp
@@ -124,7 +124,7 @@ bool UnusedNonTrivialVariable::isInterestingType(QualType t) const
                                                        "QLine", "QLineF", "QRect", "QRectF", "QDomNode"
     };
 
-    CXXRecordDecl *record = TypeUtils::typeAsRecord(t);
+    CXXRecordDecl *record = clazy::typeAsRecord(t);
     if (!record)
         return false;
 
diff --git a/src/checks/level0/wrong-qevent-cast.cpp b/src/checks/level0/wrong-qevent-cast.cpp
index 432eb2a4..02d91307 100644
--- a/src/checks/level0/wrong-qevent-cast.cpp
+++ b/src/checks/level0/wrong-qevent-cast.cpp
@@ -245,7 +245,7 @@ void WrongQEventCast::VisitStmt(clang::Stmt *stmt)
     Expr *e = cast->getSubExpr();
 
     QualType t = e ? e->getType() : QualType();
-    QualType pointeeType = t.isNull() ? QualType() : TypeUtils::pointeeQualType(t);
+    QualType pointeeType = t.isNull() ? QualType() : clazy::pointeeQualType(t);
     CXXRecordDecl *rec = pointeeType.isNull() ? nullptr : pointeeType->getAsCXXRecordDecl();
 
     if (!rec || clazy::name(rec) != "QEvent")
diff --git a/src/checks/level1/auto-unexpected-qstringbuilder.cpp b/src/checks/level1/auto-unexpected-qstringbuilder.cpp
index b07d5bb4..2dc20ac0 100644
--- a/src/checks/level1/auto-unexpected-qstringbuilder.cpp
+++ b/src/checks/level1/auto-unexpected-qstringbuilder.cpp
@@ -47,7 +47,7 @@ using namespace std;
 
 static bool isQStringBuilder(QualType t)
 {
-    CXXRecordDecl *record = TypeUtils::typeAsRecord(t);
+    CXXRecordDecl *record = clazy::typeAsRecord(t);
     return record && clazy::name(record) == "QStringBuilder";
 }
 
diff --git a/src/checks/level1/const-signal-or-slot.cpp b/src/checks/level1/const-signal-or-slot.cpp
index f0419565..192e2302 100644
--- a/src/checks/level1/const-signal-or-slot.cpp
+++ b/src/checks/level1/const-signal-or-slot.cpp
@@ -87,7 +87,7 @@ void ConstSignalOrSlot::VisitDecl(Decl *decl)
         return;
 
     CXXRecordDecl *record = method->getParent();
-    if (TypeUtils::derivesFrom(record, "QDBusAbstractInterface"))
+    if (clazy::derivesFrom(record, "QDBusAbstractInterface"))
         return;
 
     QtAccessSpecifierType specifierType = a->qtAccessSpecifierType(method);
diff --git a/src/checks/level1/foreach.cpp b/src/checks/level1/foreach.cpp
index 702ba2f1..c647b225 100644
--- a/src/checks/level1/foreach.cpp
+++ b/src/checks/level1/foreach.cpp
@@ -156,8 +156,8 @@ void Foreach::checkBigTypeMissingRef()
     if (!varDecl)
         return;
 
-    TypeUtils::QualTypeClassification classif;
-    bool success = TypeUtils::classifyQualType(m_context, varDecl->getType(), varDecl, /*by-ref*/ classif, forStatements.at(0));
+    clazy::QualTypeClassification classif;
+    bool success = clazy::classifyQualType(m_context, varDecl->getType(), varDecl, /*by-ref*/ classif, forStatements.at(0));
     if (!success)
         return;
 
diff --git a/src/checks/level1/install-event-filter.cpp b/src/checks/level1/install-event-filter.cpp
index ce4a82c4..6d917b2e 100644
--- a/src/checks/level1/install-event-filter.cpp
+++ b/src/checks/level1/install-event-filter.cpp
@@ -65,7 +65,7 @@ void InstallEventFilter::VisitStmt(clang::Stmt *stmt)
     Expr *arg1 = memberCallExpr->getArg(0);
     arg1 = arg1 ? arg1->IgnoreCasts() : nullptr;
 
-    CXXRecordDecl *record = TypeUtils::typeAsRecord(arg1);
+    CXXRecordDecl *record = clazy::typeAsRecord(arg1);
     auto methods = Utils::methodsFromString(record, "eventFilter");
 
     for (auto method : methods) {
diff --git a/src/checks/level1/post-event.cpp b/src/checks/level1/post-event.cpp
index 4bd78a4c..e7c7ff57 100644
--- a/src/checks/level1/post-event.cpp
+++ b/src/checks/level1/post-event.cpp
@@ -61,7 +61,7 @@ void PostEvent::VisitStmt(clang::Stmt *stmt)
 
     bool isStack = false;
     bool isHeap = false;
-    TypeUtils::heapOrStackAllocated(event, "QEvent", lo(), isStack, isHeap);
+    clazy::heapOrStackAllocated(event, "QEvent", lo(), isStack, isHeap);
 
     if (isStack || isHeap) {
         if (isSendEvent && isHeap) {
diff --git a/src/checks/level1/range-loop.cpp b/src/checks/level1/range-loop.cpp
index 1a9247e1..8401cf13 100644
--- a/src/checks/level1/range-loop.cpp
+++ b/src/checks/level1/range-loop.cpp
@@ -104,7 +104,7 @@ void RangeLoop::processForRangeLoop(CXXForRangeStmt *rangeLoop)
         return;
 
     auto loopVariableType = rangeLoop->getLoopVariable()->getType();
-    if (!TypeUtils::unrefQualType(loopVariableType).isConstQualified() && loopVariableType->isReferenceType())
+    if (!clazy::unrefQualType(loopVariableType).isConstQualified() && loopVariableType->isReferenceType())
         return;
 
     CXXRecordDecl *record = t->getAsCXXRecordDecl();
@@ -133,9 +133,9 @@ void RangeLoop::processForRangeLoop(CXXForRangeStmt *rangeLoop)
 
 void RangeLoop::checkPassByConstRefCorrectness(CXXForRangeStmt *rangeLoop)
 {
-    TypeUtils::QualTypeClassification classif;
+    clazy::QualTypeClassification classif;
     auto varDecl = rangeLoop->getLoopVariable();
-    bool success = varDecl && TypeUtils::classifyQualType(m_context, varDecl->getType(), varDecl, /*by-ref*/ classif, rangeLoop);
+    bool success = varDecl && clazy::classifyQualType(m_context, varDecl->getType(), varDecl, /*by-ref*/ classif, rangeLoop);
     if (!success)
         return;
 
diff --git a/src/checks/level1/returning-data-from-temporary.cpp b/src/checks/level1/returning-data-from-temporary.cpp
index 60836722..861aa085 100644
--- a/src/checks/level1/returning-data-from-temporary.cpp
+++ b/src/checks/level1/returning-data-from-temporary.cpp
@@ -132,14 +132,14 @@ void ReturningDataFromTemporary::handleMemberCall(CXXMemberCallExpr *memberCall,
 
     if (declRef) {
         VarDecl *varDecl = dyn_cast<VarDecl>(declRef->getDecl());
-        if (!varDecl || varDecl->isStaticLocal() || TypeUtils::valueIsConst(varDecl->getType()))
+        if (!varDecl || varDecl->isStaticLocal() || clazy::valueIsConst(varDecl->getType()))
             return;
 
         QualType qt = varDecl->getType();
         if (qt.isNull() || qt->isReferenceType())
             return;
     } else if (temporaryExpr) {
-        if (TypeUtils::valueIsConst(temporaryExpr->getType()))
+        if (clazy::valueIsConst(temporaryExpr->getType()))
             return;
     }
 
diff --git a/src/checks/level1/skipped-base-method.cpp b/src/checks/level1/skipped-base-method.cpp
index fccfc5fa..064bccb4 100644
--- a/src/checks/level1/skipped-base-method.cpp
+++ b/src/checks/level1/skipped-base-method.cpp
@@ -60,7 +60,7 @@ void SkippedBaseMethod::VisitStmt(clang::Stmt *stmt)
     const CXXRecordDecl *baseClass = memberCall->getRecordDecl();
 
     std::vector<CXXRecordDecl*> baseClasses;
-    if (!TypeUtils::derivesFrom(thisClass, baseClass, &baseClasses) || baseClasses.size() < 2)
+    if (!clazy::derivesFrom(thisClass, baseClass, &baseClasses) || baseClasses.size() < 2)
         return;
 
     // We're calling a grand-base method, so check if a more direct base also implements it
diff --git a/src/checks/level2/ctor-missing-parent-argument.cpp b/src/checks/level2/ctor-missing-parent-argument.cpp
index a9aca6ab..46f2faed 100644
--- a/src/checks/level2/ctor-missing-parent-argument.cpp
+++ b/src/checks/level2/ctor-missing-parent-argument.cpp
@@ -45,11 +45,11 @@ CtorMissingParentArgument::CtorMissingParentArgument(const std::string &name, Cl
 
 static string expectedParentTypeFor(CXXRecordDecl *decl)
 {
-    if (TypeUtils::derivesFrom(decl, "QWidget")) {
+    if (clazy::derivesFrom(decl, "QWidget")) {
         return "QWidget";
-    } else if (TypeUtils::derivesFrom(decl, "QQuickItem")) {
+    } else if (clazy::derivesFrom(decl, "QQuickItem")) {
         return "QQuickItem";
-    } else if (TypeUtils::derivesFrom(decl, "Qt3DCore::QEntity")) {
+    } else if (clazy::derivesFrom(decl, "Qt3DCore::QEntity")) {
         return "Qt3DCore::QNode";
     }
 
diff --git a/src/checks/level2/function-args-by-ref.cpp b/src/checks/level2/function-args-by-ref.cpp
index fdb88b11..975203eb 100644
--- a/src/checks/level2/function-args-by-ref.cpp
+++ b/src/checks/level2/function-args-by-ref.cpp
@@ -125,7 +125,7 @@ void FunctionArgsByRef::processFunction(FunctionDecl *func)
     auto funcParams = Utils::functionParameters(func);
     for (unsigned int i = 0; i < funcParams.size(); ++i) {
         ParmVarDecl* param = funcParams[i];
-        const QualType paramQt = TypeUtils::unrefQualType(param->getType());
+        const QualType paramQt = clazy::unrefQualType(param->getType());
         const Type *paramType = paramQt.getTypePtrOrNull();
         if (!paramType || paramType->isIncompleteType() || paramType->isDependentType())
             continue;
@@ -133,8 +133,8 @@ void FunctionArgsByRef::processFunction(FunctionDecl *func)
         if (shouldIgnoreClass(paramType->getAsCXXRecordDecl()))
             continue;
 
-        TypeUtils::QualTypeClassification classif;
-        bool success = TypeUtils::classifyQualType(m_context, param->getType(), param, classif, body);
+        clazy::QualTypeClassification classif;
+        bool success = clazy::classifyQualType(m_context, param->getType(), param, classif, body);
         if (!success)
             continue;
 
@@ -167,7 +167,7 @@ void FunctionArgsByRef::addFixits(std::vector<FixItHint> &fixits, FunctionDecl *
                 return;
 
             ParmVarDecl *param = funcParams[parmIndex];
-            QualType paramQt = TypeUtils::unrefQualType(param->getType());
+            QualType paramQt = clazy::unrefQualType(param->getType());
 
             const bool isConst = paramQt.isConstQualified();
 
@@ -195,7 +195,7 @@ void FunctionArgsByRef::VisitStmt(Stmt *stmt)
     }
 }
 
-clang::FixItHint FunctionArgsByRef::fixit(const ParmVarDecl *, TypeUtils::QualTypeClassification)
+clang::FixItHint FunctionArgsByRef::fixit(const ParmVarDecl *, clazy::QualTypeClassification)
 {
     FixItHint fixit;
     return fixit;
diff --git a/src/checks/level2/function-args-by-ref.h b/src/checks/level2/function-args-by-ref.h
index 1819c4d1..631b82e7 100644
--- a/src/checks/level2/function-args-by-ref.h
+++ b/src/checks/level2/function-args-by-ref.h
@@ -40,7 +40,7 @@ class FunctionDecl;
 class Stmt;
 }
 
-namespace TypeUtils {
+namespace clazy {
 struct QualTypeClassification;
 }
 
@@ -58,7 +58,7 @@ public:
 private:
     void processFunction(clang::FunctionDecl *);
     void addFixits(std::vector<clang::FixItHint> &fixits, clang::FunctionDecl *, unsigned int parmIndex);
-    clang::FixItHint fixit(const clang::ParmVarDecl *, TypeUtils::QualTypeClassification);
+    clang::FixItHint fixit(const clang::ParmVarDecl *, clazy::QualTypeClassification);
 };
 
 #endif
diff --git a/src/checks/level2/function-args-by-value.cpp b/src/checks/level2/function-args-by-value.cpp
index b302f876..481b8d86 100644
--- a/src/checks/level2/function-args-by-value.cpp
+++ b/src/checks/level2/function-args-by-value.cpp
@@ -145,7 +145,7 @@ void FunctionArgsByValue::processFunction(FunctionDecl *func)
     int i = -1;
     for (auto param : Utils::functionParameters(func)) {
         i++;
-        const QualType paramQt = TypeUtils::unrefQualType(param->getType());
+        const QualType paramQt = clazy::unrefQualType(param->getType());
         const Type *paramType = paramQt.getTypePtrOrNull();
         if (!paramType || paramType->isIncompleteType() || paramType->isDependentType())
             continue;
@@ -153,8 +153,8 @@ void FunctionArgsByValue::processFunction(FunctionDecl *func)
         if (shouldIgnoreClass(paramType->getAsCXXRecordDecl()))
             continue;
 
-        TypeUtils::QualTypeClassification classif;
-        bool success = TypeUtils::classifyQualType(m_context, param->getType(), param, classif, body);
+        clazy::QualTypeClassification classif;
+        bool success = clazy::classifyQualType(m_context, param->getType(), param, classif, body);
         if (!success)
             continue;
 
@@ -199,9 +199,9 @@ void FunctionArgsByValue::processFunction(FunctionDecl *func)
 }
 
 FixItHint FunctionArgsByValue::fixit(FunctionDecl *func, const ParmVarDecl *param,
-                                     TypeUtils::QualTypeClassification)
+                                     clazy::QualTypeClassification)
 {
-    QualType qt = TypeUtils::unrefQualType(param->getType());
+    QualType qt = clazy::unrefQualType(param->getType());
     qt.removeLocalConst();
     const string typeName = qt.getAsString(PrintingPolicy(lo()));
     string replacement = typeName + ' ' + string(clazy::name(param));
diff --git a/src/checks/level2/function-args-by-value.h b/src/checks/level2/function-args-by-value.h
index d39ca65e..c29d6d41 100644
--- a/src/checks/level2/function-args-by-value.h
+++ b/src/checks/level2/function-args-by-value.h
@@ -37,7 +37,7 @@ class FunctionDecl;
 class ParmVarDecl;
 }
 
-namespace TypeUtils {
+namespace clazy {
 struct QualTypeClassification;
 }
 
@@ -56,7 +56,7 @@ public:
 private:
     void processFunction(clang::FunctionDecl *);
     clang::FixItHint fixit(clang::FunctionDecl *func, const clang::ParmVarDecl *param,
-                           TypeUtils::QualTypeClassification);
+                           clazy::QualTypeClassification);
 };
 
 #endif
diff --git a/src/checks/level2/rule-of-three.cpp b/src/checks/level2/rule-of-three.cpp
index 171d929d..8db55d53 100644
--- a/src/checks/level2/rule-of-three.cpp
+++ b/src/checks/level2/rule-of-three.cpp
@@ -132,7 +132,7 @@ void RuleOfThree::VisitDecl(clang::Decl *decl)
         }
     }
 
-    if (!hasUserDtor && (TypeUtils::derivesFrom(record, "QSharedData") || dtorDefaultedByUser))
+    if (!hasUserDtor && (clazy::derivesFrom(record, "QSharedData") || dtorDefaultedByUser))
         return;
 
     if (Utils::hasMember(record, "QSharedDataPointer"))
diff --git a/src/checks/level2/static-pmf.cpp b/src/checks/level2/static-pmf.cpp
index bfaf377b..6c239a0c 100644
--- a/src/checks/level2/static-pmf.cpp
+++ b/src/checks/level2/static-pmf.cpp
@@ -48,7 +48,7 @@ void StaticPmf::VisitDecl(clang::Decl *decl)
     if (!vardecl || !vardecl->isStaticLocal())
         return;
 
-    const Type *t = TypeUtils::unpealAuto(vardecl->getType());
+    const Type *t = clazy::unpealAuto(vardecl->getType());
     if (!t)
         return;
 
diff --git a/src/checks/manuallevel/heap-allocated-small-trivial-type.cpp b/src/checks/manuallevel/heap-allocated-small-trivial-type.cpp
index a730b7c2..cc132402 100644
--- a/src/checks/manuallevel/heap-allocated-small-trivial-type.cpp
+++ b/src/checks/manuallevel/heap-allocated-small-trivial-type.cpp
@@ -47,7 +47,7 @@ void HeapAllocatedSmallTrivialType::VisitStmt(clang::Stmt *stmt)
         return;
 
     QualType qualType = newExpr->getType()->getPointeeType();
-    if (TypeUtils::isSmallTrivial(m_context, qualType)) {
+    if (clazy::isSmallTrivial(m_context, qualType)) {
         if (clazy::contains(qualType.getAsString(), "Private")) {
             // Possibly a pimpl, forward declared in header
             return;
diff --git a/src/checks/manuallevel/qhash-with-char-pointer-key.cpp b/src/checks/manuallevel/qhash-with-char-pointer-key.cpp
index f8d3c010..5ea5ac5a 100644
--- a/src/checks/manuallevel/qhash-with-char-pointer-key.cpp
+++ b/src/checks/manuallevel/qhash-with-char-pointer-key.cpp
@@ -54,7 +54,7 @@ void QHashWithCharPointerKey::VisitDecl(clang::Decl *decl)
 
     QualType qt = templateArguments[0].getAsType();
     if (!qt.isNull() && qt->isPointerType()) {
-        qt = TypeUtils::pointeeQualType(qt);
+        qt = clazy::pointeeQualType(qt);
         if (!qt.isNull() && !qt->isPointerType() && qt->isCharType()) {
             emitWarning(clazy::getLocStart(decl), "Using QHash<const char *, T> is dangerous");
         }
diff --git a/src/checks/manuallevel/thread-with-slots.cpp b/src/checks/manuallevel/thread-with-slots.cpp
index c6b690fd..66da812e 100644
--- a/src/checks/manuallevel/thread-with-slots.cpp
+++ b/src/checks/manuallevel/thread-with-slots.cpp
@@ -49,7 +49,7 @@ static bool hasMutexes(Stmt *body)
     auto declrefs = clazy::getStatements<DeclRefExpr>(body);
     for (auto declref : declrefs) {
         ValueDecl *valueDecl = declref->getDecl();
-        if (CXXRecordDecl *record = TypeUtils::typeAsRecord(valueDecl->getType())) {
+        if (CXXRecordDecl *record = clazy::typeAsRecord(valueDecl->getType())) {
             if (clazy::name(record) == "QMutex" || clazy::name(record) == "QBasicMutex") {
                 return true;
             }
@@ -78,7 +78,7 @@ void ThreadWithSlots::VisitStmt(clang::Stmt *stmt)
         return;
 
     CXXMethodDecl *slot =  clazy::receiverMethodForConnect(callExpr);
-    if (!slot || !TypeUtils::derivesFrom(slot->getParent(), "QThread"))
+    if (!slot || !clazy::derivesFrom(slot->getParent(), "QThread"))
         return;
 
     if (clazy::name(slot->getParent()) == "QThread") // The slots in QThread are thread safe, we're only worried about derived classes
@@ -97,7 +97,7 @@ void ThreadWithSlots::VisitDecl(Decl *decl)
 
     auto method = dyn_cast<CXXMethodDecl>(decl);
     if (!method || !m_context->accessSpecifierManager || !method->isThisDeclarationADefinition() || !method->hasBody()
-        || !TypeUtils::derivesFrom(method->getParent(), "QThread"))
+        || !clazy::derivesFrom(method->getParent(), "QThread"))
         return;
 
     // The slots in QThread are thread safe, we're only worried about derived classes:
@@ -118,7 +118,7 @@ void ThreadWithSlots::VisitDecl(Decl *decl)
     auto memberexprs = clazy::getStatements<MemberExpr>(body);
     for (auto memberexpr : memberexprs) {
         ValueDecl *valueDecl = memberexpr->getMemberDecl();
-        if (CXXRecordDecl *record = TypeUtils::typeAsRecord(valueDecl->getType())) {
+        if (CXXRecordDecl *record = clazy::typeAsRecord(valueDecl->getType())) {
             if (clazy::name(record) == "QMutex" || clazy::name(record) == "QBasicMutex") {
                 return;
             }
diff --git a/src/checks/manuallevel/unneeded-cast.cpp b/src/checks/manuallevel/unneeded-cast.cpp
index d83630f3..46c90b98 100644
--- a/src/checks/manuallevel/unneeded-cast.cpp
+++ b/src/checks/manuallevel/unneeded-cast.cpp
@@ -116,7 +116,7 @@ bool UnneededCast::maybeWarn(Stmt *stmt, CXXRecordDecl *castFrom, CXXRecordDecl
     if (castFrom == castTo) {
         emitWarning(clazy::getLocStart(stmt), "Casting to itself");
         return true;
-    } else if (TypeUtils::derivesFrom(/*child=*/ castFrom, castTo)) {
+    } else if (clazy::derivesFrom(/*child=*/ castFrom, castTo)) {
         emitWarning(clazy::getLocStart(stmt), "explicitly casting to base is unnecessary");
         return true;
     }