diff --git a/clang-tools-extra/CMakeLists.txt b/clang-tools-extra/CMakeLists.txt
--- a/clang-tools-extra/CMakeLists.txt
+++ b/clang-tools-extra/CMakeLists.txt
@@ -8,6 +8,7 @@
 add_subdirectory(modularize)
 add_subdirectory(clang-tidy)
 
+add_subdirectory(clang-cast)
 add_subdirectory(clang-change-namespace)
 add_subdirectory(clang-doc)
 add_subdirectory(clang-include-fixer)
diff --git a/clang-tools-extra/clang-cast/CMakeLists.txt b/clang-tools-extra/clang-cast/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/CMakeLists.txt
@@ -0,0 +1,14 @@
+set(LLVM_LINK_COMPONENTS
+        support)
+
+add_clang_tool(clang-cast
+  ClangCast.cpp
+  )
+
+target_link_libraries(clang-cast
+  PRIVATE
+  clangTooling
+  clangBasic
+  clangRewriteFrontend
+  clangASTMatchers
+  )
diff --git a/clang-tools-extra/clang-cast/Cast.h b/clang-tools-extra/clang-cast/Cast.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/Cast.h
@@ -0,0 +1,497 @@
+//===--- Cast.h - clang-cast ------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains classes that manage semantics of C style casts.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CAST_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CAST_H
+
+#include "CastOptions.h"
+#include "CastUtils.h"
+#include "clang/AST/OperationKinds.h"
+#include <exception>
+
+//===----------------------------------------------------------------------===//
+// CStyleCastOperation
+//===----------------------------------------------------------------------===//
+
+namespace clang {
+namespace cppcast {
+
+/// CStyleCastOperation is responsible for capturing a CStyleCastExpr AST node
+/// and perform some basic semantic analysis on the C style cast's equivalent in
+/// C++ explicit cast expressions.
+///
+/// This class does not have any ownership semantics for the CStyleCastExpr
+/// itself, nor does it have ownership semantics for the underlying Context that
+/// the CStyleCastExpr is from.
+///
+/// Note that although some functions are similar to the Sema library, such as
+/// CastsAwayConstness vs. requireConstCast, it is a much simpler version as we
+/// assume compilation is successful and we are restricted to C++. The reason
+/// Sema was not used here is because the anonymous namespaces and static
+/// visibility of the original functions require leaking existing abstractions
+/// and a large refactoring in the fundamental Clang codebase.
+class CStyleCastOperation {
+  /// The main expression captured by a matcher
+  const CStyleCastExpr &MainExpr;
+
+  /// The subexpression type in the C style cast.
+  /// For example:
+  /// \code
+  /// (int) 3.2f;
+  /// \endcode
+  ///
+  /// the subexpression is 3.2f, and its type is float.
+  const QualType SubExprType;
+
+  /// The cast type in the C style cast.
+  /// For example:
+  /// \code
+  /// (int) 3.2f;
+  /// \endcode
+  ///
+  /// the cast type is int.
+  const QualType CastType;
+
+  /// The context that the CStyleCastExpr belongs to.
+  const ASTContext &Context;
+
+  /// The engine in the context responsible for printing diagnostics
+  const DiagnosticsEngine &DiagEngine;
+
+  /// Whether or not the generated code should comply with -pedantic
+  const bool Pedantic;
+
+public:
+  /// Initializes a new CStyleCastOperation
+  /// \param CastExpr node to perform semantic analysis on
+  /// \param Context the context that CastExpr belongs to
+  /// \param Pedantic whether we should generate code that complies with
+  /// -pedantic and -pedantic-errors
+  ///
+  /// Note that we are canonicalizing the subexpression and cast types. We don't
+  /// yet provide typedef-preserving code generation.
+  CStyleCastOperation(const CStyleCastExpr &CastExpr, const ASTContext &Context,
+                      const bool Pedantic)
+      : MainExpr(CastExpr),
+        SubExprType(
+            CastExpr.getSubExprAsWritten()->getType().getCanonicalType()),
+        CastType(CastExpr.getTypeAsWritten().getCanonicalType()),
+        Context(Context), DiagEngine(Context.getDiagnostics()),
+        Pedantic(Pedantic) {}
+
+  CStyleCastOperation() = delete;
+  CStyleCastOperation(const CStyleCastOperation &) = delete;
+  CStyleCastOperation(CStyleCastOperation &&) = delete;
+  CStyleCastOperation &operator=(const CStyleCastOperation &) = delete;
+  CStyleCastOperation &operator=(CStyleCastOperation &&) = delete;
+  virtual ~CStyleCastOperation() = default;
+
+  /// public accessor methods, some of which return reference handles.
+  QualType getSubExprType() const { return SubExprType; }
+  QualType getCastType() const { return CastType; }
+  const CStyleCastExpr &getCStyleCastExpr() const { return MainExpr; }
+  const Expr &getSubExprAsWritten() const {
+    return *MainExpr.getSubExprAsWritten();
+  }
+  const ASTContext &getContext() const { return Context; }
+
+  /// This method tests to see whether the conversion from SubExprType to
+  /// CastType is "casting away constness", as the standard describes.
+  ///
+  /// The standard states that a conversion is casting away constness when there
+  /// exists a cv-decomposition such that there exists no implicit qualification
+  /// conversion from SubExprType to CastType.
+  ///
+  /// Clang, without -pedantic or -pedantic-error, allows a few exceptional
+  /// cases, such as when two nested pointers diverge in type (pointer vs.
+  /// array, for example), and the rest of the qualifiers are ignored in the
+  /// cast-away-constness consideration. (exception: two member-pointers that
+  /// are pointers to different classes are considered the same "type").
+  ///
+  /// Some other notable exceptions include variable-length arrays (VLA) being
+  /// used in non-pedantic codebases, which we also allow.
+  bool requireConstCast() const;
+
+  /// This converts From(the cast type) into To(subexpression type)'s qualifiers
+  /// to prepare for const_cast.
+  /// \return QualType corresponding to CastType but with minimal qualifiers to
+  /// satisfy for a non-pedantic conversion.
+  ///
+  /// For example:
+  /// \code
+  /// const int* const (* const x) [2];
+  /// (int***) x;
+  /// \endcode
+  ///
+  /// will yield (int* const* const* const) for typical, non-pedantic usage
+  /// because const_cast will only modify the qualifiers where they are
+  /// both locally similar (they stop being similar at array vs. pointer).
+  ///
+  /// We need this to first perform static/reinterpret casts and then const
+  /// cast. In order to do this, we must take the cast type and change its
+  /// qualifiers so that it can be performed by static/reinterpret cast first.
+  ///
+  /// NOTE: There is only one case where we'd need to modify qualifiers and that
+  /// is for function pointers. Const cast cannot change qualifiers on function
+  /// pointers.
+  QualType changeQualifiers() const {
+    return changeQualifierHelper(CastType, SubExprType);
+  }
+
+  /// Given the CStyleCastExpr, determine from its CastKind and other metadata
+  /// to decide what kind of C++ style cast is appropriate, if any. This does
+  /// not take into consideration const_cast and qualifiers. Use
+  /// requireConstCast() to determine whether const_cast should be added.
+  ///
+  /// \return CXXCast corresponding to the type of conversion.
+  CXXCast getCastKindFromCStyleCast() const { return castHelper(&MainExpr); }
+
+private:
+  /// Auxilliary diagnostic methods
+  void warnMemberPointerClass(const QualType &SEType,
+                              const QualType &CType) const;
+  void errorPedanticVLA(const QualType &T) const;
+
+  /// \param SEType, a copy of QualType subexpression
+  /// \param CType, a copy of QualType cast type
+  /// \return true if the const was casted away, false otherwise.
+  ///
+  /// IMPORTANT: We are assuming that reinterpret_cast will have already taken
+  /// care of the downcasting of nested function pointers, and if we have nested
+  /// function pointers, they have the same qualifiers.
+  bool castAwayConst(const QualType &SEType, const QualType &CType) const;
+
+  /// \param From, the CastType, which needs to be modified to not require const
+  /// cast
+  /// \param To, the SubExpression, which has specific qualifiers on it.
+  /// \return QualType mirroring From but with qualifiers on To.
+  QualType changeQualifierHelper(QualType From, const QualType &To) const;
+
+  /// Recurse CastExpr AST nodes until a non-cast expression has been reached.
+  /// \return CXXCast enum corresponding to the lowest power cast required.
+  CXXCast castHelper(const Expr *Expression) const;
+
+  /// Given a CastExpr, determine from its CastKind and other metadata
+  /// the corresponding CXXCast to use (NOTE: this does not include
+  ///     the additional const cast for qualifiers if it is
+  ///     static/interpret. Use isQualifierModified for that.)
+  /// Note that it's a CastExpr, which can be either CStyleCastExpr
+  /// or ImplicitCastExpr or any of its children.
+  ///
+  /// \return CXXCast corresponding to the type of conversion.
+  CXXCast getCastType(const CastExpr *CastExpression) const;
+};
+
+bool CStyleCastOperation::requireConstCast() const {
+  // Case 0 - We just cannot cast function pointers at the very beginning,
+  // regardless of whether it's being downcasted or not.
+  if (details::isFunctionPtr(CastType) || details::isFunctionPtr(SubExprType)) {
+    return false;
+  }
+
+  // We modify the types for references
+  // Note that for our subexpr type, we use the type post-implicit conv.
+  QualType ModifiedImpliedSubExprType =
+      MainExpr.getSubExpr()->getType().getCanonicalType();
+  QualType ModifiedCastType = CastType;
+
+  // Case 1 - reference type:
+  // remove the reference from both the subexpr and cast and add a pointer
+  // level.
+  if (ModifiedCastType->isReferenceType()) {
+    ModifiedCastType = ModifiedCastType.getNonReferenceType();
+    if (ModifiedImpliedSubExprType->isReferenceType()) {
+      ModifiedImpliedSubExprType =
+          ModifiedImpliedSubExprType.getNonReferenceType();
+    }
+    ModifiedCastType = Context.getPointerType(ModifiedCastType);
+    ModifiedImpliedSubExprType =
+        Context.getPointerType(ModifiedImpliedSubExprType);
+  }
+
+  // Case 2, 3 - pointer type & POD type
+  // if the pointer qualifiers are downcasted at any level, then fail.
+  // if the POD qualifiers are downcasted, then fail.
+  return castAwayConst(ModifiedImpliedSubExprType, ModifiedCastType);
+}
+
+void CStyleCastOperation::warnMemberPointerClass(const QualType &SEType,
+                                                 const QualType &CType) const {
+  // Auxilliary: If the member pointers classes are
+  // not the same, issue a warning.
+  if (SEType->isMemberPointerType() && CType->isMemberPointerType()) {
+    const MemberPointerType *MPSEType = dyn_cast<MemberPointerType>(SEType);
+    const Type *SEClass = MPSEType->getClass();
+
+    const MemberPointerType *MPCType = dyn_cast<MemberPointerType>(CType);
+    const Type *CClass = MPCType->getClass();
+
+    if (SEClass->getCanonicalTypeUnqualified() !=
+        CClass->getCanonicalTypeUnqualified()) {
+      reportWithLoc(
+          Context.getDiagnostics(), DiagnosticsEngine::Warning,
+          "C style cast performs a member-to-pointer cast from class %0 to "
+          "%1, which are not equal",
+          MainExpr.getExprLoc(), QualType(SEClass, /*Quals=*/0),
+          QualType(CClass, /*Quals=*/0));
+    }
+  }
+}
+
+void CStyleCastOperation::errorPedanticVLA(const QualType &T) const {
+  if (!Pedantic)
+    return;
+  // Auxilliary: If the type is variable length arrays (VLA)s, it should raise
+  // warnings under --pedantic
+  if (T->isVariableArrayType()) {
+    reportWithLoc(Context.getDiagnostics(), DiagnosticsEngine::Error,
+                  "detected variable length array %0 with --pedantic enabled",
+                  MainExpr.getExprLoc(), T);
+  }
+}
+
+bool CStyleCastOperation::castAwayConst(const QualType &SEType,
+                                        const QualType &CType) const {
+  if (SEType.isMoreQualifiedThan(CType)) {
+    return true;
+  }
+
+  // If we follow clang's extensions, then the moment something is not locally
+  // similar, we consider the source and destination types not equal and so we
+  // can return false for any nested levels.
+  if (!details::isLocallySimilar(SEType, CType) && !Pedantic)
+    return false;
+
+  // Auxiliary warnings during parsing
+  warnMemberPointerClass(SEType, CType);
+  errorPedanticVLA(SEType);
+  errorPedanticVLA(CType);
+
+  if (details::isTerminal(SEType, CType))
+    return false;
+
+  QualType SEStrippedType = details::stripLayer(SEType, Context);
+  QualType CStrippedType = details::stripLayer(CType, Context);
+
+  // Continue recursing for pointer types
+  return castAwayConst(SEStrippedType, CStrippedType);
+}
+
+QualType CStyleCastOperation::changeQualifierHelper(QualType From,
+                                                    const QualType &To) const {
+  // If it's a function pointer, then we don't change the qualifier and we've
+  // reached the end.
+  if (details::isFunctionPtr(From))
+    return From;
+
+  // We're changing qualifiers because it'd be casting away constness.
+  // If we follow the standard, we could be casting away constness down to the
+  // terminal level.
+  // If we follow clang's extensions, we could be casting away constness until
+  // we've reached a non-similar stage.
+  if ((!details::isLocallySimilar(From, To) && !Pedantic) ||
+      details::isTerminal(From, To)) {
+    From.setLocalFastQualifiers(To.getLocalFastQualifiers());
+    return From;
+  }
+
+  auto StrippedTo = details::stripLayer(To, Context);
+  auto StrippedFrom = details::stripLayer(From, Context);
+
+  auto Temp = changeQualifierHelper(StrippedFrom, StrippedTo);
+  // If they are locally similar and non-terminal, we can keep going down
+  if (From->isPointerType()) {
+    // modify the nested types
+    From = Context.getPointerType(Temp);
+  } else if (From->isMemberPointerType()) {
+    const MemberPointerType *MPT = dyn_cast<MemberPointerType>(From);
+    const Type *FromClass = MPT->getClass();
+    // modify the nested types
+    From = Context.getMemberPointerType(Temp, FromClass);
+  } else if (From->isConstantArrayType()) {
+    const ConstantArrayType *AT = dyn_cast<ConstantArrayType>(From);
+    // Don't assign yet because we need to change the qualifiers
+    From = Context.getConstantArrayType(Temp, AT->getSize(), AT->getSizeExpr(),
+                                        AT->getSizeModifier(),
+                                        AT->getIndexTypeCVRQualifiers());
+  } else if (From->isIncompleteArrayType()) {
+    const IncompleteArrayType *IAT = dyn_cast<IncompleteArrayType>(From);
+    From = Context.getIncompleteArrayType(Temp, IAT->getSizeModifier(),
+                                          IAT->getIndexTypeCVRQualifiers());
+  } else if (From->isVariableArrayType()) {
+    // The following can only work if we're not in --pedantic
+    const VariableArrayType *VAT = dyn_cast<VariableArrayType>(From);
+    Context.getVariableArrayType(
+        Temp, VAT->getSizeExpr(), VAT->getSizeModifier(),
+        VAT->getIndexTypeCVRQualifiers(), VAT->getBracketsRange());
+  }
+  // Unwrap the references and reconstruct them
+  // but we don't need to strip To here (lvalue-to-rvalue would've already
+  // happened)
+  else if (From->isLValueReferenceType()) {
+    From = Context.getLValueReferenceType(Temp);
+  } else if (From->isRValueReferenceType()) {
+    From = Context.getRValueReferenceType(Temp);
+  }
+
+  From.setLocalFastQualifiers(To.getLocalFastQualifiers());
+  return From;
+}
+
+CXXCast CStyleCastOperation::castHelper(const Expr *Expression) const {
+  const auto *CastExpression = dyn_cast<CastExpr>(Expression);
+
+  // Base case - we have reached an expression that's not a CastExpr
+  if (!CastExpression) {
+    return CXXCast::CC_NoOpCast;
+  }
+
+  // If it's a cast expression but is not a part of the explicit c-style cast,
+  // we've also gone too far.
+  const auto *ImplicitCastExpression = dyn_cast<ImplicitCastExpr>(Expression);
+
+  if (ImplicitCastExpression &&
+      !ImplicitCastExpression->isPartOfExplicitCast()) {
+    return CXXCast::CC_NoOpCast;
+  }
+
+  return std::max(getCastType(CastExpression),
+                  castHelper(CastExpression->getSubExpr()));
+}
+
+CXXCast CStyleCastOperation::getCastType(const CastExpr *CastExpression) const {
+  switch (CastExpression->getCastKind()) {
+  /// No-op cast type
+  case CastKind::CK_NoOp:
+  case CastKind::CK_ArrayToPointerDecay:
+  case CastKind::CK_LValueToRValue:
+    return CXXCast::CC_NoOpCast;
+
+  // Static cast (with extension) types
+  case CastKind::CK_UncheckedDerivedToBase:
+  case CastKind::CK_DerivedToBase: {
+    /// Special case:
+    /// The base class A is inaccessible (private)
+    /// so we can't static_cast. We can't reinterpret_cast
+    /// either because reinterpret casting to A* would point
+    /// to the data segment owned by Pad. We can't convert to C style
+    /// in this case.
+    ///
+    /// \code
+    /// struct A { int i; };
+    /// struct Pad { int i; };
+    /// class B: Pad, A {};
+    ///
+    /// A *f(B *b) { return (A*)(b); }
+    /// \endcode
+    ///
+    /// We assume that the base class is unambiguous.
+    const CXXRecordDecl *Base = CastType->getPointeeCXXRecordDecl();
+    const CXXRecordDecl *Derived = SubExprType->getPointeeCXXRecordDecl();
+    return details::getBaseDerivedCast(Base, Derived);
+  }
+  case CastKind::CK_BaseToDerived: {
+    const CXXRecordDecl *Base = SubExprType->getPointeeCXXRecordDecl();
+    const CXXRecordDecl *Derived = CastType->getPointeeCXXRecordDecl();
+    return details::getBaseDerivedCast(Base, Derived);
+  }
+  case CastKind::CK_FunctionToPointerDecay:
+  case CastKind::CK_NullToPointer:
+  case CastKind::CK_NullToMemberPointer:
+  case CastKind::CK_BaseToDerivedMemberPointer:
+  case CastKind::CK_DerivedToBaseMemberPointer:
+  case CastKind::CK_MemberPointerToBoolean:
+  case CastKind::CK_UserDefinedConversion:
+  case CastKind::CK_ConstructorConversion:
+  case CastKind::CK_PointerToBoolean:
+  case CastKind::CK_ToVoid:
+  // vector splats are constant size vectors that can be
+  // broadcast assigned a single value.
+  case CastKind::CK_VectorSplat:
+  // Common integral/float cast types
+  case CastKind::CK_IntegralCast:
+  case CastKind::CK_IntegralToBoolean:
+  case CastKind::CK_IntegralToFloating:
+  case CastKind::CK_FixedPointCast:
+  case CastKind::CK_FixedPointToIntegral:
+  case CastKind::CK_IntegralToFixedPoint:
+  case CastKind::CK_FixedPointToBoolean:
+  case CastKind::CK_FloatingToIntegral:
+  case CastKind::CK_FloatingToBoolean:
+  case CastKind::CK_BooleanToSignedIntegral:
+  case CastKind::CK_FloatingCast:
+  // Floating complex cast types
+  case CastKind::CK_FloatingRealToComplex:
+  case CastKind::CK_FloatingComplexToReal:
+  case CastKind::CK_FloatingComplexToBoolean:
+  case CastKind::CK_FloatingComplexCast:
+  case CastKind::CK_FloatingComplexToIntegralComplex:
+  // Integral complex cast types
+  case CastKind::CK_IntegralRealToComplex:
+  case CastKind::CK_IntegralComplexToReal:
+  case CastKind::CK_IntegralComplexToBoolean:
+  case CastKind::CK_IntegralComplexCast:
+  case CastKind::CK_IntegralComplexToFloatingComplex:
+  // Atomic to non-atomic casts
+  case CastKind::CK_AtomicToNonAtomic:
+  case CastKind::CK_NonAtomicToAtomic:
+  // OpenCL casts
+  // https://godbolt.org/z/DEz8Rs
+  case CastKind::CK_ZeroToOCLOpaqueType:
+  case CastKind::CK_AddressSpaceConversion:
+  case CastKind::CK_IntToOCLSampler:
+    return CXXCast::CC_StaticCast;
+
+  // Reinterpret cast types
+  case CastKind::CK_BitCast:
+  case CastKind::CK_LValueBitCast:
+  case CastKind::CK_IntegralToPointer:
+  case CastKind::CK_LValueToRValueBitCast:
+  case CastKind::CK_ReinterpretMemberPointer:
+  case CastKind::CK_PointerToIntegral:
+    return CXXCast::CC_ReinterpretCast;
+
+  // C style cast types
+  // Dependent types are left as they are.
+  case CastKind::CK_Dependent:
+    return CXXCast::CC_CStyleCast;
+
+  // Invalid cast types for C++
+  // Union casts is not available in C++.
+  case CastKind::CK_ToUnion:
+  // Built-in functions must be directly called and don't have
+  // address. This is impossible for C style casts.
+  case CastKind::CK_BuiltinFnToFnPtr:
+  // C++ does not officially support the Objective C extensions.
+  // We mark these as invalid.
+  // - Objective C pointer types &
+  // - Objective C automatic reference counting (ARC)
+  // - Objective C blocks
+  // - etc
+  case CastKind::CK_CPointerToObjCPointerCast:
+  case CastKind::CK_BlockPointerToObjCPointerCast:
+  case CastKind::CK_AnyPointerToBlockPointerCast:
+  case CastKind::CK_ObjCObjectLValueCast:
+  case CastKind::CK_ARCProduceObject:
+  case CastKind::CK_ARCConsumeObject:
+  case CastKind::CK_ARCReclaimReturnedObject:
+  case CastKind::CK_ARCExtendBlockObject:
+  case CastKind::CK_CopyAndAutoreleaseBlockObject:
+  default:
+    return CXXCast::CC_InvalidCast;
+  }
+}
+
+} // namespace cppcast
+} // namespace clang
+#endif
diff --git a/clang-tools-extra/clang-cast/CastOptions.h b/clang-tools-extra/clang-cast/CastOptions.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/CastOptions.h
@@ -0,0 +1,190 @@
+//===--- CastOptions.h - clang-cast -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the enumerations and options that dictate behavior of
+/// the Matcher object defined in Matcher.h.
+///
+//===----------------------------------------------------------------------===//
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CAST_OPTIONS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CAST_OPTIONS_H
+
+#include "clang/Rewrite/Frontend/FixItRewriter.h"
+#include <string>
+
+namespace clang {
+namespace cppcast {
+
+/// Enumerations for cast types
+/// The ordering of these enums is important.
+///
+/// C style casts in clang are performed incrementally:
+/// - CStyleCastExpr
+///   - ImplicitCastExpr
+///     - ImplicitCastExpr
+///     ...
+///       - DeclRefExpr (for example)
+///
+/// Each one of the cast exprs may require a more "powerful" level of
+/// casting. With the exception of dynamic cast, the rest are ordered
+/// accordingly.
+///
+/// CC_DynamicCast
+/// --------------
+/// \code
+/// dynamic_cast<Base*>(derived_ptr);
+/// \endcode
+///
+/// A conversion from Base to Derived or vice versa that is
+/// performed at RUNTIME. This is not possible to be expressed
+/// in terms of C style casts.
+///
+/// CC_NoOpCast
+/// -----------
+/// This is either a cast to itself or an implicit conversion that
+/// can be done without casting.
+///
+/// CC_ConstCast
+/// ------------
+/// \code
+/// int x = 1;
+/// const int& y = x;
+/// const_cast<int&>(y);
+/// \endcode
+///
+/// A conversion from the same type but with different qualifiers on the
+/// multilevel pointer-array structure.
+///
+/// CC_StaticCast
+/// -------------
+/// \code
+/// static_cast<int>(true);
+/// \endcode
+///
+/// Static cast can perform logical conversions between types,
+/// call explicitly defined conversion functions such as operator(),
+/// and cast up and down an inheritance hierarchy (given access),
+/// and more.
+///
+/// CC_ReinterpretCast
+/// ------------------
+/// \code
+/// int* x;
+/// (bool*) x;
+/// \endcode
+///
+/// The above is a bitcast, and is generally the theme of reinterpret cast.
+/// We reinterpret the bits of the data type into something else. This cast
+/// will only cast A to B if sizeof(A) <= sizeof(B). Out of all the C++ casts,
+/// this is the most "rule-breaking" and dangerous, and should be used
+/// very sparingly.
+///
+/// CC_CStyleCast
+/// -------------
+/// \code
+/// template <typename T>
+/// void foo() {
+///     (T) 0;
+/// }
+/// \endcode
+///
+/// There are some cases where none of the above casts are possible,
+/// or suitable for replacement for C style casts, such as when
+/// static_cast cannot cast DerivedToBase due to insufficient access,
+/// or C style casting dependent (template) types (which can be any type
+/// enumerated above, including the DerivedToBase case). It is generally
+/// good to convert all C style casts to something of lower power, but
+/// sometimes it's not possible without losing power.
+///
+/// CC_InvalidCast
+/// --------------
+/// This maps to the set of CastKind::CK_* that are not possible to
+/// generate in C++. If this enum is encountered, something is wrong.
+///
+/// NOTE: We are using enums instead of enum-classes for the following reasons:
+/// - We can't use convenience functions from llvm CommandLine.h to define
+/// lists.
+/// - we want to make these these values bitmasks for inclusivity testing, and
+///   there is no implicit conversion from enum-class values to integral types.
+enum CXXCast {
+  CC_DynamicCast = 0b1,
+  CC_NoOpCast = 0b10,
+  CC_ConstCast = 0b100,
+  CC_StaticCast = 0b1000,
+  CC_ReinterpretCast = 0b10000,
+  CC_CStyleCast = 0b100000,
+  CC_InvalidCast = 0b1000000,
+};
+
+} // namespace cppcast
+
+namespace cli {
+
+using clang::cppcast::CXXCast;
+
+/// Options for CLI to specify which of the following should raise an error
+/// upon encountering CStyleCast with equivalent power.
+///
+/// NOTE: If a C style cast requires both const and static, having EO_StaticCast
+/// is sufficient to trigger an error.
+enum ErrorOpts {
+  EO_StaticCast = CXXCast::CC_StaticCast,
+  EO_ReinterpretCast = CXXCast::CC_ReinterpretCast,
+  EO_ConstCast = CXXCast::CC_ConstCast,
+  EO_CStyleCast = CXXCast::CC_CStyleCast,
+  EO_NoOpCast = CXXCast::CC_NoOpCast,
+  EO_All = 0xffffffff,
+};
+
+/// Options for CLI to specify which of C style casts should be fixed with
+/// FixItWriters.
+///
+/// NOTE: If a C style cast requires both const and static, it is required to
+/// have the bits of 'FO_StaticCast | FO_ConstCast' in the mask to apply a fix.
+enum FixOpts {
+  FO_StaticCast = CXXCast::CC_StaticCast,
+  FO_ReinterpretCast = CXXCast::CC_ReinterpretCast,
+  FO_ConstCast = CXXCast::CC_ConstCast,
+  // NOTE: There is no "fix_cstyle" because we can't fix them.
+  FO_NoOpCast = CXXCast::CC_NoOpCast,
+  FO_All = 0xffffffff,
+};
+
+} // namespace cli
+
+namespace rewriter {
+
+/// Custom FixItOptions to allow users to emit to files with added suffix.
+class FixItRewriterOptions : public clang::FixItOptions {
+public:
+  FixItRewriterOptions(const std::string &RewriteSuffix)
+      : RewriteSuffix(RewriteSuffix) {
+    if (RewriteSuffix.empty()) {
+      InPlace = true;
+    } else {
+      InPlace = false;
+    }
+    FixWhatYouCan = true;
+  }
+
+  std::string RewriteFilename(const std::string &Filename, int &fd) override {
+    // Set fd to -1 to mean that the file descriptor is not yet opened.
+    fd = -1;
+    const auto NewFilename = Filename + RewriteSuffix;
+    return NewFilename;
+  }
+
+private:
+  std::string RewriteSuffix;
+};
+
+} // namespace rewriter
+
+} // namespace clang
+
+#endif
diff --git a/clang-tools-extra/clang-cast/CastUtils.h b/clang-tools-extra/clang-cast/CastUtils.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/CastUtils.h
@@ -0,0 +1,195 @@
+//===--- CastUtils.h - clang-cast -------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains utility functions for semantics and diagnostics.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CAST_UTILS_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CAST_UTILS_H
+
+#include "CastOptions.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/DeclCXX.h"
+
+namespace clang {
+namespace cppcast {
+
+/// Given a cast type enum of the form CXXCasts::CC_{type}, return the
+/// string representation of that respective type.
+std::string cppCastToString(const CXXCast &Cast) {
+  switch (Cast) {
+  case CXXCast::CC_ConstCast:
+    return "const_cast";
+  case CXXCast::CC_StaticCast:
+    return "static_cast";
+  case CXXCast::CC_ReinterpretCast:
+    return "reinterpret_cast";
+    // Below are only used for summary diagnostics
+  case CXXCast::CC_CStyleCast:
+    return "C style cast";
+  case CXXCast::CC_NoOpCast:
+    return "No-op cast";
+  default:
+    llvm_unreachable("The cast should never occur.");
+    return {};
+  }
+}
+
+/// Reports messages with a source location, typically used to address
+/// specific code segments.
+///
+/// \tparam N length of string
+/// \tparam Args variadic types to be accepted by DiagnosticBuilder
+/// \param Engine the diagnostic engine to report with
+/// \param Level diagnostic level
+/// \param FormatString A C string with \p N characters with potential clang
+/// format strings
+/// \param Loc The starting location in the translation unit to
+/// address
+/// \param args data to be formatted into FormatString \return resulting
+/// message object to be emitted.
+template <unsigned N, typename... Args>
+DiagnosticBuilder reportWithLoc(DiagnosticsEngine &Engine,
+                                const DiagnosticsEngine::Level &Level,
+                                const char (&FormatString)[N],
+                                const SourceLocation &Loc, Args &&... args) {
+  unsigned ID = Engine.getCustomDiagID(Level, FormatString);
+  // Binary left fold
+  return (Engine.Report(Loc, ID) << ... << std::forward<Args>(args));
+}
+
+/// Reports messages, typically used to address a translation-unit/file wide
+/// diagnostic. Refer to reportWithLoc for more information.
+template <unsigned N, typename... Args>
+DiagnosticBuilder report(DiagnosticsEngine &Engine,
+                         DiagnosticsEngine::Level Level,
+                         const char (&FormatString)[N], Args &&... args) {
+  unsigned ID = Engine.getCustomDiagID(Level, FormatString);
+  // Binary left fold
+  return (Engine.Report(ID) << ... << std::forward<Args &&>(args));
+}
+
+namespace details {
+
+/// Determines whether Base is accessible from Derived class.
+///
+/// \param Base the base class declaration
+/// \param Derived the derived class declaration
+/// \returns true if \p Base is accessible from \p Derived or are the same
+/// class, and false if \p Base is not accessible from \p Derived or are
+/// unrelated classes
+bool isAccessible(const CXXRecordDecl *Base, const CXXRecordDecl *Derived) {
+  if (!Base || !Derived)
+    return false;
+
+  if (clang::declaresSameEntity(Derived, Base)) {
+    // The class's contents is always accessible to itself.
+    return true;
+  }
+
+  for (const CXXBaseSpecifier &Specifier : Derived->bases()) {
+    // This should already be canonical
+    const QualType &BaseType = Specifier.getType();
+    CXXRecordDecl *BaseClass = (*BaseType).getAsCXXRecordDecl();
+
+    if (Specifier.getAccessSpecifier() == clang::AccessSpecifier::AS_public &&
+        isAccessible(Base, BaseClass))
+      return true;
+  }
+
+  // These two are unrelated classes.
+  return false;
+}
+
+/// Determines the proper cast type for a Base to/from Derived conversion
+/// based off of accessbility.
+///
+/// \param Base the base class declaration
+/// \param Derived the derived class declaration
+/// \return CXXCast enum corresponding to the lowest power cast required.
+CXXCast getBaseDerivedCast(const CXXRecordDecl *Base,
+                           const CXXRecordDecl *Derived) {
+  assert(Base && Derived && "Base and Derived decls cannot be null.");
+  if (!details::isAccessible(Base, Derived))
+    return CXXCast::CC_CStyleCast;
+  else
+    return CXXCast::CC_StaticCast;
+}
+
+/// Removes a layer of pointers, member pointers, arrays.
+///
+/// \param T type to strip, assumed to be one of the above.
+/// \param Context, the ASTContext to create the array type edge case.
+/// \return type corresponding to \p T stripped of one indirection layer.
+QualType stripLayer(const QualType &T, const ASTContext &Context) {
+  if (T->isPointerType()) {
+    const PointerType *PT = dyn_cast<PointerType>(T);
+    return PT->getPointeeType();
+  }
+  if (T->isArrayType()) {
+    const ArrayType *AT = Context.getAsArrayType(T);
+    return AT->getElementType();
+  }
+  if (T->isMemberPointerType()) {
+    const MemberPointerType *MPT = dyn_cast<MemberPointerType>(T);
+    return MPT->getPointeeType();
+  }
+  llvm_unreachable("The type is not a pointer/array/member to pointer type.");
+  return T;
+}
+
+/// \param T some qualified type
+/// \return true if T is a function pointer
+bool isFunctionPtr(const QualType &T) {
+  return T->isMemberFunctionPointerType() || T->isFunctionPointerType();
+}
+
+/// We define the types A and B to be locally similar if they are both
+/// - pointer, i.e. int* is a pointer to an int
+/// - member pointer, i.e. given struct t, int t::* const ptr is a
+/// pointer to an int member of struct t.
+/// - array / array of unknown bound, i.e. int a[2] and int a[], where the
+/// latter is likely a partial 'extern' type.
+bool isLocallySimilar(const QualType &A, const QualType &B) {
+  bool AIsPtr = A->isPointerType();
+  bool BIsPtr = B->isPointerType();
+  bool AIsArr = A->isArrayType();
+  bool BIsArr = B->isArrayType();
+  bool AIsMemberPtr = A->isMemberPointerType();
+  bool BIsMemberPtr = B->isMemberPointerType();
+
+  bool LocallySimilar = (AIsMemberPtr && BIsMemberPtr) ||
+                        (AIsPtr && BIsPtr && !AIsMemberPtr && !BIsMemberPtr) ||
+                        (AIsArr && BIsArr);
+
+  return LocallySimilar;
+}
+
+/// Either types are terminal if either one are not pointer-like types that
+/// can be traversed.
+bool isTerminal(const QualType &A, const QualType &B) {
+  bool AIsPtr = A->isPointerType();
+  bool BIsPtr = B->isPointerType();
+  bool AIsArr = A->isArrayType();
+  bool BIsArr = B->isArrayType();
+  bool AIsMemberPtr = A->isMemberPointerType();
+  bool BIsMemberPtr = B->isMemberPointerType();
+
+  bool IsTerminal = !(AIsPtr || AIsArr || AIsMemberPtr) ||
+                    !(BIsPtr || BIsArr || BIsMemberPtr);
+
+  return IsTerminal;
+}
+
+} // namespace details
+} // namespace cppcast
+} // namespace clang
+
+#endif
diff --git a/clang-tools-extra/clang-cast/ClangCast.cpp b/clang-tools-extra/clang-cast/ClangCast.cpp
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/ClangCast.cpp
@@ -0,0 +1,147 @@
+//===--- ClangCast.cpp - clang-cast -----------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file is the main driver for the clang-cast tool.
+///
+//===----------------------------------------------------------------------===//
+
+#include "Consumer.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Error.h"
+
+using namespace clang::ast_matchers;
+using namespace clang;
+using namespace cppcast;
+using namespace llvm;
+
+namespace clang {
+namespace cli {
+
+static llvm::cl::OptionCategory ClangCastCategory("clang-cast options");
+
+llvm::cl::extrahelp ClangCastCategoryHelp(R"(
+clang-cast finds C style casts and attempts to convert them into C++ casts.
+C++ casts are preferred since they are safer and more explicit than C style casts.
+
+For example:
+
+double* p = nullptr;
+(int*) p;
+
+... is converted into:
+
+double* p = nullptr;
+reinterpret_cast<int*>(p);
+
+When running clang-cast on a compilation unit, the tool will emit useful diagnostics.
+The tool can be used to modify a file in-place or into a new file with an added suffix.
+Clang-cast will not modify system headers, nor any file with the suffix .c (C files).
+)");
+
+llvm::cl::opt<bool>
+    PedanticOption("pedantic", llvm::cl::init(false),
+                   llvm::cl::desc("If true, clang-cast will not assume "
+                                  "qualification conversion extensions \n"
+                                  "(this will lead to more false negatives) "
+                                  "that clang adds. This is for projects \n"
+                                  "which use the -pedantic or -pedantic-errors "
+                                  "flag and have extensions turned off."),
+                   llvm::cl::cat(ClangCastCategory));
+
+llvm::cl::list<ErrorOpts> ErrorOptList(
+    llvm::cl::desc("For each flag set, clang-cast will issue an "
+                   "error for any C style casts that are converted "
+                   "to the following types."),
+    llvm::cl::values(
+        clEnumValN(EO_StaticCast, "err-static", "Error on static_cast"),
+        clEnumValN(EO_ReinterpretCast, "err-reinterpret",
+                   "Error on reinterpret_cast"),
+        clEnumValN(EO_ConstCast, "err-const", "Error on const_cast"),
+        clEnumValN(EO_CStyleCast, "err-cstyle",
+                   "Error on non-convertible C style casts"),
+        clEnumValN(EO_NoOpCast, "err-noop",
+                   "Error on unnecessary C style casts"),
+        clEnumValN(EO_All, "err-all", "Error for all of the above")),
+    llvm::cl::cat(ClangCastCategory));
+
+llvm::cl::list<FixOpts> FixOptList(
+    llvm::cl::desc("For each flag set, clang-cast will apply a fix for the C "
+                   "style casts that can be converted to the following types. "
+                   "Note that for casts that require two consecutive C++ "
+                   "casts, both flags need to be specified (or --fix-all)."),
+    llvm::cl::values(
+        clEnumValN(FO_StaticCast, "fix-static", "Apply fixes to static_cast"),
+        clEnumValN(FO_ReinterpretCast, "fix-reinterpret",
+                   "Apply fixes to reinterpret_cast"),
+        clEnumValN(FO_ConstCast, "fix-const", "Apply fixes to const_cast"),
+        clEnumValN(FO_NoOpCast, "fix-noop", "Apply fixes to no-op cast"),
+        clEnumValN(FO_All, "fix-all", "Apply fixes for all of the above")),
+    llvm::cl::cat(ClangCastCategory));
+
+llvm::cl::opt<std::string>
+    SuffixOption("suffix",
+                 llvm::cl::desc("If suffix is set, changes of "
+                                "a file F will be written to F+suffix."),
+                 llvm::cl::cat(ClangCastCategory));
+
+llvm::cl::opt<bool>
+    DontExpandIncludes("no-includes", llvm::cl::init(false),
+                       llvm::cl::desc("Don't modify any include files."),
+                       llvm::cl::cat(ClangCastCategory));
+
+llvm::cl::opt<bool>
+    PublishSummary("summary", llvm::cl::init(false),
+                   llvm::cl::desc("If true, clang-cast gives a small summary "
+                                  "of the statistics of casts through "
+                                  "the entire translation unit."),
+                   llvm::cl::cat(ClangCastCategory));
+
+llvm::cl::extrahelp
+    CommonHelp(clang::tooling::CommonOptionsParser::HelpMessage);
+
+} // namespace cli
+
+namespace cppcast {
+
+class Action : public clang::ASTFrontendAction {
+public:
+  using ASTConsumerPointer = std::unique_ptr<clang::ASTConsumer>;
+  Action() = default;
+  ASTConsumerPointer CreateASTConsumer(CompilerInstance &Compiler,
+                                       StringRef Filename) override {
+    if (!Compiler.getLangOpts().CPlusPlus) {
+      llvm::report_fatal_error("clang-cast is only supported for C++.");
+    }
+    return std::make_unique<Consumer>(
+        cli::SuffixOption, cli::PedanticOption, cli::PublishSummary,
+        cli::DontExpandIncludes, cli::ErrorOptList, cli::FixOptList);
+  }
+};
+
+struct ToolFactory : public clang::tooling::FrontendActionFactory {
+  std::unique_ptr<clang::FrontendAction> create() override {
+    std::unique_ptr<clang::FrontendAction> Ptr;
+    Ptr.reset(new Action());
+    return Ptr;
+  }
+};
+
+} // namespace cppcast
+
+} // namespace clang
+
+int main(int argc, const char **argv) {
+  tooling::CommonOptionsParser op(argc, argv, cli::ClangCastCategory);
+  tooling::ClangTool Tool(op.getCompilations(), op.getSourcePathList());
+  int ExitCode = Tool.run(new clang::cppcast::ToolFactory());
+  return ExitCode;
+}
diff --git a/clang-tools-extra/clang-cast/Consumer.h b/clang-tools-extra/clang-cast/Consumer.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/Consumer.h
@@ -0,0 +1,45 @@
+//===--- Consumer.h - clang-cast --------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the ASTConsumer class used in FrontendAction.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CONSUMER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_CONSUMER_H
+
+#include "Matcher.h"
+#include "clang/AST/ASTConsumer.h"
+
+namespace clang {
+namespace cppcast {
+
+class Consumer : public clang::ASTConsumer {
+public:
+  template <typename... Args>
+  Consumer(Args &&... args) : Handler(std::forward<Args>(args)...) {
+    using namespace clang::ast_matchers;
+    // TODO: Make this a constant instead of hardcode "cast"
+    StatementMatcher CStyleCastMatcher = cStyleCastExpr().bind("cast");
+    MatchFinder.addMatcher(CStyleCastMatcher, &Handler);
+  }
+
+  void HandleTranslationUnit(clang::ASTContext &Context) override {
+    MatchFinder.matchAST(Context);
+  }
+
+private:
+  Matcher Handler;
+  clang::ast_matchers::MatchFinder MatchFinder;
+};
+
+} // namespace cppcast
+} // namespace clang
+
+#endif
diff --git a/clang-tools-extra/clang-cast/Matcher.h b/clang-tools-extra/clang-cast/Matcher.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/clang-cast/Matcher.h
@@ -0,0 +1,402 @@
+//===--- Matcher.h - clang-cast ---------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains the ASTMatcher responsible for most of the diagnostics.
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_MATCHER_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_CAST_MATCHER_H
+
+#include "Cast.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace cppcast {
+
+/// Matcher is responsible for creating a CStyleCastOperation to perform
+/// semantic analysis on the CStyleCastExpr and decide what potential
+/// replacements are suitable for the expression.
+///
+/// The matcher decides whether to emit a warning or error or to additionally
+/// perform a fix based off of the bit masks created by enums in CastOptions.h.
+///
+/// The Matcher emits summaries if the flags are set, containing some summary
+/// statistics.
+class Matcher : public MatchFinder::MatchCallback {
+  using RewriterPtr = std::unique_ptr<clang::FixItRewriter>;
+  /// The FixItRewriter is actually a composable DiagnosticConsumer which
+  /// contains the original DiagnosticConsumer client, which is a
+  /// TextDiagnosticPrinter.
+  ///
+  /// If we have Rewriter set as the client, FixIt's will be fixed on the file.
+  /// We want to have granular control over which FixIt's to fix, so we do some
+  /// light pointer manipulation with the DiagnosticEngine in setClient to
+  /// switch back and forth between the TextDiagnosticPrinter and FixItRewriter.
+  RewriterPtr Rewriter;
+  rewriter::FixItRewriterOptions FixItOptions;
+  DiagnosticConsumer *OriginalWriter;
+
+  /// Whether or not the Matcher should emit code compliant with -pedantic
+  bool Pedantic;
+
+  /// Whether or not the Matcher should publish a short blurb upon finishing
+  /// visiting a translation unit.
+  bool PublishSummary;
+
+  /// Number of C style casts encountered
+  unsigned TotalCasts;
+
+  /// Whether or not to diagnose & fix includes (Local modifications only)
+  bool DontExpandIncludes;
+
+  /// Bitmask to determine which C style cast powers should give an error.
+  /// For example, if we met a cast that requires static cast,
+  /// and static cast is 0x1, and our mask is 0x10011, since the last bit is a
+  /// 1, we will emit the error.
+  unsigned ErrMask;
+
+  /// Bitmask to determine which C style casts to fix.
+  unsigned FixMask;
+
+  /// Keeps count of how many C++ cast conversion types there are.
+  /// Note that for casts that require multiple C++ casts, multiple types are
+  /// updated here.
+  std::map<CXXCast, unsigned> Statistics;
+
+  /// List of files that were modified from the tool.
+  std::set<StringRef> ChangedFiles;
+
+public:
+  /// Initializes a new Matcher.
+  /// \param FilenameSuffix the suffix to add to the filenames
+  /// \param Pedantic whether to check & emit code compliant with -pedantic
+  /// \param PublishSummary whether to publish a small summary at the end
+  /// \param DontExpandIncludes whether to parse cast exprs in headers
+  /// \param ErrorOptions vector of bitmasks for error/warn types of cast
+  /// \param FixOptions vector of bitmasks for fixing types of cast
+  Matcher(const std::string &FilenameSuffix, const bool Pedantic,
+          bool PublishSummary, bool DontExpandIncludes,
+          std::vector<cli::ErrorOpts> ErrorOptions,
+          std::vector<cli::FixOpts> FixOptions);
+
+  virtual ~Matcher();
+
+  /// There are a few cases for the replacement string:
+  /// 1. No-op cast (remove the cast)
+  /// 2. Only const cast
+  /// 3. Static cast
+  /// 4. Static cast + const cast
+  /// 5. Reinterpret cast
+  /// 6. Reinterpret cast + const cast
+  /// 7. C style cast (keep the cast as is)
+  /// \param Op operation wrapper
+  /// \param CXXCastKind kind of non const cast applied to the expr (can be
+  /// noop)
+  /// \param ConstCastRequired whether const cast should be added to the
+  /// existing casts
+  /// \return A string to replace the C style cast operation char range with.
+  std::string replaceExpression(const CStyleCastOperation &Op,
+                                CXXCast CXXCastKind, bool ConstCastRequired);
+
+  /// Given an ordered list of casts, use the ASTContext to report necessary
+  /// changes to the cast expression. Also performs a FixIt on the source code
+  /// if necessary.
+  /// \param ModifiableContext the context ptr needs to be modifiable in
+  /// order to set the diagnostic client
+  /// \param Op the operation wrapper
+  /// \return true if a FixIt has been applied
+  bool reportDiagnostic(ASTContext *ModifiableContext,
+                        const CStyleCastOperation &Op);
+
+  virtual void run(const MatchFinder::MatchResult &Result);
+
+private:
+  /// Given an expression, gives the character source range of the expr.
+  CharSourceRange getRangeForExpression(const Expr *Expression,
+                                        const ASTContext &Context);
+
+  /// Sets a client to the diagnostic engine depending on Modify:
+  /// if Modify is true, then we change the diagnostics client to a
+  /// FixItRewriter which takes and owns the TextDiagnosticPrinter from the
+  /// engine.
+  ///
+  /// If modify is false, then we can't just destroy the FixItRewriter, as the
+  /// previous FixIt's would be gone. If we already created a rewriter, then the
+  /// TextDiagnosticPrinter is owned by it when previously it was owned by the
+  /// engine. We do nothing if the rewriter hasn't been initialized, but this is
+  /// extremely precarious as it's juggling ownership between two objects as the
+  /// FixIt's are applied to subsets of the program.
+  ///
+  /// This function was born out of a necessity to work with FixItRewriter's
+  /// composition-of-consumers design which makes ownership very complicated.
+  void setClient(clang::ASTContext *Context, bool Modify);
+
+  /// A quick diagnostic warning for when symlinks are being overwritten by an
+  /// actual file.
+  void checkForSymlinks(const SourceManager &Manager, const SourceLocation &Loc,
+                        DiagnosticsEngine &DiagEngine);
+};
+
+// We can't initialize the RewriterPtr until we get an ASTContext.
+Matcher::Matcher(const std::string &FilenameSuffix, const bool Pedantic,
+                 bool PublishSummary, bool DontExpandIncludes,
+                 std::vector<cli::ErrorOpts> ErrorOptions,
+                 std::vector<cli::FixOpts> FixOptions)
+    : Rewriter(nullptr), FixItOptions(FilenameSuffix), Pedantic(Pedantic),
+      PublishSummary(PublishSummary), TotalCasts(0),
+      DontExpandIncludes(DontExpandIncludes),
+      /* modify in ctr */ ErrMask(0),
+      /* modify in ctr */ FixMask(0) {
+  for (unsigned i = 0; i != ErrorOptions.size(); i++) {
+    ErrMask |= ErrorOptions[i];
+  }
+  for (unsigned i = 0; i != FixOptions.size(); i++) {
+    FixMask |= FixOptions[i];
+  }
+}
+
+// TODO: Is this okay to do?
+Matcher::~Matcher() {
+  if (PublishSummary) {
+    for (const auto &Pair : Statistics) {
+      const auto &CXXCastKind = Pair.first;
+      const auto &Freq = Pair.second;
+      if (!Freq)
+        continue;
+      llvm::errs() << "The type " << cppCastToString(CXXCastKind)
+                   << " has been issued " << Freq
+                   << " times throughout the translation unit.\n";
+    }
+    if (FixMask) {
+      llvm::errs() << "The following files were modified:\n";
+      for (auto const &File : ChangedFiles) {
+        llvm::errs() << "\t - " << File << "\n";
+      }
+    }
+    llvm::errs() << "In total, there are " << TotalCasts
+                 << " C style casts in the translation unit. Multiple C++ "
+                    "casts may be used to convert a single C style cast.\n";
+  }
+}
+
+CharSourceRange Matcher::getRangeForExpression(const Expr *Expression,
+                                               const ASTContext &Context) {
+  // Also expand on macros:
+  auto &Manager = Context.getSourceManager();
+
+  const ParenExpr *ParenExpression;
+  while ((ParenExpression = dyn_cast<ParenExpr>(Expression))) {
+    Expression = ParenExpression->getSubExpr();
+  }
+  auto ExprStart = Manager.getSpellingLoc(Expression->getBeginLoc());
+  auto ExprEnd = Lexer::getLocForEndOfToken(
+      Manager.getSpellingLoc(Expression->getEndLoc()), /*Offset=*/0,
+      Context.getSourceManager(), Context.getLangOpts());
+
+  return CharSourceRange::getCharRange(SourceRange{ExprStart, ExprEnd});
+}
+
+std::string Matcher::replaceExpression(const CStyleCastOperation &Op,
+                                       CXXCast CXXCastKind,
+                                       bool ConstCastRequired) {
+  assert(CXXCastKind != CXXCast::CC_ConstCast &&
+         "Const cast enum cannot be passed in as CXXCastKind");
+  QualType CastType = Op.getCastType();
+  const Expr &SubExpr = Op.getSubExprAsWritten();
+  const ASTContext &Context = Op.getContext();
+  const auto &LangOpts = Context.getLangOpts();
+
+  std::string SubExpressionStr =
+      Lexer::getSourceText(getRangeForExpression(&SubExpr, Context),
+                           Context.getSourceManager(), Context.getLangOpts())
+          .str();
+
+  switch (CXXCastKind) {
+  case CXXCast::CC_NoOpCast: {
+    if (!ConstCastRequired) {
+      // our replacement is simply the subexpression (no cast needed)
+      return SubExpressionStr;
+    }
+    return cppCastToString(CXXCast::CC_ConstCast) + "<" +
+           CastType.getAsString(LangOpts) + ">(" + SubExpressionStr + ")";
+  }
+  case CXXCast::CC_StaticCast:
+  case CXXCast::CC_ReinterpretCast: {
+    std::string CastTypeStr = cppCastToString(CXXCastKind);
+    if (!ConstCastRequired) {
+      return CastTypeStr + "<" + CastType.getAsString(LangOpts) + ">(" +
+             SubExpressionStr + ")";
+    }
+    QualType IntermediateType = Op.changeQualifiers();
+    return cppCastToString(CXXCast::CC_ConstCast) + "<" +
+           CastType.getAsString(LangOpts) + ">(" + CastTypeStr + "<" +
+           IntermediateType.getAsString(LangOpts) + ">(" + SubExpressionStr +
+           "))";
+  }
+  default: {
+    llvm_unreachable(
+        "The type of cast passed in cannot produce a replacement.");
+    return {};
+  }
+  }
+}
+
+bool Matcher::reportDiagnostic(ASTContext *ModifiableContext,
+                               const CStyleCastOperation &Op) {
+  // No FixItRewriter should be set as consumer until we need to fix anything.
+  setClient(ModifiableContext, /*Modify=*/false);
+  const auto &Context = Op.getContext();
+  auto &DiagEngine = Context.getDiagnostics();
+
+  // Set diagnostics to warning by default, and to INFO for edge cases.
+  const auto &CastExpr = Op.getCStyleCastExpr();
+  auto StartingLoc = CastExpr.getExprLoc();
+  const auto &ExprRange = getRangeForExpression(&CastExpr, Context);
+
+  CXXCast CXXCastKind = Op.getCastKindFromCStyleCast();
+  bool ConstCastRequired = Op.requireConstCast();
+  unsigned CurMask = CXXCastKind | (ConstCastRequired * CXXCast::CC_ConstCast);
+
+  // Invalid cast or dynamic (this should never happen, and would be a bug)
+  if (CurMask & (CXXCast::CC_InvalidCast | CXXCast::CC_DynamicCast)) {
+    reportWithLoc(
+        DiagEngine, DiagnosticsEngine::Error,
+        "clang-casts has encountered an error. Currently does not support "
+        "the following cast",
+        StartingLoc, ExprRange);
+    return false;
+  }
+  if (CurMask & CXXCast::CC_CStyleCast) {
+    reportWithLoc(DiagEngine,
+                  (CurMask & ErrMask) ? DiagnosticsEngine::Error
+                                      : DiagnosticsEngine::Remark,
+                  "C style cast cannot be converted "
+                  "into a C++ style cast",
+                  StartingLoc, ExprRange);
+    return false;
+  }
+
+  const auto Replacement =
+      replaceExpression(Op, CXXCastKind, ConstCastRequired);
+  const auto CastRange = getRangeForExpression(&CastExpr, Context);
+
+  Statistics[CXXCast::CC_ConstCast] += ConstCastRequired;
+  Statistics[CXXCastKind]++;
+
+  // TODO: the location pointer looks funky when the cast expression is
+  // in a macro.
+  auto &Manager = Context.getSourceManager();
+  auto Level = (CurMask & ErrMask) ? DiagnosticsEngine::Error
+                                   : DiagnosticsEngine::Warning;
+  if (Manager.isMacroBodyExpansion(StartingLoc)) {
+    reportWithLoc(DiagEngine, Level,
+                  "C style cast can be replaced by '%0' "
+                  "(won't be fixed in macro)",
+                  StartingLoc, Replacement, ExprRange);
+    return false;
+  }
+
+  // Set the diagnostic consumer accordingly.
+  bool Modify = (CurMask & FixMask) == CurMask;
+
+  // TODO: For clang-tidy, we want to put a logical branch here and not input
+  // FixIt if we don't want to modify it. If we set the consumer as
+  // FixItRewriter permanently, emitting an error (from --err-all, for example)
+  // will cause FixIt to emit "FIXIT: detected an error it cannot fix", which
+  // clutters up the real diagnostics.
+  setClient(ModifiableContext, Modify);
+  const auto FixIt =
+      clang::FixItHint::CreateReplacement(CastRange, Replacement);
+  reportWithLoc(DiagEngine, Level, "C style cast can be replaced by '%0'",
+                StartingLoc, Replacement, FixIt);
+  return Modify;
+}
+
+void Matcher::run(const MatchFinder::MatchResult &Result) {
+  ASTContext *Context = Result.Context;
+  auto &DiagEngine = Context->getDiagnostics();
+
+  const CStyleCastExpr *CastExpression =
+      Result.Nodes.getNodeAs<CStyleCastExpr>("cast");
+  assert(CastExpression && "CastExpr cannot be null");
+
+  const auto &Manager = Context->getSourceManager();
+  const auto Loc = CastExpression->getBeginLoc();
+  // We skip external headers
+  if (Manager.isInExternCSystemHeader(Loc) || Manager.isInSystemHeader(Loc) ||
+      (!Manager.isInMainFile(Loc) && DontExpandIncludes)) {
+    return;
+  }
+
+  TotalCasts++;
+  CStyleCastOperation Op(*CastExpression, *Context, Pedantic);
+
+  // If anything is to be modified
+  if (reportDiagnostic(Context, Op)) {
+    checkForSymlinks(Manager, Loc, DiagEngine);
+    if (Rewriter->WriteFixedFiles()) {
+      llvm::errs() << "Writing the FixItHint was unsuccessful.\n";
+    }
+  }
+}
+
+void Matcher::checkForSymlinks(const SourceManager &Manager,
+                               const SourceLocation &Loc,
+                               DiagnosticsEngine &DiagEngine) {
+  const FileEntry *Entry = Manager.getFileEntryForID(Manager.getFileID(Loc));
+  assert(Entry && "File entry cannot be null");
+  const auto RealFilename = Entry->tryGetRealPathName();
+  const auto Filename = Entry->getName();
+  ChangedFiles.insert(Filename);
+
+  if (RealFilename != Filename) {
+    report(DiagEngine, DiagnosticsEngine::Warning,
+           "The symlink at %0 pointing to %1 is changed to a file during "
+           "modifications.",
+           Filename, RealFilename);
+  }
+}
+
+void Matcher::setClient(clang::ASTContext *Context, bool Modify) {
+  auto &DiagEngine = Context->getDiagnostics();
+  if (Modify) {
+    // First time initializing, means that engine owns TDP.
+    if (!Rewriter) {
+      OriginalWriter = DiagEngine.getClient();
+      Rewriter = std::make_unique<clang::FixItRewriter>(
+          DiagEngine, Context->getSourceManager(), Context->getLangOpts(),
+          &FixItOptions);
+    }
+
+    // If we modify, we don't want the diagnostics engine to own it.
+    // If we don't modify, we want the diagnostics engine to own the original
+    // client.
+    Context->getDiagnostics().setClient(Rewriter.get(),
+                                        /*ShouldOwnClient=*/false);
+  } else {
+    // Rewriter not initialized, therefore do nothing, as the TDP client
+    // is still there and owned by engine.
+    if (!Rewriter)
+      return;
+    // Rewriter is initialized, therefore set TDP (not owned by engine,
+    // owned by FIR)
+    Context->getDiagnostics().setClient(OriginalWriter,
+                                        /*ShouldOwnClient=*/false);
+  }
+}
+
+} // namespace cppcast
+} // namespace clang
+
+#endif
diff --git a/clang-tools-extra/unittests/CMakeLists.txt b/clang-tools-extra/unittests/CMakeLists.txt
--- a/clang-tools-extra/unittests/CMakeLists.txt
+++ b/clang-tools-extra/unittests/CMakeLists.txt
@@ -6,6 +6,7 @@
 endfunction()
 
 add_subdirectory(clang-apply-replacements)
+add_subdirectory(clang-cast)
 add_subdirectory(clang-change-namespace)
 add_subdirectory(clang-doc)
 add_subdirectory(clang-include-fixer)
diff --git a/clang-tools-extra/unittests/clang-cast/CMakeLists.txt b/clang-tools-extra/unittests/clang-cast/CMakeLists.txt
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/unittests/clang-cast/CMakeLists.txt
@@ -0,0 +1,30 @@
+set(LLVM_LINK_COMPONENTS Support)
+
+include_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/../../clang-cast
+)
+
+add_extra_unittest(ClangCastTests
+    ClangCastTests.cpp
+)
+
+clang_target_link_libraries(ClangCastTests
+    PRIVATE
+    clangAST
+    clangASTMatchers
+    clangBasic
+    clangFormat
+    clangFrontend
+    clangRewrite
+    clangSerialization
+    clangTooling
+    clangToolingCore
+)
+
+target_link_libraries(ClangCastTests
+    PRIVATE
+    clangTooling
+    clangBasic
+    clangASTMatchers
+)
+
diff --git a/clang-tools-extra/unittests/clang-cast/ClangCXXCastTestCases.h b/clang-tools-extra/unittests/clang-cast/ClangCXXCastTestCases.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/unittests/clang-cast/ClangCXXCastTestCases.h
@@ -0,0 +1,339 @@
+//===-- ClangCXXCastTestCases.h - clang-cast --------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains test cases for
+/// CStyleCastOperation::getCastKindFromCStyleCast (defined in Cast.h)
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_CAST_CLANGCXXCASTTESTCASES_H
+#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_CAST_CLANGCXXCASTTESTCASES_H
+
+namespace testcases {
+
+/// NoOp cast types - these are conversions
+/// that can be done implicitly.
+static const char NoOp[] = R"(
+void f() {
+  (int&&) 0;
+}
+)";
+static const char ArrayToPointerDecay[] = R"(
+void f() {
+  char x[] = "";
+  (char*) x;
+}
+)";
+// NOTE: Unused, as C style casts cannot
+//       perform this. It must be done implicitly.
+//       (int&&) x is a NoOp, and std::move(x) is
+//       FunctionToPointerDecay.
+static const char LValueToRValue[] = R"(
+void f() {
+  int x;
+  int y = x;
+}
+)";
+
+/// Static cast types
+static const char BaseToDerived[] = R"(
+class A {};
+class B: public A {};
+class C: public B {};
+
+void f() {
+  A* a = nullptr;
+  (C*) a;
+}
+)";
+static const char DerivedToBase[] = R"(
+class A {};
+class B: public A {};
+class C: public B {};
+
+void f() {
+  C* c = nullptr;
+  (A*) c;
+}
+)";
+// NOTE: Unused, as C style casts cannot
+//       perform this. It must be done implicitly.
+static const char UncheckedDerivedToBase[] = R"(
+class A { public: void a(){} };
+class B : public A {};
+
+void f() {
+    B *b;
+    b->a();
+}
+)";
+static const char FunctionToPointerDecay[] = R"(
+void g() {}
+
+void f() {
+  (void (*)()) g;
+}
+)";
+static const char NullToPointer[] = R"(
+void f() {
+  (void*) 0;
+}
+)";
+static const char NullToMemberPointer[] = R"(
+struct A {};
+void f() {
+  (int A::*) 0;
+}
+)";
+static const char BaseToDerivedMemberPointer[] = R"(
+struct A { int m; };
+struct B : A {};
+void f() {
+  (int B::*) &A::m;
+}
+)";
+static const char DerivedToBaseMemberPointer[] = R"(
+struct A {};
+struct B : A { int m; };
+void f() {
+  (int A::*) &B::m;
+}
+)";
+static const char MemberPointerToBoolean[] = R"(
+struct A { int m; };
+void f() {
+  (bool) &A::m;
+}
+)";
+static const char UserDefinedConversion[] = R"(
+struct A { operator int(); };
+
+void f() {
+  (int) A();
+}
+)";
+static const char ConstructorConversion[] = R"(
+struct A { A(int); };
+
+void f() {
+  (A) 10;
+}
+)";
+static const char PointerToBoolean[] = R"(
+void f() {
+  (bool) nullptr;
+}
+)";
+static const char ToVoid[] = R"(
+void f() {
+  (void) 0;
+}
+)";
+static const char VectorSplat[] = R"(
+void f() {
+  typedef float float4 __attribute__((ext_vector_type(4)));
+  using type = float4;
+  (type) 0.0f;
+}
+)";
+static const char IntegralCast[] = R"(
+void f() {
+  (long long int) 0u;
+}
+)";
+static const char IntegralToBoolean[] = R"(
+void f() {
+  (bool) 10l;
+}
+)";
+static const char IntegralToFloating[] = R"(
+void f() {
+  (float) 10l;
+}
+)";
+
+// NOTE: Unused, as fixed points are not yet introduced into C++ standard.
+//       nor the clang extensions.
+static const char FixedPointCast[] = R"()";
+// NOTE: Unused, as fixed points are not yet introduced into C++ standard.
+//       nor the clang extensions.
+static const char FixedPointToIntegral[] = R"()";
+// NOTE: Unused, as fixed points are not yet introduced into C++ standard.
+//       nor the clang extensions.
+static const char IntegralToFixedPoint[] = R"()";
+// NOTE: Unused, as fixed points are not yet introduced into C++ standard.
+//       nor the clang extensions.
+static const char FixedPointToBoolean[] = R"()";
+
+static const char FloatingToIntegral[] = R"(
+void f() {
+  (int) 0.0f;
+}
+)";
+static const char FloatingToBoolean[] = R"(
+void f() {
+  (bool) 0.0f;
+}
+)";
+// TODO: Ask question
+// NOTE: Unused, because AFAIK this is not possible, according to
+//       the comments it will cast to -1/0 for true/false.
+static const char BooleanToSignedIntegral[] = R"(
+void f() {
+  (int) true;
+}
+)";
+static const char FloatingCast[] = R"(
+void f() {
+  (double) 0.0f;
+}
+)";
+static const char FloatingRealToComplex[] = R"(
+void f() {
+  (_Complex long double) 1.0;
+}
+)";
+static const char FloatingComplexToReal[] = R"(
+void f() {
+  _Complex long double c;
+  (long double) c;
+}
+)";
+static const char FloatingComplexToBoolean[] = R"(
+void f() {
+  _Complex long double c;
+  (bool) c;
+}
+)";
+static const char FloatingComplexCast[] = R"(
+void f() {
+  _Complex long double c;
+  (_Complex float) c;
+}
+)";
+static const char FloatingComplexToIntegralComplex[] = R"(
+void f() {
+  _Complex long double c;
+  (_Complex int) c;
+}
+)";
+static const char IntegralRealToComplex[] = R"(
+void f() {
+  (_Complex long long) 10l;
+}
+)";
+static const char IntegralComplexToReal[] = R"(
+void f() {
+  _Complex long long c;
+  (int) c;
+}
+)";
+static const char IntegralComplexToBoolean[] = R"(
+void f() {
+  _Complex long long c;
+  (bool) c;
+}
+)";
+static const char IntegralComplexCast[] = R"(
+void f() {
+  _Complex long long c;
+  (_Complex int) c;
+}
+)";
+static const char IntegralComplexToFloatingComplex[] = R"(
+void f() {
+  _Complex long long c;
+  (_Complex float) c;
+}
+)";
+static const char AtomicToNonAtomic[] = R"(
+void f() {
+  _Atomic(int) c;
+  (int) c;
+}
+)";
+static const char NonAtomicToAtomic[] = R"(
+void f() {
+  int c;
+  (_Atomic(int)) c;
+}
+)";
+
+/// Reinterpret cast types
+const char BitCast[] = R"(
+void f() {
+  char* x;
+  (int *) x;
+}
+)";
+const char LValueBitCast[] = R"(
+void f() {
+  char c;
+  (bool&) c;
+}
+)";
+static const char IntegralToPointer[] = R"(
+void f() {
+  (int*) 10l;
+}
+)";
+// NOTE: Unused, as C style casts cannot
+//       perform this. It must be done by bit_cast.
+const char LValueToRValueBitCast[] = R"(
+void f() {
+  int i;
+  std::bit_cast<float>(i);
+}
+)";
+static const char ReinterpretMemberPointer[] = R"(
+struct A { int val; };
+
+void f() {
+  int A::* ptr = &A::val;
+  (bool A::*) ptr;
+}
+)";
+static const char PointerToIntegral[] = R"(
+#include <stdint.h>
+void f() {
+  (intptr_t) nullptr;
+}
+)";
+
+/// C-style cast types
+static const char Dependent[] = R"(
+template <typename T>
+void foo() {
+    (T) 0;
+}
+)";
+
+namespace edgecases {
+
+static const char BaseToDerivedPrivateSpecifier[] = R"(
+struct A { int i; };
+struct Pad { int i; };
+class B: Pad, A {};
+
+B* foo(A *a) { return (B*)(a); }
+)";
+
+static const char DerivedToBasePrivateSpecifier[] = R"(
+struct A { int i; };
+struct Pad { int i; };
+class B: Pad, A {};
+
+A* foo(B *b) { return (A*)(b); }
+)";
+
+} // namespace edgecases
+
+} // namespace testcases
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_CAST_CLANGCXXCASTTESTCASES_H
diff --git a/clang-tools-extra/unittests/clang-cast/ClangCastTests.cpp b/clang-tools-extra/unittests/clang-cast/ClangCastTests.cpp
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/unittests/clang-cast/ClangCastTests.cpp
@@ -0,0 +1,509 @@
+//===-- ClangCastTests.cpp - clang-cast -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains tests of:
+///   - Getting the correct non-const cast type from a C style cast
+///   - Correctly determing whether an expression is casting
+///     away constness
+///   - Checking edge cases (function ptrs, private access
+///     inheritance, etc)
+///
+//===----------------------------------------------------------------------===//
+
+#include "Cast.h"
+#include "ClangCXXCastTestCases.h"
+#include "ClangChangeQualifierTestCases.h"
+#include "ClangFunctionPtrTestCases.h"
+#include "ClangQualifierTestCases.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/ASTMatchers/ASTMatchers.h"
+#include "clang/Tooling/Tooling.h"
+#include "gtest/gtest.h"
+#include <iostream>
+#include <set>
+#include <vector>
+
+#define CLANG_CXX_CAST_CHECK(cast_kind, cxx_cast)                              \
+  {                                                                            \
+    auto res = parse(cast_kind);                                               \
+    ASSERT_GE(res.first.size(), 1ul);                                          \
+    ASSERT_EQ(res.second.size(), 1ul);                                         \
+    ASSERT_TRUE(res.first.find(CastKind::CK_##cast_kind) != res.first.end());  \
+    ASSERT_EQ(res.second[0], CXXCast::CC_##cxx_cast);                          \
+  }
+
+#define CLANG_QUAL_CHECK(test_case, req_const, pedantic)                       \
+  {                                                                            \
+    auto res = parse(test_case, pedantic);                                     \
+    ASSERT_EQ(res, req_const);                                                 \
+  }
+
+#define CLANG_FUNC_PTR_CHECK(test_case, detected)                              \
+  {                                                                            \
+    auto res = parse(test_case);                                               \
+    ASSERT_EQ(res, detected);                                                  \
+  }
+
+using namespace testcases;
+using namespace testcases::constcheck;
+using namespace testcases::funcptr;
+using namespace testcases::changequal;
+using namespace clang;
+using namespace clang::tooling;
+using namespace clang::ast_matchers;
+using namespace clang::cppcast;
+
+static constexpr auto CastVar = "cast";
+static constexpr auto DeclVar = "varDecl";
+
+/// Uses CStyleCastCollector to collect all CXXCast enums obtained
+/// and CastKinds encountered.
+class ClangCXXCastTest : public ::testing::Test {
+  using CastKindSet = std::set<CastKind>;
+  using CXXCastVector = std::vector<CXXCast>;
+  StatementMatcher CStyleCastMatcher;
+
+  struct CStyleCastCollector : MatchFinder::MatchCallback {
+    std::vector<CXXCast> Casts;
+    std::set<CastKind> CastKinds;
+    CStyleCastCollector() = default;
+
+    virtual void run(const MatchFinder::MatchResult &Result) override {
+      ASTContext *Context = Result.Context;
+      const CStyleCastExpr *Expr =
+          Result.Nodes.getNodeAs<CStyleCastExpr>(CastVar);
+      assert(Expr && Context);
+      CStyleCastOperation Op(*Expr, *Context, /*Pedantic*/ false);
+
+      const CastExpr *GenericCastExpr = dyn_cast<CastExpr>(Expr);
+      // traverse the expr tree and set current expr
+      // node to GenericCastExpr.
+      while (GenericCastExpr) {
+        CastKinds.insert(GenericCastExpr->getCastKind());
+        GenericCastExpr = dyn_cast<CastExpr>(GenericCastExpr->getSubExpr());
+      }
+
+      Casts.push_back(Op.getCastKindFromCStyleCast());
+    }
+  };
+
+protected:
+  ClangCXXCastTest() : CStyleCastMatcher(cStyleCastExpr().bind(CastVar)) {}
+
+  std::pair<CastKindSet, CXXCastVector> parse(const StringRef Code) {
+    // Parses a single translation unit (from text)
+    // and returns the CXXCasts in order of traversed.
+    std::unique_ptr<clang::ASTUnit> ast(clang::tooling::buildASTFromCode(Code));
+    CStyleCastCollector Collector;
+    MatchFinder Finder;
+    Finder.addMatcher(CStyleCastMatcher, &Collector);
+    Finder.matchAST(ast->getASTContext());
+    return {Collector.CastKinds, Collector.Casts};
+  }
+};
+
+class ClangQualifierModificationTest : public ::testing::Test {
+  StatementMatcher CStyleCastMatcher;
+
+  struct QualifierChecker : MatchFinder::MatchCallback {
+    bool RequireConstCast;
+    bool Pedantic;
+
+    QualifierChecker(const bool Pedantic) : Pedantic(Pedantic){};
+
+    virtual void run(const MatchFinder::MatchResult &Result) override {
+      ASTContext *Context = Result.Context;
+      const CStyleCastExpr *CastExpression =
+          Result.Nodes.getNodeAs<CStyleCastExpr>(CastVar);
+      assert(CastExpression && Context);
+      CStyleCastOperation Op(*CastExpression, *Context, Pedantic);
+
+      RequireConstCast = Op.requireConstCast();
+    }
+  };
+
+protected:
+  ClangQualifierModificationTest()
+      : CStyleCastMatcher(cStyleCastExpr().bind(CastVar)) {}
+
+  bool parse(const StringRef Code, bool Pedantic) {
+    std::unique_ptr<clang::ASTUnit> ast(clang::tooling::buildASTFromCode(Code));
+    QualifierChecker Checker(Pedantic);
+    MatchFinder Finder;
+    Finder.addMatcher(CStyleCastMatcher, &Checker);
+    Finder.matchAST(ast->getASTContext());
+    return Checker.RequireConstCast;
+  }
+};
+
+class ClangFunctionPtrDetectionTest : public ::testing::Test {
+  DeclarationMatcher VarDeclMatcher;
+
+  struct FunctionPtrDetector : MatchFinder::MatchCallback {
+    bool FoundFunctionPtr;
+    FunctionPtrDetector() = default;
+
+    virtual void run(const MatchFinder::MatchResult &Result) override {
+      const VarDecl *DeclExpr = Result.Nodes.getNodeAs<VarDecl>(DeclVar);
+      assert(DeclExpr);
+      QualType CanonicalDeclType = DeclExpr->getType().getCanonicalType();
+      FoundFunctionPtr = details::isFunctionPtr(CanonicalDeclType);
+    }
+  };
+
+protected:
+  ClangFunctionPtrDetectionTest() : VarDeclMatcher(varDecl().bind(DeclVar)) {}
+
+  bool parse(const StringRef Code) {
+    std::unique_ptr<clang::ASTUnit> ast(clang::tooling::buildASTFromCode(Code));
+    FunctionPtrDetector Detector;
+    MatchFinder Finder;
+    Finder.addMatcher(VarDeclMatcher, &Detector);
+    Finder.matchAST(ast->getASTContext());
+    return Detector.FoundFunctionPtr;
+  }
+};
+
+class ChangeQualifierTest : public ::testing::Test {
+  StatementMatcher CStyleCastMatcher;
+  DeclarationMatcher DeclMatcher;
+
+  struct QualifierChanger : MatchFinder::MatchCallback {
+    QualType ChangedCanonicalType;
+    bool Pedantic;
+    QualifierChanger(const bool Pedantic) : Pedantic(Pedantic) {}
+
+    virtual void run(const MatchFinder::MatchResult &Result) override {
+      ASTContext *Context = Result.Context;
+      const CStyleCastExpr *CastExpression =
+          Result.Nodes.getNodeAs<CStyleCastExpr>(CastVar);
+      assert(CastExpression && Context);
+      CStyleCastOperation Op(*CastExpression, *Context, Pedantic);
+
+      ChangedCanonicalType = Op.changeQualifiers().getCanonicalType();
+    }
+  };
+
+  struct DeclTypeMatcher : MatchFinder::MatchCallback {
+    QualType FoundCanonicalType;
+    DeclTypeMatcher() = default;
+
+    virtual void run(const MatchFinder::MatchResult &Result) override {
+      const VarDecl *DeclExpr = Result.Nodes.getNodeAs<VarDecl>(DeclVar);
+      assert(DeclExpr);
+
+      FoundCanonicalType = DeclExpr->getType().getCanonicalType();
+    }
+  };
+
+protected:
+  ChangeQualifierTest()
+      : CStyleCastMatcher(cStyleCastExpr().bind(CastVar)),
+        DeclMatcher(varDecl().bind(DeclVar)) {}
+
+  bool parse(const StringRef CastCode, bool Pedantic) {
+    std::unique_ptr<clang::ASTUnit> CastAst(
+        clang::tooling::buildASTFromCode(CastCode));
+    std::unique_ptr<clang::ASTUnit> TypeAst(
+        clang::tooling::buildASTFromCode(CastCode));
+    QualifierChanger Changer(Pedantic);
+    DeclTypeMatcher TypeMatcher;
+    {
+      MatchFinder Finder;
+      Finder.addMatcher(CStyleCastMatcher, &Changer);
+      Finder.matchAST(CastAst->getASTContext());
+    }
+    {
+      MatchFinder Finder;
+      Finder.addMatcher(DeclMatcher, &TypeMatcher);
+      Finder.matchAST(TypeAst->getASTContext());
+    }
+    return Changer.ChangedCanonicalType.getAsString() ==
+           TypeMatcher.FoundCanonicalType.getAsString();
+  }
+};
+
+TEST_F(ClangCXXCastTest, TestNoOpCastTypes) {
+  CLANG_CXX_CAST_CHECK(NoOp, NoOpCast);
+  CLANG_CXX_CAST_CHECK(ArrayToPointerDecay, NoOpCast);
+  // Unchecked: CLANG_CXX_CAST_CHECK(LValueToRValue, ConstCast);
+}
+
+TEST_F(ClangCXXCastTest, TestReinterpretCastTypes) {
+  CLANG_CXX_CAST_CHECK(BitCast, ReinterpretCast);
+  CLANG_CXX_CAST_CHECK(LValueBitCast, ReinterpretCast);
+  CLANG_CXX_CAST_CHECK(IntegralToPointer, ReinterpretCast);
+  CLANG_CXX_CAST_CHECK(ReinterpretMemberPointer, ReinterpretCast);
+  CLANG_CXX_CAST_CHECK(PointerToIntegral, ReinterpretCast);
+}
+
+TEST_F(ClangCXXCastTest, TestStaticCastTypes) {
+  CLANG_CXX_CAST_CHECK(BaseToDerived, StaticCast);
+  CLANG_CXX_CAST_CHECK(DerivedToBase, StaticCast);
+  // Unchecked: CLANG_CXX_CAST_CHECK(UncheckedDerivedToBase, StaticCast);
+  CLANG_CXX_CAST_CHECK(FunctionToPointerDecay, StaticCast);
+  CLANG_CXX_CAST_CHECK(NullToPointer, StaticCast);
+  CLANG_CXX_CAST_CHECK(NullToMemberPointer, StaticCast);
+  CLANG_CXX_CAST_CHECK(BaseToDerivedMemberPointer, StaticCast);
+  CLANG_CXX_CAST_CHECK(DerivedToBaseMemberPointer, StaticCast);
+  CLANG_CXX_CAST_CHECK(MemberPointerToBoolean, StaticCast);
+  CLANG_CXX_CAST_CHECK(UserDefinedConversion, StaticCast);
+  CLANG_CXX_CAST_CHECK(ConstructorConversion, StaticCast);
+  CLANG_CXX_CAST_CHECK(PointerToBoolean, StaticCast);
+  CLANG_CXX_CAST_CHECK(ToVoid, StaticCast);
+  CLANG_CXX_CAST_CHECK(VectorSplat, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralCast, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralToBoolean, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralToFloating, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingToIntegral, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingToBoolean, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingCast, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingRealToComplex, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingComplexToReal, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingComplexToBoolean, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingComplexCast, StaticCast);
+  CLANG_CXX_CAST_CHECK(FloatingComplexToIntegralComplex, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralRealToComplex, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralComplexToReal, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralComplexToBoolean, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralComplexCast, StaticCast);
+  CLANG_CXX_CAST_CHECK(IntegralComplexToFloatingComplex, StaticCast);
+  CLANG_CXX_CAST_CHECK(AtomicToNonAtomic, StaticCast);
+  CLANG_CXX_CAST_CHECK(NonAtomicToAtomic, StaticCast);
+}
+
+TEST_F(ClangCXXCastTest, TestCStyleCastTypes) {
+  CLANG_CXX_CAST_CHECK(Dependent, CStyleCast);
+}
+
+TEST_F(ClangCXXCastTest, TestEdgeCases) {
+  using namespace edgecases;
+  {
+    auto res = parse(DerivedToBasePrivateSpecifier);
+    ASSERT_GE(res.first.size(), 1ul);
+    ASSERT_GE(res.second.size(), 1ul);
+    ASSERT_TRUE(res.first.find(CastKind::CK_DerivedToBase) != res.first.end());
+    ASSERT_EQ(res.second[0], CXXCast::CC_CStyleCast);
+  }
+  {
+    auto res = parse(BaseToDerivedPrivateSpecifier);
+    ASSERT_GE(res.first.size(), 1ul);
+    ASSERT_GE(res.second.size(), 1ul);
+    ASSERT_TRUE(res.first.find(CastKind::CK_BaseToDerived) != res.first.end());
+    ASSERT_EQ(res.second[0], CXXCast::CC_CStyleCast);
+  }
+  CLANG_CXX_CAST_CHECK(Dependent, CStyleCast);
+}
+
+/// These tests mean:
+/// Does the C-style cast in <test case> require a const_cast?
+TEST_F(ClangQualifierModificationTest, TestConstCases) {
+  CLANG_QUAL_CHECK(QualNoOp, false, false);
+  // add
+  // we perform these operations in order to first do a sanity check that
+  // 1. const cast isn't needed for upcasting
+  // 2. there will be no segmentation faults before we run the removal tests
+  CLANG_QUAL_CHECK(QualAddConst, false, false);
+  CLANG_QUAL_CHECK(QualAddPtrToConst, false, false);
+  CLANG_QUAL_CHECK(QualAddConstPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDoublePtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddMemberPtrToConst, false, false);
+  CLANG_QUAL_CHECK(QualAddConstMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDoubleMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDiffLevelMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstRef, false, false);
+  CLANG_QUAL_CHECK(QualAddConstArr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstPtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstPtrToArrOfConstPtrs, false, false);
+  CLANG_QUAL_CHECK(QualAddArrPtrConstData, false, false);
+  CLANG_QUAL_CHECK(QualAddDiffLevelArrPtrConstData, false, false);
+  CLANG_QUAL_CHECK(QualAddConstMixedPtrTypes, false, false);
+  CLANG_QUAL_CHECK(QualAddConstUnknownArrPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstUnknownArrPtrToKnownArrPtr, false, false);
+
+  // remove
+  // we perform these operations in order to check the positive cases, along
+  // with negative edge cases.
+  // does not require const cast - implicit
+  CLANG_QUAL_CHECK(QualRemoveConst, false, false);
+  // does require const cast, base type downcast
+  CLANG_QUAL_CHECK(QualRemovePtrToConst, true, false);
+  // does not - implicit
+  CLANG_QUAL_CHECK(QualRemoveConstPtr, false, false);
+  // does - downcast
+  CLANG_QUAL_CHECK(QualRemoveConstDoublePtr, true, false);
+  // does not - level truncated
+  CLANG_QUAL_CHECK(QualRemoveConstDiffLevelPtr, false, false);
+
+  // Same as the above 4
+  CLANG_QUAL_CHECK(QualRemoveMemberPtrToConst, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveConstDoubleMemberPtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstDiffLevelMemberPtr, false, false);
+
+  // does - downcast
+  CLANG_QUAL_CHECK(QualRemoveConstRef, true, false);
+  // does - downcast
+  CLANG_QUAL_CHECK(QualRemoveConstArr, true, false);
+  // does not - implicit
+  CLANG_QUAL_CHECK(QualRemoveConstPtrToArr, false, false);
+  // does - downcast
+  CLANG_QUAL_CHECK(QualRemoveConstPtrToArrOfConstPtrs, true, false);
+  // does - downcast
+  CLANG_QUAL_CHECK(QualRemoveArrPtrConstData, true, false);
+  // does not - level truncated
+  CLANG_QUAL_CHECK(QualRemoveDiffLevelArrPtrConstData, false, false);
+  // does - similar types going down
+  CLANG_QUAL_CHECK(QualRemoveSimilarPtrsBeyondArrConstData, true, false);
+  // does - All pointer-like types are downcasted
+  CLANG_QUAL_CHECK(QualRemoveConstMixedPtrTypes, true, false);
+  // does - Unknown size array is similar to unknown size array
+  CLANG_QUAL_CHECK(QualRemoveConstUnknownArrPtr, true, false);
+  // does - Unknown size array is similar to known size array
+  CLANG_QUAL_CHECK(QualRemoveConstUnknownArrPtrToKnownArrPtr, true, false);
+
+  // Checking for pedantic changes
+  CLANG_QUAL_CHECK(QualNoOp, false, false);
+  CLANG_QUAL_CHECK(QualAddConst, false, false);
+  CLANG_QUAL_CHECK(QualAddPtrToConst, false, false);
+  CLANG_QUAL_CHECK(QualAddConstPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDoublePtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddMemberPtrToConst, false, false);
+  CLANG_QUAL_CHECK(QualAddConstMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDoubleMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstDiffLevelMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstRef, false, false);
+  CLANG_QUAL_CHECK(QualAddConstArr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstPtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstPtrToArrOfConstPtrs, false, false);
+  CLANG_QUAL_CHECK(QualAddArrPtrConstData, false, false);
+  CLANG_QUAL_CHECK(QualAddDiffLevelArrPtrConstData, false, false);
+  CLANG_QUAL_CHECK(QualAddConstMixedPtrTypes, false, false);
+  CLANG_QUAL_CHECK(QualAddConstUnknownArrPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddConstUnknownArrPtrToKnownArrPtr, false, false);
+
+  CLANG_QUAL_CHECK(QualRemoveConst, false, false);
+  CLANG_QUAL_CHECK(QualRemovePtrToConst, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveConstDoublePtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveMemberPtrToConst, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveConstDoubleMemberPtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstDiffLevelMemberPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveConstRef, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstArr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstPtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveConstPtrToArrOfConstPtrs, true, false);
+  CLANG_QUAL_CHECK(QualRemoveArrPtrConstData, true, false);
+  CLANG_QUAL_CHECK(QualRemoveDiffLevelArrPtrConstData, false, false);
+  CLANG_QUAL_CHECK(QualRemoveSimilarPtrsBeyondArrConstData, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstMixedPtrTypes, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstUnknownArrPtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveConstUnknownArrPtrToKnownArrPtr, true, false);
+}
+
+TEST_F(ClangQualifierModificationTest, TestVolatileCases) {
+  // add
+  CLANG_QUAL_CHECK(QualAddVolatile, false, false);
+  CLANG_QUAL_CHECK(QualAddPtrToVolatile, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatilePtr, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileDoublePtr, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileRef, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileArr, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatilePtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatilePtrToArrOfVolatilePtrs, false, false);
+  CLANG_QUAL_CHECK(QualAddArrPtrVolatileData, false, false);
+  CLANG_QUAL_CHECK(QualAddDiffLevelArrPtrVolatileData, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileMixedPtrTypes, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileUnknownArrPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddVolatileUnknownArrPtrToKnownArrPtr, false, false);
+
+  // remove
+  CLANG_QUAL_CHECK(QualRemoveVolatile, false, false);
+  CLANG_QUAL_CHECK(QualRemovePtrToVolatile, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatilePtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileDoublePtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileRef, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileArr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatilePtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatilePtrToArrOfVolatilePtrs, true, false);
+  CLANG_QUAL_CHECK(QualRemoveArrPtrVolatileData, true, false);
+  CLANG_QUAL_CHECK(QualRemoveDiffLevelArrPtrVolatileData, false, false);
+  CLANG_QUAL_CHECK(QualRemoveSimilarPtrsBeyondArrVolatileData, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileMixedPtrTypes, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileUnknownArrPtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveVolatileUnknownArrPtrToKnownArrPtr, true, false);
+}
+
+TEST_F(ClangQualifierModificationTest, TestRestrictCases) {
+  // add
+  CLANG_QUAL_CHECK(QualAddRestrictPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictDoublePtr, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictArr, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictPtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictPtrToArrOfRestrictPtrs, false, false);
+  CLANG_QUAL_CHECK(QualAddArrPtrRestrictData, false, false);
+  CLANG_QUAL_CHECK(QualAddDiffLevelArrPtrRestrictData, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictMixedPtrTypes, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictUnknownArrPtr, false, false);
+  CLANG_QUAL_CHECK(QualAddRestrictUnknownArrPtrToKnownArrPtr, false, false);
+
+  // remove
+  CLANG_QUAL_CHECK(QualRemoveRestrictPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictDoublePtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictDiffLevelPtr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictArr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictPtrToArr, false, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictPtrToArrOfRestrictPtrs, true, false);
+  CLANG_QUAL_CHECK(QualRemoveArrPtrRestrictData, true, false);
+  CLANG_QUAL_CHECK(QualRemoveDiffLevelArrPtrRestrictData, false, false);
+  CLANG_QUAL_CHECK(QualRemoveSimilarPtrsBeyondArrRestrictData, true, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictMixedPtrTypes, true, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictUnknownArrPtr, true, false);
+  CLANG_QUAL_CHECK(QualRemoveRestrictUnknownArrPtrToKnownArrPtr, true, false);
+}
+
+TEST_F(ClangFunctionPtrDetectionTest, TestFuncPtrs) {
+  CLANG_FUNC_PTR_CHECK(Scalar, false);
+  CLANG_FUNC_PTR_CHECK(ArrOfFreeFunctionPtr, false);
+  CLANG_FUNC_PTR_CHECK(NestedFreeFunctionPtr, false);
+  CLANG_FUNC_PTR_CHECK(FreeFunction, true);
+  CLANG_FUNC_PTR_CHECK(ArrOfMemberFunction, false);
+  CLANG_FUNC_PTR_CHECK(NestedMemberFunction, false);
+  CLANG_FUNC_PTR_CHECK(MemberFunction, true);
+}
+
+TEST_F(ChangeQualifierTest, TestChangeQualifiers) {
+  ASSERT_TRUE(parse(extension::NoQualifierChange, false));
+  ASSERT_TRUE(parse(extension::NoQualifierChangeReinterpret, false));
+  ASSERT_TRUE(parse(extension::ChangeNestedPointers, false));
+  ASSERT_TRUE(parse(extension::ChangeNestedPointersReinterpret, false));
+  ASSERT_TRUE(parse(extension::ChangeNestedPointersUntilArray, false));
+  ASSERT_TRUE(
+      parse(extension::ChangeNestedPointersUntilArrayReinterpret, false));
+  ASSERT_TRUE(parse(extension::NoModificationToMixedPtrTypes, false));
+  ASSERT_TRUE(parse(extension::DontChangeMemberFuncPtr, false));
+  ASSERT_TRUE(parse(extension::ChangeNestedPointersUntilMemberVsNot, false));
+
+  ASSERT_TRUE(parse(pedantic::NoQualifierChange, true));
+  ASSERT_TRUE(parse(pedantic::NoQualifierChangeReinterpret, true));
+  ASSERT_TRUE(parse(pedantic::ChangeNestedPointers, true));
+  ASSERT_TRUE(parse(pedantic::ChangeNestedPointersReinterpret, true));
+  ASSERT_TRUE(parse(pedantic::ChangeNestedPointersUntilArray, true));
+  ASSERT_TRUE(parse(pedantic::ChangeNestedPointersUntilArrayReinterpret, true));
+  ASSERT_TRUE(parse(pedantic::NoModificationToMixedPtrTypes, true));
+  ASSERT_TRUE(parse(pedantic::DontChangeMemberFuncPtr, true));
+  ASSERT_TRUE(parse(pedantic::ChangeNestedPointersUntilMemberVsNot, true));
+}
diff --git a/clang-tools-extra/unittests/clang-cast/ClangChangeQualifierTestCases.h b/clang-tools-extra/unittests/clang-cast/ClangChangeQualifierTestCases.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/unittests/clang-cast/ClangChangeQualifierTestCases.h
@@ -0,0 +1,199 @@
+//===-- ClangChangeQualifierTestCases.h - clang-cast ------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains test cases for
+/// CStyleCast::changeQualifiers (defined in Cast.h)
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PROJECT_CLANGCHANGEQUALIFIERTESTCASES_H
+#define LLVM_PROJECT_CLANGCHANGEQUALIFIERTESTCASES_H
+
+/// NOTE: We are not performing an implicit cast conversion, so the types
+/// are exactly decltype(p) when we pass it into changeQualifiers().
+namespace testcases {
+namespace changequal {
+namespace extension {
+static const char NoQualifierChange[] = R"(
+void f() {
+  const int * const p {};
+  (const int * const) p;
+  // Expected type
+  const int * const x {};
+}
+)";
+static const char NoQualifierChangeReinterpret[] = R"(
+void f() {
+  const int * const p {};
+  (const double * const) p;
+  // Expected type
+  const double * const x {};
+}
+)";
+
+// Change all of these pointer qualifiers down
+static const char ChangeNestedPointers[] = R"(
+void f() {
+  const int * const * volatile * __restrict p {};
+  (int***) p;
+  // Expected type
+  const int* const * volatile * __restrict x {};
+}
+)";
+static const char ChangeNestedPointersReinterpret[] = R"(
+void f() {
+  const int * const * volatile * __restrict p {};
+  (double****) p;
+  // Expected type (note how we have 1 more layer of ptr)
+  double* const * const * volatile * __restrict x {};
+}
+)";
+
+// Stop the const cast up to an array type
+static const char ChangeNestedPointersUntilArray[] = R"(
+void f() {
+  int * const * volatile * __restrict (* const * volatile * __restrict p) [2] {};
+  (int*** (***)[2]) p;
+  // Expected type
+  int * const * volatile * __restrict (* const * volatile * __restrict x) [2] {};
+}
+)";
+static const char ChangeNestedPointersUntilArrayReinterpret[] = R"(
+void f() {
+  int * const * volatile * __restrict (* const * volatile * __restrict p) [2] {};
+  (double**** (***)[2]) p;
+  // Expected type
+  double ** const * volatile * __restrict (* const * volatile * __restrict x) [2] {};
+}
+)";
+static const char NoModificationToMixedPtrTypes[] = R"(
+struct t{};
+void f() {
+  double * __restrict t::* __restrict (t::* __restrict * __restrict a) [2];
+  (double * t::* (t::* *) [2]) a;
+  // Expected type
+  double * __restrict t::* __restrict (t::* __restrict * __restrict x) [2];
+}
+)";
+
+// The member function dropped const, but const_cast can't perform this
+// operation. It's up to reinterpret_cast to perform this.
+static const char DontChangeMemberFuncPtr[] = R"(
+struct t{};
+void f() {
+  void (t::* p)(void) const {};
+  (void (t::*)(void)) p;
+  // Expected type
+  void (t::* x)(void) {};
+}
+)";
+
+static const char ChangeNestedPointersUntilMemberVsNot[] = R"(
+struct t{};
+void f() {
+    const int* const t::* const t::* const p {};
+    (int** t::*) p;
+    // Expected type
+    int** const t::* const x {};
+}
+)";
+} // namespace extension
+
+namespace pedantic {
+
+static const char NoQualifierChange[] = R"(
+void f() {
+  const int * const p {};
+  (const int * const) p;
+  // Expected type
+  const int * const x {};
+}
+)";
+static const char NoQualifierChangeReinterpret[] = R"(
+void f() {
+  const int * const p {};
+  (const double * const) p;
+  // Expected type
+  const double * const x {};
+}
+)";
+
+// Change all of these pointer qualifiers down
+static const char ChangeNestedPointers[] = R"(
+void f() {
+  const int * const * volatile * __restrict p {};
+  (int***) p;
+  // Expected type
+  const int* const * volatile * __restrict x {};
+}
+)";
+static const char ChangeNestedPointersReinterpret[] = R"(
+void f() {
+  const int * const * volatile * __restrict p {};
+  (double****) p;
+  // Expected type (note how we have 1 more layer of ptr)
+  double* const * const * volatile * __restrict x {};
+}
+)";
+
+// Stop the const cast up to an array type
+static const char ChangeNestedPointersUntilArray[] = R"(
+void f() {
+  int * const * volatile * __restrict (* const * volatile * __restrict p) [2] {};
+  (int*** (***)[2]) p;
+  // Expected type
+  int * const * volatile * __restrict (* const * volatile * __restrict x) [2] {};
+}
+)";
+static const char ChangeNestedPointersUntilArrayReinterpret[] = R"(
+void f() {
+  int * const * volatile * __restrict (* const * volatile * __restrict p) [2] {};
+  (double**** (***)[2]) p;
+  // Expected type
+  double ** const * volatile * __restrict (* const * volatile * __restrict x) [2] {};
+}
+)";
+static const char NoModificationToMixedPtrTypes[] = R"(
+struct t{};
+void f() {
+  double * __restrict t::* __restrict (t::* __restrict * __restrict a) [2];
+  (double * t::* (t::* *) [2]) a;
+  // Expected type
+  double * __restrict t::* __restrict (t::* __restrict * __restrict x) [2];
+}
+)";
+
+// The member function dropped const, but const_cast can't perform this
+// operation. It's up to reinterpret_cast to perform this.
+static const char DontChangeMemberFuncPtr[] = R"(
+struct t{};
+void f() {
+  void (t::* p)(void) const {};
+  (void (t::*)(void)) p;
+  // Expected type
+  void (t::* x)(void) {};
+}
+)";
+
+static const char ChangeNestedPointersUntilMemberVsNot[] = R"(
+struct t{};
+void f() {
+    const int* const t::* const t::* const p {};
+    (int** t::*) p;
+    // Expected type
+    const int* const* const t::* const x {};
+}
+)";
+
+} // namespace pedantic
+
+} // namespace changequal
+} // namespace testcases
+
+#endif // LLVM_PROJECT_CLANGCHANGEQUALIFIERTESTCASES_H
diff --git a/clang-tools-extra/unittests/clang-cast/ClangFunctionPtrTestCases.h b/clang-tools-extra/unittests/clang-cast/ClangFunctionPtrTestCases.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/unittests/clang-cast/ClangFunctionPtrTestCases.h
@@ -0,0 +1,71 @@
+//===-- ClangFunctionPtrTestCases.h - clang-cast ----------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains test cases for
+/// details::isFunctionPtr (defined in CastUtils.h)
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_PROJECT_CLANGFUNCTIONPTRTESTCASES_H
+#define LLVM_PROJECT_CLANGFUNCTIONPTRTESTCASES_H
+
+namespace testcases {
+namespace funcptr {
+
+// Out of all of these tests, we should ideally only identify the cases of
+// FreeFunction and MemberFunction.
+
+static const char Scalar[] = R"(
+void f() {
+  bool a {};
+}
+)";
+
+static const char ArrOfFreeFunctionPtr[] = R"(
+void f() {
+  void (*a[2])(void){};
+}
+)";
+
+static const char NestedFreeFunctionPtr[] = R"(
+void f() {
+  void (**a)(void) {};
+}
+)";
+
+static const char FreeFunction[] = R"(
+void f() {
+  void (*a)(void) {};
+}
+)";
+
+static const char ArrOfMemberFunction[] = R"(
+struct t{};
+void f() {
+  void (t::* a[2])(void) const {};
+}
+)";
+
+static const char NestedMemberFunction[] = R"(
+struct t{};
+void f() {
+  void (t::** a)(void) const {};
+}
+)";
+
+static const char MemberFunction[] = R"(
+struct t{};
+void f() {
+  void (t::* a)(void) const {};
+}
+)";
+} // namespace funcptr
+} // namespace testcases
+
+#endif // LLVM_PROJECT_CLANGFUNCTIONPTRTESTCASES_H
diff --git a/clang-tools-extra/unittests/clang-cast/ClangQualifierTestCases.h b/clang-tools-extra/unittests/clang-cast/ClangQualifierTestCases.h
new file mode 100644
--- /dev/null
+++ b/clang-tools-extra/unittests/clang-cast/ClangQualifierTestCases.h
@@ -0,0 +1,603 @@
+//===-- ClangQualifierTestCases.h - clang-cast ------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// This file contains test cases for
+/// CStyleCastOperation::requireConstCast (defined in Cast.h)
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_CAST_CLANGQUALIFIERTESTCASES_H
+#define LLVM_CLANG_TOOLS_EXTRA_UNITTESTS_CLANG_CAST_CLANGQUALIFIERTESTCASES_H
+
+namespace testcases {
+
+namespace constcheck {
+/// No-op
+static const char QualNoOp[] = R"(
+void f() {
+  (bool) 0;
+}
+)";
+
+/// Const
+/// Adding const doesn't require const_cast
+static const char QualAddConst[] = R"(
+void f() {
+  int x = 0;
+  (const int) x;
+}
+)";
+static const char QualAddPtrToConst[] = R"(
+void f() {
+  int* x = nullptr;
+  const int* y = (const int*) x;
+}
+)";
+static const char QualAddConstPtr[] = R"(
+void f() {
+  int* x = nullptr;
+  int* const y = (int* const) x;
+}
+)";
+static const char QualAddConstDoublePtr[] = R"(
+void f() {
+  int** x = nullptr;
+  int* const * const y = (int* const * const) x;
+}
+)";
+static const char QualAddConstDiffLevelPtr[] = R"(
+void f() {
+  int*** x = nullptr;
+  const int** y = (const int**) x;
+}
+)";
+static const char QualAddMemberPtrToConst[] = R"(
+struct t{};
+void f() {
+  int t::* x = nullptr;
+  const int t::* y = (const int t::*) x;
+}
+)";
+static const char QualAddConstMemberPtr[] = R"(
+struct t{};
+void f() {
+  int t::* x = nullptr;
+  int t::* const y = (int t::* const) x;
+}
+)";
+static const char QualAddConstDoubleMemberPtr[] = R"(
+struct t{};
+void f() {
+  int t::* t::* x = nullptr;
+  int t::* const t::* const y = (int t::* const t::* const) x;
+}
+)";
+static const char QualAddConstDiffLevelMemberPtr[] = R"(
+struct t{};
+void f() {
+  int t::* t::* t::* x = nullptr;
+  const int t::* t::* y = (const int t::* t::*) x;
+}
+)";
+static const char QualAddConstRef[] = R"(
+void f() {
+  int x = 1;
+  int& y = x;
+  const int& z = (const int&) y;
+}
+)";
+static const char QualAddConstArr[] = R"(
+void f() {
+  double a[2] {1, 2};
+  const double* ca = (const double*) a;
+}
+)";
+static const char QualAddConstPtrToArr[] = R"(
+void f() {
+  double (*a)[2] {};
+  (double(* const)[2]) a;
+}
+)";
+static const char QualAddConstPtrToArrOfConstPtrs[] = R"(
+void f() {
+  double* (*a)[2] {};
+  (double * const (* const)[2]) a;
+}
+)";
+static const char QualAddArrPtrConstData[] = R"(
+void f() {
+  double (*a)[2] {};
+  (const double(*)[2]) a;
+}
+)";
+static const char QualAddDiffLevelArrPtrConstData[] = R"(
+void f() {
+  double (*a)[2] {};
+  (const double* (*)[2]) a;
+}
+)";
+static const char QualAddConstMixedPtrTypes[] = R"(
+struct t {};
+void f() {
+  double * t::* (t::* *a) [2];
+  (const double * const t::* const (t::* const * const) [2]) a;
+}
+)";
+static const char QualAddConstUnknownArrPtr[] = R"(
+void f() {
+  int* (*x) [] {};
+  (const int* const (*)[]) x;
+}
+)";
+static const char QualAddConstUnknownArrPtrToKnownArrPtr[] = R"(
+void f() {
+  int* (*x) [] {};
+  (const int* const (*)[2]) x;
+}
+)";
+
+/// Removing const MIGHT require const_cast
+static const char QualRemoveConst[] = R"(
+void f() {
+  const int x = 0;
+  (int) x;
+}
+)";
+static const char QualRemovePtrToConst[] = R"(
+void f() {
+  const int* x = nullptr;
+  int* y = (int*) x;
+}
+)";
+static const char QualRemoveConstPtr[] = R"(
+void f() {
+  int* const x = nullptr;
+  int* y = (int*) x;
+}
+)";
+static const char QualRemoveConstDoublePtr[] = R"(
+void f() {
+  int* const * const x = nullptr;
+  int** y = (int**) x;
+}
+)";
+static const char QualRemoveConstDiffLevelPtr[] = R"(
+void f() {
+  const int*** x = nullptr;
+  int** y = (int**) x;
+}
+)";
+static const char QualRemoveMemberPtrToConst[] = R"(
+struct t{};
+void f() {
+  const int t::* x = nullptr;
+  int t::* y = (int t::*) x;
+}
+)";
+static const char QualRemoveConstMemberPtr[] = R"(
+struct t{};
+void f() {
+  int t::* const x = nullptr;
+  int t::* y = (int t::*) x;
+}
+)";
+static const char QualRemoveConstDoubleMemberPtr[] = R"(
+struct t{};
+void f() {
+  int t::* const  t::* const x = nullptr;
+  int t::* t::* y = (int t::* t::*) x;
+}
+)";
+static const char QualRemoveConstDiffLevelMemberPtr[] = R"(
+struct t{};
+void f() {
+  const int t::* t::* t::* x = nullptr;
+  int t::* t::* y = (int t::* t::*) x;
+}
+)";
+static const char QualRemoveConstRef[] = R"(
+void f() {
+  int x = 1;
+  const int& y = x;
+  int& z = (int&) y;
+}
+)";
+static const char QualRemoveConstArr[] = R"(
+void f() {
+  const double a[2] {1, 2};
+  double* ca = (double*) a;
+}
+)";
+static const char QualRemoveConstPtrToArr[] = R"(
+void f() {
+  double (* const a)[2] {};
+  (double(*)[2]) a;
+}
+)";
+static const char QualRemoveConstPtrToArrOfConstPtrs[] = R"(
+void f() {
+  double* const (* const a)[2] {};
+  (double* (*)[2]) a;
+}
+)";
+static const char QualRemoveArrPtrConstData[] = R"(
+void f() {
+  const double (*a)[2] {};
+  (double(*)[2]) a;
+}
+)";
+static const char QualRemoveDiffLevelArrPtrConstData[] = R"(
+void f() {
+  const double* (*a)[2] {};
+  (double (*)[2]) a;
+}
+)";
+static const char QualRemoveSimilarPtrsBeyondArrConstData[] = R"(
+void f() {
+  const double* const (* const a)[2] {};
+  (double* const (* const)[2]) a;
+}
+)";
+static const char QualRemoveConstMixedPtrTypes[] = R"(
+struct t {};
+void f() {
+  const double * const t::* const (t::* const * const a) [2] {};
+  (double * t::* (t::* *) [2]) a;
+}
+)";
+static const char QualRemoveConstUnknownArrPtr[] = R"(
+void f() {
+  const int* const (*x) [] {};
+  (int* (*)[]) x;
+}
+)";
+static const char QualRemoveConstUnknownArrPtrToKnownArrPtr[] = R"(
+void f() {
+  const int* const (*x) [] {};
+  (int* (*)[2]) x;
+}
+)";
+
+/// Volatile
+/// add
+static const char QualAddVolatile[] = R"(
+void f() {
+  int x = 0;
+  (volatile int) x;
+}
+)";
+static const char QualAddPtrToVolatile[] = R"(
+void f() {
+  int* x = nullptr;
+  volatile int* y = (volatile int*) x;
+}
+)";
+static const char QualAddVolatilePtr[] = R"(
+void f() {
+  int* x = nullptr;
+  int* volatile y = (int* volatile) x;
+}
+)";
+static const char QualAddVolatileDoublePtr[] = R"(
+void f() {
+  int** x = nullptr;
+  int* volatile * volatile y = (int* volatile * volatile) x;
+}
+)";
+static const char QualAddVolatileDiffLevelPtr[] = R"(
+void f() {
+  int*** x = nullptr;
+  volatile int** y = (volatile int**) x;
+}
+)";
+static const char QualAddVolatileRef[] = R"(
+void f() {
+  int x = 1;
+  int& y = x;
+  volatile int& z = (volatile int&) y;
+}
+)";
+static const char QualAddVolatileArr[] = R"(
+void f() {
+  double a[2] {1, 2};
+  volatile double* ca = (volatile double*) a;
+}
+)";
+static const char QualAddVolatilePtrToArr[] = R"(
+void f() {
+  double (*a)[2] {};
+  (double(* volatile)[2]) a;
+}
+)";
+static const char QualAddVolatilePtrToArrOfVolatilePtrs[] = R"(
+void f() {
+  double* (*a)[2] {};
+  (double * volatile (* volatile)[2]) a;
+}
+)";
+static const char QualAddArrPtrVolatileData[] = R"(
+void f() {
+  double (*a)[2] {};
+  (volatile double(*)[2]) a;
+}
+)";
+static const char QualAddDiffLevelArrPtrVolatileData[] = R"(
+void f() {
+  double (*a)[2] {};
+  (volatile double* (*)[2]) a;
+}
+)";
+static const char QualRemoveSimilarPtrsBeyondArrVolatileData[] = R"(
+void f() {
+  volatile double* volatile (* volatile a)[2] {};
+  (double* volatile (* volatile)[2]) a;
+}
+)";
+static const char QualAddVolatileMixedPtrTypes[] = R"(
+struct t {};
+void f() {
+  double * t::* (t::* *a) [2];
+  (volatile double * volatile t::* volatile (t::* volatile * volatile) [2]) a;
+}
+)";
+static const char QualAddVolatileUnknownArrPtr[] = R"(
+void f() {
+  int* (*x) [] {};
+  (volatile int* volatile (*)[]) x;
+}
+)";
+static const char QualAddVolatileUnknownArrPtrToKnownArrPtr[] = R"(
+void f() {
+  int* (*x) [] {};
+  (volatile int* volatile (*)[2]) x;
+}
+)";
+
+/// remove
+static const char QualRemoveVolatile[] = R"(
+void f() {
+  volatile int x = 0;
+  (int) x;
+}
+)";
+static const char QualRemovePtrToVolatile[] = R"(
+void f() {
+  volatile int* x = nullptr;
+  int* y = (int*) x;
+}
+)";
+static const char QualRemoveVolatilePtr[] = R"(
+void f() {
+  int* volatile x = nullptr;
+  int* y = (int*) x;
+}
+)";
+static const char QualRemoveVolatileDoublePtr[] = R"(
+void f() {
+  int* volatile * volatile x = nullptr;
+  int** y = (int**) x;
+}
+)";
+static const char QualRemoveVolatileDiffLevelPtr[] = R"(
+void f() {
+  volatile int*** x = nullptr;
+  int** y = (int**) x;
+}
+)";
+static const char QualRemoveVolatileRef[] = R"(
+void f() {
+  int x = 1;
+  volatile int& y = x;
+  int& z = (int&) y;
+}
+)";
+static const char QualRemoveVolatileArr[] = R"(
+void f() {
+  volatile double a[2] {1, 2};
+  double* ca = (double*) a;
+}
+)";
+static const char QualRemoveVolatilePtrToArr[] = R"(
+void f() {
+  double (* volatile a)[2] {};
+  (double(*)[2]) a;
+}
+)";
+static const char QualRemoveVolatilePtrToArrOfVolatilePtrs[] = R"(
+void f() {
+  double* volatile (* volatile a)[2] {};
+  (double* (*)[2]) a;
+}
+)";
+static const char QualRemoveArrPtrVolatileData[] = R"(
+void f() {
+  volatile double (*a)[2] {};
+  (double(*)[2]) a;
+}
+)";
+static const char QualRemoveDiffLevelArrPtrVolatileData[] = R"(
+void f() {
+  volatile double* (*a)[2] {};
+  (double (*)[2]) a;
+}
+)";
+static const char QualRemoveVolatileMixedPtrTypes[] = R"(
+struct t {};
+void f() {
+  volatile double * volatile t::* volatile (t::* volatile * volatile a) [2] {};
+  (double * t::* (t::* *) [2]) a;
+}
+)";
+static const char QualRemoveVolatileUnknownArrPtr[] = R"(
+void f() {
+  volatile int* volatile (*x) [] {};
+  (int* (*)[]) x;
+}
+)";
+static const char QualRemoveVolatileUnknownArrPtrToKnownArrPtr[] = R"(
+void f() {
+  volatile int* volatile (*x) [] {};
+  (int* (*)[2]) x;
+}
+)";
+
+/// Restricted
+/// add
+static const char QualAddRestrictPtr[] = R"(
+void f() {
+  int* x = nullptr;
+  int* __restrict y = (int* __restrict) x;
+}
+)";
+static const char QualAddRestrictDoublePtr[] = R"(
+void f() {
+  int** x = nullptr;
+  int* __restrict * __restrict y = (int* __restrict * __restrict) x;
+}
+)";
+// Add another layer of pointers to decorate __restrict on
+static const char QualAddRestrictDiffLevelPtr[] = R"(
+void f() {
+  int** x = nullptr;
+  int* __restrict *** y = (int* __restrict ***) x;
+}
+)";
+// Add another layers of pointers to decorate __restrict on
+static const char QualAddRestrictArr[] = R"(
+void f() {
+  double* a[2] {};
+  double* __restrict * ca = (double* __restrict *) a;
+}
+)";
+static const char QualAddRestrictPtrToArr[] = R"(
+void f() {
+  double (*a)[2] {};
+  (double(* __restrict)[2]) a;
+}
+)";
+static const char QualAddRestrictPtrToArrOfRestrictPtrs[] = R"(
+void f() {
+  double* (*a)[2] {};
+  (double* __restrict (* __restrict)[2]) a;
+}
+)";
+// Add another layer of pointers to decorate __restrict on
+static const char QualAddArrPtrRestrictData[] = R"(
+void f() {
+  double* (*a)[2] {};
+  (double* __restrict (*)[2]) a;
+}
+)";
+// Add another layer of pointers to decorate __restrict on
+static const char QualAddDiffLevelArrPtrRestrictData[] = R"(
+void f() {
+  double (*a)[2] {};
+  (double* __restrict *(*)[2]) a;
+}
+)";
+static const char QualAddRestrictMixedPtrTypes[] = R"(
+struct t {};
+void f() {
+  double * t::* (t::* *a) [2];
+  (double * __restrict t::* __restrict (t::* __restrict * __restrict) [2]) a;
+}
+)";
+static const char QualAddRestrictUnknownArrPtr[] = R"(
+void f() {
+  int* (*x) [] {};
+  (int* __restrict (*)[]) x;
+}
+)";
+static const char QualAddRestrictUnknownArrPtrToKnownArrPtr[] = R"(
+void f() {
+  int* (*x) [] {};
+  (int* __restrict (*)[2]) x;
+}
+)";
+
+/// remove
+static const char QualRemoveRestrictPtr[] = R"(
+void f() {
+  int* __restrict x = nullptr;
+  int* y = (int*) x;
+}
+)";
+static const char QualRemoveRestrictDoublePtr[] = R"(
+void f() {
+  int* __restrict * __restrict x = nullptr;
+  int** y = (int**) x;
+}
+)";
+static const char QualRemoveRestrictDiffLevelPtr[] = R"(
+void f() {
+  int* __restrict *** x = nullptr;
+  int** y = (int**) x;
+}
+)";
+static const char QualRemoveRestrictArr[] = R"(
+void f() {
+  double* __restrict a[2] {};
+  double** ca = (double**) a;
+}
+)";
+static const char QualRemoveRestrictPtrToArr[] = R"(
+void f() {
+  double (* __restrict a)[2] {};
+  (double(*)[2]) a;
+}
+)";
+static const char QualRemoveRestrictPtrToArrOfRestrictPtrs[] = R"(
+void f() {
+  double* __restrict (* __restrict a)[2] {};
+  (double* (*)[2]) a;
+}
+)";
+static const char QualRemoveArrPtrRestrictData[] = R"(
+void f() {
+  double* __restrict (*a)[2] {};
+  (double* (*)[2]) a;
+}
+)";
+static const char QualRemoveDiffLevelArrPtrRestrictData[] = R"(
+void f() {
+  double* __restrict *(*a)[2] {};
+  (double (*)[2]) a;
+}
+)";
+static const char QualRemoveSimilarPtrsBeyondArrRestrictData[] = R"(
+void f() {
+  double* __restrict * __restrict (* __restrict a)[2] {};
+  (double* * __restrict (* __restrict)[2]) a;
+}
+)";
+static const char QualRemoveRestrictMixedPtrTypes[] = R"(
+struct t {};
+void f() {
+  double * __restrict t::* __restrict (t::* __restrict * __restrict a) [2] {};
+  (double * t::* (t::* *) [2]) a;
+}
+)";
+static const char QualRemoveRestrictUnknownArrPtr[] = R"(
+void f() {
+  int* __restrict (*x) [] {};
+  (int* (*)[]) x;
+}
+)";
+static const char QualRemoveRestrictUnknownArrPtrToKnownArrPtr[] = R"(
+void f() {
+  int* __restrict (*x) [] {};
+  (int* (*)[2]) x;
+}
+)";
+
+} // namespace constcheck
+
+} // namespace testcases
+
+#endif // LLVM_PROJECT_CLANGQUALIFIERTESTCASES_H