MPITypeMismatchCheck for Clang-Tidy

[Alexander_Droste]

Summary

This check verifies if buffer type and MPI (Message Passing Interface)
datatype pairs match. All MPI datatypes defined by the MPI standard (3.1)
are verified by this check. User defined typedefs, custom MPI datatypes and
null pointer constants are skipped, in the course of verification.

Instructions on how to apply the check can be found at: https://github.com/0ax1/MPI-Checker/tree/master/examples

[Alexander_Droste]

Hi Alexander,

this is the check that verifies buffer type / MPI datatype inconsistencies
that was originally part of http://reviews.llvm.org/D12761.

docs/clang-tidy/checks/list.rst

63 ↗

(On Diff #62637)

Will be removed.

test/clang-tidy/misc-mpi-type-mismatch.cpp

3 ↗

(On Diff #62637)

This header needs to moved but I need some guidance where to put it so that the test file can access it. Using relative paths within the include seems not to be possible.

[Alexander_Droste]

• change comment style to LLVM style
• remove 'misc-m-p-i-type-mismatch' entry from list.rst (misc-mpi-type-mismatch is the correct one)

[Alexander_Droste]

• fix some comments

[Alexander_Droste]

• fix comments

[Alexander_Droste]

• remove superflous clang::

[alexfh]

Please re-generate the diff with full-context (http://llvm.org/docs/Phabricator.html#requesting-a-review-via-the-web-interface).

A bunch of style comments.

clang-tidy/misc/MpiTypeMismatchCheck.cpp

86 ↗

(On Diff #62653)

I don't think this needs to be a method of the check class. I'd say a static bool isMPIDataType(StringRef Type) is a proper interface, and it can have the list of types as a static local variable.

122 ↗

(On Diff #62653)

Since this method doesn't need any members of the class, it should be a static function instead.

130 ↗

(On Diff #62653)

Just return true;

138 ↗

(On Diff #62653)

Looks like you can use getText from clang/include/clang/Tooling/FixIt.h.

146 ↗

(On Diff #62653)

Since this method doesn't need any members of the class, it should be a static function instead.

151 ↗

(On Diff #62653)

No else after return, please. http://llvm.org/docs/CodingStandards.html#don-t-use-else-after-a-return

222 ↗

(On Diff #62653)

Should probably be a static function as well. ComplexCXXMatches can be a static local variable instead.

Same applies for the other similar methods.

233 ↗

(On Diff #62653)

Please use actual language options (e.g. from MatchResult).

262 ↗

(On Diff #62653)

Use ArrayRef<const Type *> instead.

268 ↗

(On Diff #62653)

Please use assignment-style initialization. http://llvm.org/docs/CodingStandards.html#do-not-use-braced-initializer-lists-to-call-a-constructor

271 ↗

(On Diff #62653)

Please use proper capitalization and punctuation in comments.

http://llvm.org/docs/CodingStandards.html#commenting

"When writing comments, write them as English prose, which means they should use proper capitalization, punctuation, etc."

Actually, I'm not sure these comments are helpful.

272 ↗

(On Diff #62653)

Use const auto * when the type of the variable is obvious (e.g. when the initializer literally spells it, like here).

276 ↗

(On Diff #62653)

else should be on the same line as the preceding }.

test/clang-tidy/misc-mpi-type-mismatch.cpp

4 ↗

(On Diff #62653)

We usually put headers needed for tests to a subdiretory (named after the test name) of the Inputs directory. See test/clang-tidy/modernize-loop-convert-extra.cpp, for example.

[Alexander_Droste]

Thanks for the review!

This update should address the requested changes:

• functions and variables are made static if possible
• usage of ArrayRef<const Type *> instead of SmallVector<..> &
• assignment init instead of braced init
• usage of tooling::fixit::getText instead of custom function
• no else after return
• remove superfluous single word comments
• const auto * if the deduced type is obvious
• add MPI mock header to test/clang-tidy/Inputs/misc-mpi-type-mismatch/mpimock.h
• pass LangOptions from the AST matcher result
• return bool in while loop directly instead of assigning true and calling break
• generate the diff with full context (git diff -U999999 master)

[Alexander_Droste]

• remove TODO

[alexfh]

clang-tidy/misc/MpiTypeMismatchCheck.cpp

147 ↗

(On Diff #62694)

What about this comment?

152 ↗

(On Diff #62694)

What about this comment? I find it convenient to mark comments "Done" when I address them, so it's easier to track the action items.

259 ↗

(On Diff #62694)

Diagnostics are not complete sentences, so they should not start with a capital letter and should not end with a period.

259 ↗

(On Diff #62694)

Please use formatting placeholders instead of concatenation: diag("buffer type '%0' does not match ...") << BufferTypeName << ....;.

271 ↗

(On Diff #62694)

It looks like you're trying to avoid unnecessary allocations by passing this buffer into the calls below. It would probably be even more efficient, if you moved this variable out of the loop.

clang-tidy/misc/MpiTypeMismatchCheck.h

128 ↗

(On Diff #62694)

These static members and corresponding methods don't have to be in the class. My comment might have been ambiguous, but I was actually suggesting to change the methods that use these maps to free-standing static functions in the .cpp file and make these maps static local variables in the corresponding functions.

[Alexander_Droste]

• make static functions free functions
• make static containers local to their corresponding functions
• only assign the buffer type name in case of an error
• fix capitalization and punctuation in error diagnostic
• usage of formatting placeholders instead of concatenation
• move buffer type name variable out of the loop

[Alexander_Droste]

clang-tidy/misc/MpiTypeMismatchCheck.cpp

153 ↗

(On Diff #63091)

Sure, I can do that. I marked all addressed comments with done.

272 ↗

(On Diff #63091)

I removed the unnecessary single word comments.

272 ↗

(On Diff #63091)

Further, the variable now only gets assigned in case of an error.

clang-tidy/misc/MpiTypeMismatchCheck.h

60 ↗

(On Diff #63091)

I see, this removes a lot of verbosity.

[Alexander_Droste]

• fix typo

[Alexander_Droste]

• simplify argumentType() function

[alexfh]

Thanks for addressing the comments. The code looks better now. My main concern at this point is that the name and the location of the check: "misc" is a place for the stuff we can't find a better place for, but here I guess we clearly want a separate module and a subdirectory for MPI-related checks (MPITidyModule, "mpi/"). The check name should be updated accordingly: "mpi-type-mismatch".

A few more comments inline.

clang-tidy/misc/MpiTypeMismatchCheck.cpp

212 ↗

(On Diff #63422)

llvm::StringMap should be more efficient here.

218 ↗

(On Diff #63422)

getQualifiedNameAsString returns a std::string, which will be destroyed at the end of this statement. TypedefToCompare will be a dangling reference then. Please change StringRef to std::string here.

Another question is whether you need getQualifiedNameAsString, which is rather expensive. Maybe you could use getName (it returns a StringRef and is relatively cheap) and additionally check that the name is in the global namespace?

220 ↗

(On Diff #63422)

Repeated lookups into a map are wasteful. Please store the result of find and use it to get the value.

[Alexander_Droste]

Thanks for looking over this once more. I'll set up an extra MPI folder and rename the check.

One comment inline.

clang-tidy/misc/MpiTypeMismatchCheck.cpp

218 ↗

(On Diff #63422)

No, it seems I can also simply use getName. Why is it necessary to check if the name is in the global namespace? How would that check look like?

[alexfh]

clang-tidy/misc/MpiTypeMismatchCheck.cpp

218 ↗

(On Diff #63422)

Verifying that the name is in the global namespace would make the check stricter, but there might not be a realistic case, where it would prevent a false positive. We could try without it.

[Alexander_Droste]

• use llvm::StringMap instead of std::map
• getQualifiedNameAsString -> getName
• remove redundant map lookup
• create MPIi module
• replace misc with mpi within the check

I created an MPI module based on how misc is set up. Somehow the
mpi-type-mismatch is not found when the tests are run or when I try to
apply the check on a project but I am assuming you see at first glance what
ingredient missing.

[alexfh]

clang-tidy/mpi/MPITidyModule.cpp

30 ↗

(On Diff #64985)

nit: s/lint/clang-tidy/ ;)

clang-tidy/mpi/TypeMismatchCheck.cpp

11 ↗

(On Diff #64985)

Since the header is used outside of its library, it should be moved to clang/include/StaticAnalyzer/....

50 ↗

(On Diff #64985)

nit: Please remove the empty line.

185 ↗

(On Diff #64985)

I think, getName can be used here as well.

256 ↗

(On Diff #64985)

Explicit captures would make the code more transparent.

256 ↗

(On Diff #64985)

It's not clear what this lambda does. Please add a comment.

clang-tidy/mpi/TypeMismatchCheck.h

52 ↗

(On Diff #64985)

With just one caller and two lines of implementation this method doesn't make the code any better. Please just inline it.

[Alexander_Droste]

• use new MPIFunctionClassifier.h path
• change getAsCXXRecordDecl()->getNameAsString() -> getAsCXXRecordDecl()->getName()
• add comment to addPair lambda
• rename ArgumentExpression to BufferExprs
• remove superfluous empty lines

Still, the type mismatch is somehow not found/listed by clang-tidy.
When invoking $LLVM_TRUNK/build/.../clang-tidy -checks='*' -list-checks | ag mpi
it does not show up. Something seems to be missing, in order to make the mpi module available.

[alexfh]

In D21962#492657, @Alexander_Droste wrote:

Still, the type mismatch is somehow not found/listed by clang-tidy.
When invoking $LLVM_TRUNK/build/.../clang-tidy -checks='*' -list-checks | ag mpi
it does not show up. Something seems to be missing, in order to make the mpi module available.

You need to add this to ClangTidyMain.cpp:

// This anchor is used to force the linker to link the MPIModule.
extern volatile int MPIModuleAnchorSource;
static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination =
    MPIModuleAnchorSource;

[alexfh]

A few more nits. Please ensure the tests pass once you get the mpi module linking to the clang-tidy binary.

docs/clang-tidy/checks/mpi-type-mismatch.rst

4 ↗

(On Diff #65052)

Remove extra =s.

12 ↗

(On Diff #65052)

Please make this a code-block (see other .rst files for an example).

12 ↗

(On Diff #65052)

Comments should be valid English prose including correct capitalization and punctuation (http://llvm.org/docs/CodingStandards.html#commenting). In code snippets inside documentation as well.

test/clang-tidy/Inputs/mpi-type-mismatch/mpimock.h

8 ↗

(On Diff #65052)

Use proper capitalization and punctuation, please.

test/clang-tidy/mpi-type-mismatch.cpp

12 ↗

(On Diff #65052)

Please leave the first CHECK-MESSAGES as is, but remove the common suffix [mpi-type-mismatch] from all other messages. This makes the test a bit easier to read.

[Alexander_Droste]

You need to add this to ClangTidyMain.cpp:

Thanks for pointing this out and reviewing the code once more!

[Alexander_Droste]

This update addresses all requested changes. All integration tests are still passing.

[Alexander_Droste]

• fix typo

[alexfh]

Looks good with one comment.

clang-tidy/mpi/TypeMismatchCheck.cpp

237 ↗

(On Diff #65074)

Use parentheses syntax for initialization.
http://llvm.org/docs/CodingStandards.html#do-not-use-braced-initializer-lists-to-call-a-constructor

[Alexander_Droste]

• use parentheses instead of braces

[alexfh]

Do you have commit access?

[Alexander_Droste]

Do you have commit access?

No, I don't have commit access.

[alexfh]

Alexander, FYI, the patch has been reverted, since it breaks multiple buildbots, e.g.

• http://lab.llvm.org:8011/builders/clang-cmake-armv7-a15/builds/13909/steps/ninja%20check%201/logs/FAIL%3A%20Clang%20Tools%3A%3Ampi-type-mismatch.cpp
• http://lab.llvm.org:8011/builders/clang-cmake-thumbv7-a15/builds/14191/steps/ninja%20check%201/logs/FAIL%3A%20Clang%20Tools%3A%3Ampi-type-mismatch.cpp
• http://lab.llvm.org:8011/builders/clang-cmake-aarch64-quick/builds/8891/steps/ninja%20check%201/logs/FAIL%3A%20Clang%20Tools%3A%3Ampi-type-mismatch.cpp

(all failures seem to be on ARM and PPC buildbots).

Please take a look.

[Alexander_Droste]

Hi, thanks for the notification! Obviously, on some systems char is unsigned by default
which is why the check now tolerates distinct signedness for char pairs.
http://blog.cdleary.com/2012/11/arm-chars-are-unsigned-by-default/
In addition, I removed the trailing white space from the test file.

[alexfh]

Running tests, will submit shortly.

docs/clang-tidy/checks/mpi-type-mismatch.rst

13 ↗

(On Diff #65404)

This doesn't parse - an extra newline is needed. I'll fix this myself.

[Alexander_Droste]

Thanks for re-committing this patch!

clang-tools-extra/trunk/clang-tidy/CMakeLists.txt

 add_subdirectory(plugin)
 add_subdirectory(boost)
 add_subdirectory(cert)
 add_subdirectory(llvm)
 add_subdirectory(cppcoreguidelines)
 add_subdirectory(google)
 add_subdirectory(misc)
 add_subdirectory(modernize)
+add_subdirectory(mpi)
 add_subdirectory(performance)
 add_subdirectory(readability)
 add_subdirectory(utils)

clang-tools-extra/trunk/clang-tidy/mpi/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS support)
+
+add_clang_library(clangTidyMPIModule
+  MPITidyModule.cpp
+  TypeMismatchCheck.cpp
+
+  LINK_LIBS
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangLex
+  clangTidy
+  clangTidyUtils
+  clangTooling
+  )

clang-tools-extra/trunk/clang-tidy/mpi/MPITidyModule.cpp

+//===--- MPITidyModule.cpp - clang-tidy -----------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "../ClangTidy.h"
+#include "../ClangTidyModule.h"
+#include "../ClangTidyModuleRegistry.h"
+#include "TypeMismatchCheck.h"
+
+namespace clang {
+namespace tidy {
+namespace mpi {
+
+class MPIModule : public ClangTidyModule {
+public:
+  void addCheckFactories(ClangTidyCheckFactories &CheckFactories) override {
+    CheckFactories.registerCheck<TypeMismatchCheck>("mpi-type-mismatch");
+  }
+};
+
+} // namespace mpi
+
+// Register the MPITidyModule using this statically initialized variable.
+static ClangTidyModuleRegistry::Add<mpi::MPIModule>
+    X("mpi-module", "Adds MPI clang-tidy checks.");
+
+// This anchor is used to force the linker to link in the generated object file
+// and thus register the MPIModule.
+volatile int MPIModuleAnchorSource = 0;
+
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/clang-tidy/mpi/TypeMismatchCheck.h

+//===--- TypeMismatchCheck.h - clang-tidy------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H
+#define LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H
+
+#include "../ClangTidy.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+
+namespace clang {
+namespace tidy {
+namespace mpi {
+
+/// This check verifies if buffer type and MPI (Message Passing Interface)
+/// datatype pairs match. All MPI datatypes defined by the MPI standard (3.1)
+/// are verified by this check. User defined typedefs, custom MPI datatypes and
+/// null pointer constants are skipped, in the course of verification.
+///
+/// For the user-facing documentation see:
+/// http://clang.llvm.org/extra/clang-tidy/checks/mpi-type-mismatch.html
+class TypeMismatchCheck : public ClangTidyCheck {
+public:
+  TypeMismatchCheck(StringRef Name, ClangTidyContext *Context)
+      : ClangTidyCheck(Name, Context) {}
+
+  void registerMatchers(ast_matchers::MatchFinder *Finder) override;
+  void check(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+private:
+  /// Check if the buffer type MPI datatype pairs match.
+  ///
+  /// \param BufferTypes buffer types
+  /// \param BufferExprs buffer arguments as expressions
+  /// \param MPIDatatypes MPI datatype
+  /// \param LO language options
+  void checkArguments(ArrayRef<const Type *> BufferTypes,
+                      ArrayRef<const Expr *> BufferExprs,
+                      ArrayRef<StringRef> MPIDatatypes,
+                      const LangOptions &LO);
+};
+
+} // namespace mpi
+} // namespace tidy
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_MPI_TYPE_MISMATCH_H

clang-tools-extra/trunk/clang-tidy/mpi/TypeMismatchCheck.cpp

+//===--- TypeMismatchCheck.cpp - clang-tidy--------------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "TypeMismatchCheck.h"
+#include "clang/Lex/Lexer.h"
+#include "clang/StaticAnalyzer/Checkers/MPIFunctionClassifier.h"
+#include "clang/Tooling/FixIt.h"
+#include <map>
+#include <unordered_set>
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace tidy {
+namespace mpi {
+
+/// Check if a BuiltinType::Kind matches the MPI datatype.
+///
+/// \param MultiMap datatype group
+/// \param Kind buffer type kind
+/// \param MPIDatatype name of the MPI datatype
+///
+/// \returns true if the pair matches
+static bool
+isMPITypeMatching(const std::multimap<BuiltinType::Kind, std::string> &MultiMap,
+                  const BuiltinType::Kind Kind,
+                  const std::string &MPIDatatype) {
+  auto ItPair = MultiMap.equal_range(Kind);
+  while (ItPair.first != ItPair.second) {
+    if (ItPair.first->second == MPIDatatype)
+      return true;
+    ++ItPair.first;
+  }
+  return false;
+}
+
+/// Check if the MPI datatype is a standard type.
+///
+/// \param MPIDatatype name of the MPI datatype
+///
+/// \returns true if the type is a standard type
+static bool isStandardMPIDatatype(const std::string &MPIDatatype) {
+  static std::unordered_set<std::string> AllTypes = {
+      "MPI_C_BOOL",
+      "MPI_CHAR",
+      "MPI_SIGNED_CHAR",
+      "MPI_UNSIGNED_CHAR",
+      "MPI_WCHAR",
+      "MPI_INT",
+      "MPI_LONG",
+      "MPI_SHORT",
+      "MPI_LONG_LONG",
+      "MPI_LONG_LONG_INT",
+      "MPI_UNSIGNED",
+      "MPI_UNSIGNED_SHORT",
+      "MPI_UNSIGNED_LONG",
+      "MPI_UNSIGNED_LONG_LONG",
+      "MPI_FLOAT",
+      "MPI_DOUBLE",
+      "MPI_LONG_DOUBLE",
+      "MPI_C_COMPLEX",
+      "MPI_C_FLOAT_COMPLEX",
+      "MPI_C_DOUBLE_COMPLEX",
+      "MPI_C_LONG_DOUBLE_COMPLEX",
+      "MPI_INT8_T",
+      "MPI_INT16_T",
+      "MPI_INT32_T",
+      "MPI_INT64_T",
+      "MPI_UINT8_T",
+      "MPI_UINT16_T",
+      "MPI_UINT32_T",
+      "MPI_UINT64_T",
+      "MPI_CXX_BOOL",
+      "MPI_CXX_FLOAT_COMPLEX",
+      "MPI_CXX_DOUBLE_COMPLEX",
+      "MPI_CXX_LONG_DOUBLE_COMPLEX"};
+
+  return AllTypes.find(MPIDatatype) != AllTypes.end();
+}
+
+/// Check if a BuiltinType matches the MPI datatype.
+///
+/// \param Builtin the builtin type
+/// \param BufferTypeName buffer type name, gets assigned
+/// \param MPIDatatype name of the MPI datatype
+/// \param LO language options
+///
+/// \returns true if the type matches
+static bool isBuiltinTypeMatching(const BuiltinType *Builtin,
+                                  std::string &BufferTypeName,
+                                  const std::string &MPIDatatype,
+                                  const LangOptions &LO) {
+  static std::multimap<BuiltinType::Kind, std::string> BuiltinMatches = {
+      // On some systems like PPC or ARM, 'char' is unsigned by default which is
+      // why distinct signedness for the buffer and MPI type is tolerated.
+      {BuiltinType::SChar, "MPI_CHAR"},
+      {BuiltinType::SChar, "MPI_SIGNED_CHAR"},
+      {BuiltinType::SChar, "MPI_UNSIGNED_CHAR"},
+      {BuiltinType::Char_S, "MPI_CHAR"},
+      {BuiltinType::Char_S, "MPI_SIGNED_CHAR"},
+      {BuiltinType::Char_S, "MPI_UNSIGNED_CHAR"},
+      {BuiltinType::UChar, "MPI_CHAR"},
+      {BuiltinType::UChar, "MPI_SIGNED_CHAR"},
+      {BuiltinType::UChar, "MPI_UNSIGNED_CHAR"},
+      {BuiltinType::Char_U, "MPI_CHAR"},
+      {BuiltinType::Char_U, "MPI_SIGNED_CHAR"},
+      {BuiltinType::Char_U, "MPI_UNSIGNED_CHAR"},
+      {BuiltinType::WChar_S, "MPI_WCHAR"},
+      {BuiltinType::WChar_U, "MPI_WCHAR"},
+      {BuiltinType::Bool, "MPI_C_BOOL"},
+      {BuiltinType::Bool, "MPI_CXX_BOOL"},
+      {BuiltinType::Short, "MPI_SHORT"},
+      {BuiltinType::Int, "MPI_INT"},
+      {BuiltinType::Long, "MPI_LONG"},
+      {BuiltinType::LongLong, "MPI_LONG_LONG"},
+      {BuiltinType::LongLong, "MPI_LONG_LONG_INT"},
+      {BuiltinType::UShort, "MPI_UNSIGNED_SHORT"},
+      {BuiltinType::UInt, "MPI_UNSIGNED"},
+      {BuiltinType::ULong, "MPI_UNSIGNED_LONG"},
+      {BuiltinType::ULongLong, "MPI_UNSIGNED_LONG_LONG"},
+      {BuiltinType::Float, "MPI_FLOAT"},
+      {BuiltinType::Double, "MPI_DOUBLE"},
+      {BuiltinType::LongDouble, "MPI_LONG_DOUBLE"}};
+
+  if (!isMPITypeMatching(BuiltinMatches, Builtin->getKind(), MPIDatatype)) {
+    BufferTypeName = Builtin->getName(LO);
+    return false;
+  }
+
+  return true;
+}
+
+/// Check if a complex float/double/long double buffer type matches
+/// the MPI datatype.
+///
+/// \param Complex buffer type
+/// \param BufferTypeName buffer type name, gets assigned
+/// \param MPIDatatype name of the MPI datatype
+/// \param LO language options
+///
+/// \returns true if the type matches or the buffer type is unknown
+static bool isCComplexTypeMatching(const ComplexType *const Complex,
+                                   std::string &BufferTypeName,
+                                   const std::string &MPIDatatype,
+                                   const LangOptions &LO) {
+  static std::multimap<BuiltinType::Kind, std::string> ComplexCMatches = {
+      {BuiltinType::Float, "MPI_C_COMPLEX"},
+      {BuiltinType::Float, "MPI_C_FLOAT_COMPLEX"},
+      {BuiltinType::Double, "MPI_C_DOUBLE_COMPLEX"},
+      {BuiltinType::LongDouble, "MPI_C_LONG_DOUBLE_COMPLEX"}};
+
+  const auto *Builtin =
+      Complex->getElementType().getTypePtr()->getAs<BuiltinType>();
+
+  if (Builtin &&
+      !isMPITypeMatching(ComplexCMatches, Builtin->getKind(), MPIDatatype)) {
+    BufferTypeName = (llvm::Twine(Builtin->getName(LO)) + " _Complex").str();
+    return false;
+  }
+  return true;
+}
+
+/// Check if a complex<float/double/long double> templated buffer type matches
+/// the MPI datatype.
+///
+/// \param Complex buffer type
+/// \param BufferTypeName buffer type name, gets assigned
+/// \param MPIDatatype name of the MPI datatype
+/// \param LO language options
+///
+/// \returns true if the type matches or the buffer type is unknown
+static bool
+isCXXComplexTypeMatching(const TemplateSpecializationType *const Template,
+                         std::string &BufferTypeName,
+                         const std::string &MPIDatatype,
+                         const LangOptions &LO) {
+  static std::multimap<BuiltinType::Kind, std::string> ComplexCXXMatches = {
+      {BuiltinType::Float, "MPI_CXX_FLOAT_COMPLEX"},
+      {BuiltinType::Double, "MPI_CXX_DOUBLE_COMPLEX"},
+      {BuiltinType::LongDouble, "MPI_CXX_LONG_DOUBLE_COMPLEX"}};
+
+  if (Template->getAsCXXRecordDecl()->getName() != "complex")
+    return true;
+
+  const auto *Builtin =
+      Template->getArg(0).getAsType().getTypePtr()->getAs<BuiltinType>();
+
+  if (Builtin &&
+      !isMPITypeMatching(ComplexCXXMatches, Builtin->getKind(), MPIDatatype)) {
+    BufferTypeName =
+        (llvm::Twine("complex<") + Builtin->getName(LO) + ">").str();
+    return false;
+  }
+
+  return true;
+}
+
+/// Check if a fixed size width buffer type matches the MPI datatype.
+///
+/// \param Complex buffer type
+/// \param BufferTypeName buffer type name, gets assigned
+/// \param MPIDatatype name of the MPI datatype
+///
+/// \returns true if the type matches or the buffer type is unknown
+static bool isTypedefTypeMatching(const TypedefType *const Typedef,
+                                  std::string &BufferTypeName,
+                                  const std::string &MPIDatatype) {
+  static llvm::StringMap<std::string> FixedWidthMatches = {
+      {"int8_t", "MPI_INT8_T"},     {"int16_t", "MPI_INT16_T"},
+      {"int32_t", "MPI_INT32_T"},   {"int64_t", "MPI_INT64_T"},
+      {"uint8_t", "MPI_UINT8_T"},   {"uint16_t", "MPI_UINT16_T"},
+      {"uint32_t", "MPI_UINT32_T"}, {"uint64_t", "MPI_UINT64_T"}};
+
+  const auto it = FixedWidthMatches.find(Typedef->getDecl()->getName());
+  // Check if the typedef is known and not matching the MPI datatype.
+  if (it != FixedWidthMatches.end() && it->getValue() != MPIDatatype) {
+    BufferTypeName = Typedef->getDecl()->getName();
+    return false;
+  }
+  return true;
+}
+
+/// Get the unqualified, dereferenced type of an argument.
+///
+/// \param CE call expression
+/// \param idx argument index
+///
+/// \returns type of the argument
+static const Type *argumentType(const CallExpr *const CE, const size_t idx) {
+  const QualType QT = CE->getArg(idx)->IgnoreImpCasts()->getType();
+  return QT.getTypePtr()->getPointeeOrArrayElementType();
+}
+
+void TypeMismatchCheck::registerMatchers(MatchFinder *Finder) {
+  Finder->addMatcher(callExpr().bind("CE"), this);
+}
+
+void TypeMismatchCheck::check(const MatchFinder::MatchResult &Result) {
+  static ento::mpi::MPIFunctionClassifier FuncClassifier(*Result.Context);
+  const CallExpr *const CE = Result.Nodes.getNodeAs<CallExpr>("CE");
+  if (!CE->getDirectCallee())
+    return;
+
+  const IdentifierInfo *Identifier = CE->getDirectCallee()->getIdentifier();
+  if (!Identifier || !FuncClassifier.isMPIType(Identifier))
+    return;
+
+  // These containers are used, to capture buffer, MPI datatype pairs.
+  SmallVector<const Type *, 1> BufferTypes;
+  SmallVector<const Expr *, 1> BufferExprs;
+  SmallVector<StringRef, 1> MPIDatatypes;
+
+  // Adds a buffer, MPI datatype pair of an MPI call expression to the
+  // containers. For buffers, the type and expression is captured.
+  auto addPair = [&CE, &Result, &BufferTypes, &BufferExprs, &MPIDatatypes](
+      const size_t BufferIdx, const size_t DatatypeIdx) {
+    // Skip null pointer constants and in place 'operators'.
+    if (CE->getArg(BufferIdx)->isNullPointerConstant(
+            *Result.Context, Expr::NPC_ValueDependentIsNull) ||
+        tooling::fixit::getText(*CE->getArg(BufferIdx), *Result.Context) ==
+            "MPI_IN_PLACE")
+      return;
+
+    StringRef MPIDatatype =
+        tooling::fixit::getText(*CE->getArg(DatatypeIdx), *Result.Context);
+
+    const Type *ArgType = argumentType(CE, BufferIdx);
+    // Skip unknown MPI datatypes and void pointers.
+    if (!isStandardMPIDatatype(MPIDatatype) || ArgType->isVoidType())
+      return;
+
+    BufferTypes.push_back(ArgType);
+    BufferExprs.push_back(CE->getArg(BufferIdx));
+    MPIDatatypes.push_back(MPIDatatype);
+  };
+
+  // Collect all buffer, MPI datatype pairs for the inspected call expression.
+  if (FuncClassifier.isPointToPointType(Identifier)) {
+    addPair(0, 2);
+  } else if (FuncClassifier.isCollectiveType(Identifier)) {
+    if (FuncClassifier.isReduceType(Identifier)) {
+      addPair(0, 3);
+      addPair(1, 3);
+    } else if (FuncClassifier.isScatterType(Identifier) ||
+               FuncClassifier.isGatherType(Identifier) ||
+               FuncClassifier.isAlltoallType(Identifier)) {
+      addPair(0, 2);
+      addPair(3, 5);
+    } else if (FuncClassifier.isBcastType(Identifier)) {
+      addPair(0, 2);
+    }
+  }
+  checkArguments(BufferTypes, BufferExprs, MPIDatatypes,
+                 Result.Context->getLangOpts());
+}
+
+void TypeMismatchCheck::checkArguments(ArrayRef<const Type *> BufferTypes,
+                                       ArrayRef<const Expr *> BufferExprs,
+                                       ArrayRef<StringRef> MPIDatatypes,
+                                       const LangOptions &LO) {
+  std::string BufferTypeName;
+
+  for (size_t i = 0; i < MPIDatatypes.size(); ++i) {
+    const Type *const BT = BufferTypes[i];
+    bool Error = false;
+
+    if (const auto *Typedef = BT->getAs<TypedefType>()) {
+      Error = !isTypedefTypeMatching(Typedef, BufferTypeName, MPIDatatypes[i]);
+    } else if (const auto *Complex = BT->getAs<ComplexType>()) {
+      Error =
+          !isCComplexTypeMatching(Complex, BufferTypeName, MPIDatatypes[i], LO);
+    } else if (const auto *Template = BT->getAs<TemplateSpecializationType>()) {
+      Error = !isCXXComplexTypeMatching(Template, BufferTypeName,
+                                        MPIDatatypes[i], LO);
+    } else if (const auto *Builtin = BT->getAs<BuiltinType>()) {
+      Error =
+          !isBuiltinTypeMatching(Builtin, BufferTypeName, MPIDatatypes[i], LO);
+    }
+
+    if (Error) {
+      const auto Loc = BufferExprs[i]->getSourceRange().getBegin();
+      diag(Loc, "buffer type '%0' does not match the MPI datatype '%1'")
+          << BufferTypeName << MPIDatatypes[i];
+    }
+  }
+}
+
+} // namespace mpi
+} // namespace tidy
+} // namespace clang

clang-tools-extra/trunk/clang-tidy/plugin/CMakeLists.txt

add_clang_library(clangTidyPlugin
   clangTidy
   clangTidyBoostModule
   clangTidyCERTModule
   clangTidyCppCoreGuidelinesModule
   clangTidyGoogleModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTidyModernizeModule
+  clangTidyMPIModule
   clangTidyPerformanceModule
   clangTidyReadabilityModule
   clangTooling
   )

clang-tools-extra/trunk/clang-tidy/tool/CMakeLists.txt

target_link_libraries(clang-tidy
   clangTidy
   clangTidyBoostModule
   clangTidyCERTModule
   clangTidyCppCoreGuidelinesModule
   clangTidyGoogleModule
   clangTidyLLVMModule
   clangTidyMiscModule
   clangTidyModernizeModule
+  clangTidyMPIModule
   clangTidyPerformanceModule
   clangTidyReadabilityModule
   clangTooling
   )
 
 install(TARGETS clang-tidy
   RUNTIME DESTINATION bin)
 
 install(PROGRAMS clang-tidy-diff.py DESTINATION share/clang)
 install(PROGRAMS run-clang-tidy.py DESTINATION share/clang)

clang-tools-extra/trunk/clang-tidy/tool/ClangTidyMain.cpp

 static int LLVM_ATTRIBUTE_UNUSED MiscModuleAnchorDestination =
     MiscModuleAnchorSource;
 
 // This anchor is used to force the linker to link the ModernizeModule.
 extern volatile int ModernizeModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED ModernizeModuleAnchorDestination =
     ModernizeModuleAnchorSource;
 
+// This anchor is used to force the linker to link the MPIModule.
+extern volatile int MPIModuleAnchorSource;
+static int LLVM_ATTRIBUTE_UNUSED MPIModuleAnchorDestination =
+          MPIModuleAnchorSource;
+
 // This anchor is used to force the linker to link the PerformanceModule.
 extern volatile int PerformanceModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED PerformanceModuleAnchorDestination =
     PerformanceModuleAnchorSource;
 
 // This anchor is used to force the linker to link the ReadabilityModule.
 extern volatile int ReadabilityModuleAnchorSource;
 static int LLVM_ATTRIBUTE_UNUSED ReadabilityModuleAnchorDestination =
     ReadabilityModuleAnchorSource;
 
 } // namespace tidy
 } // namespace clang
 
 int main(int argc, const char **argv) {
   return clang::tidy::clangTidyMain(argc, argv);
 }

clang-tools-extra/trunk/docs/clang-tidy/checks/list.rst

.. toctree::
    modernize-shrink-to-fit
    modernize-use-auto
    modernize-use-bool-literals
    modernize-use-default
    modernize-use-emplace
    modernize-use-nullptr
    modernize-use-override
    modernize-use-using
+   mpi-type-mismatch
    performance-faster-string-find
    performance-for-range-copy
    performance-implicit-cast-in-loop
    performance-unnecessary-copy-initialization
    performance-unnecessary-value-param
    readability-avoid-const-params-in-decls
    readability-braces-around-statements
    readability-container-size-empty

clang-tools-extra/trunk/docs/clang-tidy/checks/mpi-type-mismatch.rst

+.. title:: clang-tidy - mpi-type-mismatch
+
+mpi-type-mismatch
+=================
+
+This check verifies if buffer type and MPI (Message Passing Interface) datatype
+pairs match for used MPI functions. All MPI datatypes defined by the MPI
+standard (3.1) are verified by this check. User defined typedefs, custom MPI
+datatypes and null pointer constants are skipped, in the course of verification.
+
+Example:
+.. code:: c++
+
+  // In this case, the buffer type matches MPI datatype.
+  char buf;
+  MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+
+  // In the following case, the buffer type does not match MPI datatype.
+  int buf;
+  MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);

clang-tools-extra/trunk/test/clang-tidy/Inputs/mpi-type-mismatch/mpimock.h

+// This Message Passing Interface mock header is used, to mock typedefs,
+// constants and functions, required for integration tests being part of
+// clang-tidy MPI checks.
+
+#ifndef MPIMOCK_H
+#define MPIMOCK_H
+
+#define NULL 0
+
+// These typedefs are used to mock MPI types, fixed width integer types and the
+// templated C++ complex number type.
+typedef int MPI_Datatype;
+typedef int MPI_Comm;
+typedef int MPI_Request;
+typedef int MPI_Status;
+typedef int MPI_Op;
+typedef int int8_t;
+typedef int uint8_t;
+typedef int uint16_t;
+typedef int int64_t;
+namespace std { template<class T> struct complex { T real; T imag; }; }
+
+// These defines are used to mock MPI constants.
+#define MPI_DATATYPE_NULL 0
+#define MPI_CHAR 0
+#define MPI_BYTE 0
+#define MPI_INT 0
+#define MPI_LONG 0
+#define MPI_LONG_DOUBLE 0
+#define MPI_UNSIGNED 0
+#define MPI_INT8_T 0
+#define MPI_UINT8_T 0
+#define MPI_UINT16_T 0
+#define MPI_C_LONG_DOUBLE_COMPLEX 0
+#define MPI_FLOAT 0
+#define MPI_DOUBLE 0
+#define MPI_CXX_BOOL 0
+#define MPI_CXX_FLOAT_COMPLEX 0
+#define MPI_CXX_DOUBLE_COMPLEX 0
+#define MPI_CXX_LONG_DOUBLE_COMPLEX 0
+#define MPI_IN_PLACE 0
+#define MPI_COMM_WORLD 0
+#define MPI_STATUS_IGNORE 0
+#define MPI_STATUSES_IGNORE 0
+#define MPI_SUM 0
+
+// These declarations are used to mock MPI functions.
+int MPI_Comm_size(MPI_Comm, int *);
+int MPI_Comm_rank(MPI_Comm, int *);
+int MPI_Send(const void *, int, MPI_Datatype, int, int, MPI_Comm);
+int MPI_Recv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Status *);
+int MPI_Isend(const void *, int, MPI_Datatype, int, int, MPI_Comm,
+    MPI_Request *);
+int MPI_Irecv(void *, int, MPI_Datatype, int, int, MPI_Comm, MPI_Request *);
+int MPI_Wait(MPI_Request *, MPI_Status *);
+int MPI_Waitall(int, MPI_Request[], MPI_Status[]);
+int MPI_Reduce(const void *, void *, int, MPI_Datatype, MPI_Op, int, MPI_Comm);
+int MPI_Ireduce(const void *, void *, int, MPI_Datatype, MPI_Op, int, MPI_Comm,
+    MPI_Request *);
+int MPI_Bcast(void *, int count, MPI_Datatype, int, MPI_Comm);
+
+#endif  // end of include guard: MPIMOCK_H

clang-tools-extra/trunk/test/clang-tidy/mpi-type-mismatch.cpp

+// RUN: %check_clang_tidy %s mpi-type-mismatch %t -- -- -I %S/Inputs/mpi-type-mismatch
+
+#include "mpimock.h"
+
+void charNegativeTest() {
+  int buf;
+  MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int' does not match the MPI datatype 'MPI_CHAR'
+
+  short buf2;
+  MPI_Send(&buf2, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_CHAR'
+
+  long buf3;
+  MPI_Send(&buf3, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long' does not match the MPI datatype 'MPI_CHAR'
+
+  int8_t buf4;
+  MPI_Send(&buf4, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int8_t' does not match the MPI datatype 'MPI_CHAR'
+
+  uint16_t buf5;
+  MPI_Send(&buf5, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_CHAR'
+
+  long double _Complex buf6;
+  MPI_Send(&buf6, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_CHAR'
+
+  std::complex<float> buf7;
+  MPI_Send(&buf7, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_CHAR'
+}
+
+void intNegativeTest() {
+  unsigned char buf;
+  MPI_Send(&buf, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned char' does not match the MPI datatype 'MPI_INT'
+
+  unsigned buf2;
+  MPI_Send(&buf2, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_INT'
+
+  short buf3;
+  MPI_Send(&buf3, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_INT'
+
+  long buf4;
+  MPI_Send(&buf4, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long' does not match the MPI datatype 'MPI_INT'
+
+  int8_t buf5;
+  MPI_Send(&buf5, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int8_t' does not match the MPI datatype 'MPI_INT'
+
+  uint16_t buf6;
+  MPI_Send(&buf6, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_INT'
+
+  long double _Complex buf7;
+  MPI_Send(&buf7, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_INT'
+
+  std::complex<float> buf8;
+  MPI_Send(&buf8, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_INT'
+}
+
+void longNegativeTest() {
+  char buf;
+  MPI_Send(&buf, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_LONG'
+
+  unsigned buf2;
+  MPI_Send(&buf2, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_LONG'
+
+  unsigned short buf3;
+  MPI_Send(&buf3, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned short' does not match the MPI datatype 'MPI_LONG'
+
+  unsigned long buf4;
+  MPI_Send(&buf4, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_LONG'
+
+  int8_t buf5;
+  MPI_Send(&buf5, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'int8_t' does not match the MPI datatype 'MPI_LONG'
+
+  uint16_t buf6;
+  MPI_Send(&buf6, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_LONG'
+
+  long double _Complex buf7;
+  MPI_Send(&buf7, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_LONG'
+
+  std::complex<float> buf8;
+  MPI_Send(&buf8, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_LONG'
+}
+
+void int8_tNegativeTest() {
+  char buf;
+  MPI_Send(&buf, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_INT8_T'
+
+  unsigned buf2;
+  MPI_Send(&buf2, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_INT8_T'
+
+  short buf3;
+  MPI_Send(&buf3, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_INT8_T'
+
+  unsigned long buf4;
+  MPI_Send(&buf4, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_INT8_T'
+
+  uint8_t buf5;
+  MPI_Send(&buf5, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint8_t' does not match the MPI datatype 'MPI_INT8_T'
+
+  uint16_t buf6;
+  MPI_Send(&buf6, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_INT8_T'
+
+  long double _Complex buf7;
+  MPI_Send(&buf7, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'long double _Complex' does not match the MPI datatype 'MPI_INT8_T'
+
+  std::complex<float> buf8;
+  MPI_Send(&buf8, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_INT8_T'
+}
+
+void complex_c_long_double_complexNegativeTest() {
+  char buf;
+  MPI_Send(&buf, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  unsigned buf2;
+  MPI_Send(&buf2, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  short buf3;
+  MPI_Send(&buf3, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  unsigned long buf4;
+  MPI_Send(&buf4, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  uint8_t buf5;
+  MPI_Send(&buf5, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint8_t' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  uint16_t buf6;
+  MPI_Send(&buf6, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  double _Complex buf7;
+  MPI_Send(&buf7, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'double _Complex' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+
+  std::complex<float> buf8;
+  MPI_Send(&buf8, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<float>' does not match the MPI datatype 'MPI_C_LONG_DOUBLE_COMPLEX'
+}
+
+void complex_cxx_float_complexNegativeTest() {
+  char buf;
+  MPI_Send(&buf, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'char' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  unsigned buf2;
+  MPI_Send(&buf2, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned int' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  short buf3;
+  MPI_Send(&buf3, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'short' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  unsigned long buf4;
+  MPI_Send(&buf4, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'unsigned long' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  uint8_t buf5;
+  MPI_Send(&buf5, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint8_t' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  uint16_t buf6;
+  MPI_Send(&buf6, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'uint16_t' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  double _Complex buf7;
+  MPI_Send(&buf7, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'double _Complex' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+
+  std::complex<double> buf8;
+  MPI_Send(&buf8, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+  // CHECK-MESSAGES: :[[@LINE-1]]:12: warning: buffer type 'complex<double>' does not match the MPI datatype 'MPI_CXX_FLOAT_COMPLEX'
+}
+
+void skippedTypesTests() {
+  // typedefs, user defined MPI and nullptr types are skipped
+  typedef char CHAR;
+  CHAR buf;
+  MPI_Send(&buf, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+
+  typedef unsigned UNSIGNED;
+  UNSIGNED buf2;
+  MPI_Send(&buf2, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+
+#define _MPI_LONG MPI_LONG
+  int buf3;
+  MPI_Send(&buf3, 1, _MPI_LONG, 0, 0, MPI_COMM_WORLD);
+
+#define _MPI_CXX_FLOAT_COMPLEX MPI_CXX_FLOAT_COMPLEX
+  short buf4;
+  MPI_Send(&buf4, 1, _MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+
+  MPI_Send(NULL, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+}
+
+void positiveTests() {
+  char buf;
+  MPI_Send(&buf, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+
+  int buf2;
+  MPI_Send(&buf2, 1, MPI_INT, 0, 0, MPI_COMM_WORLD);
+
+  long buf3;
+  MPI_Send(&buf3, 1, MPI_LONG, 0, 0, MPI_COMM_WORLD);
+
+  int8_t buf4;
+  MPI_Send(&buf4, 1, MPI_INT8_T, 0, 0, MPI_COMM_WORLD);
+
+  long double _Complex buf5;
+  MPI_Send(&buf5, 1, MPI_C_LONG_DOUBLE_COMPLEX, 0, 0, MPI_COMM_WORLD);
+
+  std::complex<float> buf6;
+  MPI_Send(&buf6, 1, MPI_CXX_FLOAT_COMPLEX, 0, 0, MPI_COMM_WORLD);
+
+  uint8_t buf7;
+  MPI_Send(&buf7, 1, MPI_UINT8_T, 0, 0, MPI_COMM_WORLD);
+
+  uint16_t buf8;
+  MPI_Send(&buf8, 1, MPI_UINT16_T, 0, 0, MPI_COMM_WORLD);
+
+  // On some systems like PPC or ARM, 'char' is unsigned by default which is why
+  // distinct signedness for the buffer and MPI type is tolerated.
+  unsigned char buf9;
+  MPI_Send(&buf9, 1, MPI_CHAR, 0, 0, MPI_COMM_WORLD);
+}