[clang-tidy] Extend 'bugprone-easily-swappable-parameters' with mixability because of implicit conversions

[whisperity]

Summary

Adds a relaxation option ModelImplicitConversions which will make the check report for cases where parameters refer to types that are implicitly convertible to one another.

Example:

struct IntBox { IntBox(int); operator int(); };
void foo(int i, double d, IntBox ib) {}

Implicit conversions are the last to model in the set of things that are reasons for the possibility of a function being called the wrong way which is not always immediately apparent when looking at the function (signature or call).
Implicit conversions are approximated in both directions between the parameter types, and if there is a bidirectional swap possibility, the report is made. (I.e. void bar(Base*, Derived*) {} is not reported, because a bar(DP, BP) would be a compile error.)

When a "weak" interface is diagnosed and implicit conversions are involved, the user is given a detailed breakdown (TX -> T1 -> T2 -> TB, TB -> TA, etc.) on the types the value goes through during the conversion. User-defined conversion methods are highlighted at the location with a note tag.

Unfortunately, there isn't a sensible way (at least I found none) to ask Sema at "frontend time" whether or not the two parameters could be implicitly converted between one another, as we do not have the Sema instance anymore. Hence, most of this modelling we have to do ourselves, especially for implicit conversions. Luckily, just like the original patch, it's a few lines of juggling the AST per case.

Diagnosing implicit conversions necessarily increases the number of results (both the reported length and the number of functions matched). We found in our evaluation that this increase is roughly 10%. There were a few oddballs like Bitcoin or Protobuf that produced a 20% climb. Naturally, C projects are a lot worse in this regard due to the much more proliferate use of builtin types, making a 20% increase the norm, rather than the exception.

When it comes to showing developers where their type safety is lacking, the possibility of implicit conversions is the single violator. One can argue about the impossibility of making a better design for functions that take an int, int and can't do better (this is what the Filtering patches try to capture and discard from the results). but there is hardly an excuse for an int, bool if someone wants a stronger safety.

For this very reason, the suggested default value for the check option is true, i.e. implicit conversions are considered, checked, and diagnosed.

[whisperity]

WIP because there's a lot of debug stuff that should be cleared out from here. This is a crude patch. It works fancy, but the code is crude.

[whisperity]

• Re-organised code, removed debug prints, rebased, the usual tidy-up.
• Bug fixes on certain crashes like incomplete types, conversion operator templates, etc.
• Even more bug fixes against crashes, hopefully... sorry I lost the individual commits in a squash I think

[whisperity]

clang-tools-extra/clang-tidy/experimental/CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck.cpp

919

'chute, I hate merge conflicts...

clang-tools-extra/docs/clang-tidy/checks/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type.rst

113–120

This change to check the "left half" of a full graph moved to the main checker patch D69560 and there is no significant (few seconds, on large projects like LLVM) time difference between the modes at all even on large projects... so this fearmongering text should be removed.

[whisperity]

Ignore one-way implicit conversions

One-way implicit conversions introduce too much noise, and except in very odd circumstances, do not provide a meaningful result.

The stalwart example

void f(const Base& bp, const Derived& dp)

contains just one conversion, dp -> bp, which, if called in a swapped way, will 99.9...% of the cases will result in a compile error (*)

Base b;
Derived d;
f(d, b);

Thus, there is no reason to model this, at all.

(*): Unless an operator Derived() exists in Base.

[whisperity]

This patch will be replaced with the refactoring of the base check.

[whisperity]

• Rebased over updated, rewritten, newer base patch version, vastly increased the quality of the code.
• Tidied the tests and made them more self-explanatory.
• Implemented handling function pointer conversion (implicit losing of noexcept). This was missing from the previous uploaded patch.
• Ensured that implicit conversion sequences are diagnosed properly, even when typedefs are involved. This means that if the conversion takes 4-5-6 logical steps (e.g. instead of SomeFancyIntTypedef -> DoubleBoxingType, emit SomeFancyIntTypedef -> int -> double -> const double -> DoubleBoxingType (user defined ctor)) it's all explained properly.
• Respect the user's decision about the mixability of T and const T (the previous patch D96355) even in the context of implicit conversions (i.e. if the user did not allow that, do not consider a user-defined type which constructor takes a const mixable with a non-const other parameter).
• Put a diagnostic note to the location of the FuntionDecl of the conversion method involved in the mixability.

[whisperity]

After reading through the diff as rendered by Phabricateur, I realised I left in a few crappy debug prints and commented-out values that are not needed in the end. This is fixed now.

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

207 ↗

(On Diff #327761)

Actually this is one of those debug prints that should be removed and remained in here by accident.

657–667 ↗

(On Diff #327761)

@aaron.ballman Getting ahead of the curve here. I understand this is ugly. Unfortunately, no matter how much I read the standard, I don't get anything of "canonical type" mentioned, it seems to me this concept is something inherent to the model of Clang.

Basically why this is here: imagine a void (*)() noexcept and a void (*)(). One's noexcept, the other isn't. Inside the AST, this is a ParenType of a PointerType to a FunctionProtoType. There exists a one-way implicit conversion from the noexcept to the non-noexcept ("noexceptness can be discarded", similarly to how "constness can be gained")
Unfortunately, because this is a one-way implicit conversion, it won't return on the code path earlier for implicit conversions.

Now because of this, the recursive descent in our code will reach the point when the two innermost FunctionProtoTypes are in our hands. As a fallback case, we simply ask Clang "Hey, do you think these two are the same?". And for some weird reason, Clang will say "Yes."... While one of them is a noexcept function and the other one isn't.

I do not know the innards of the AST well enough to even have a glimpse of whether or not this is a bug. So that's the reason why I went ahead and implemented this side-stepping logic. Basically, as the comment says, it'lll force the information of "No matter what you do, do NOT consider these mixable!" back up the recursion chain, and handle it appropriately later.

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-implicits.cpp

250–260 ↗

(On Diff #327761)

Now here the warning is justified, however. All these disinfectant-stinking examples are to ensure that. In this case, in our hands, on the first level, we got the function pointer, and the class. And it is the implicit conversion modeller that will eventually ask "Can I give that noexcept function to that constructor taking a non-noexcept?" and in that case, on the level of function pointers, the answer is yes, so there will be a warning made.

clang-tools-extra/test/clang-tidy/checkers/bugprone-easily-swappable-parameters-len2.cpp

336–337 ↗

(On Diff #327761)

Without this side-stepping logic mentioned above, even without this patch (so back to the "Ye Olde Strict Type Equality" mode), this particular function would be warned about, which is a definite false positive.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

377 ↗

(On Diff #327761)

Should this be MIX_WorkaroundDisableCanonicalEquivalence instead of MIX_None?

486–487 ↗

(On Diff #327761)

500–501 ↗

(On Diff #327761)

520 ↗

(On Diff #327761)

What about a DecayedType?

657–667 ↗

(On Diff #327761)

Unfortunately, no matter how much I read the standard, I don't get anything of "canonical type" mentioned, it seems to me this concept is something inherent to the model of Clang.

It is more of a Clang-centric concept. Basically, a canonical type is one that's had all of the typedefs stripped off it.

Now because of this, the recursive descent in our code will reach the point when the two innermost FunctionProtoTypes are in our hands. As a fallback case, we simply ask Clang "Hey, do you think these two are the same?". And for some weird reason, Clang will say "Yes."... While one of them is a noexcept function and the other one isn't.

I think a confounding factor in this area is that noexcept did not used to be part of the function type until one day it started being a part of the function type. So my guess is that this is fallout from this sort of thing: https://godbolt.org/z/EYfj8z (which may be worth keeping in mind when working on the check).

758 ↗

(On Diff #327761)

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

377 ↗

(On Diff #327761)

In this patch I changed the value of None to be 2, and Workaround... became 1. So everything above None means it's a valid mixability (somehow), of course only after sanitize() so Workaround... | CanonicalType becomes None.

[aaron.ballman]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

203 ↗

(On Diff #327761)

207 ↗

(On Diff #327761)

Agreed, this one should be removed.

[whisperity]

• Fixed a few nits.
• Rebased, and added highlighting (under-squiggly) the parameter/return type of conversion operators for extra emphasis.

[whisperity]

Bump. 🙂 This is the last part that's still unreviewed and also the most complex.

[martong]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

657–667 ↗

(On Diff #327761)

About noexcept: we've faced a similar problem in the ASTImporter library. We could not import a noexcept function's definition if we already had one without the noexcept specifier.

Thus, in ASTStructuralEquivalence.cpp we do differentiate the function types based on their noexcept specifier (and we even check the noexcept expression).:

TEST_F(StructuralEquivalenceFunctionTest, Noexcept) {
  auto t = makeNamedDecls("void foo();",
                          "void foo() noexcept;", Lang_CXX11);
  EXPECT_FALSE(testStructuralMatch(t));
}
TEST_F(StructuralEquivalenceFunctionTest, NoexceptNonMatch) {
  auto t = makeNamedDecls("void foo() noexcept(false);",
                          "void foo() noexcept(true);", Lang_CXX11);
  EXPECT_FALSE(testStructuralMatch(t));
}

May be in these special cases it would worth to reuse the ASTStructuralEquivalenceContext class?

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

657–667 ↗

(On Diff #327761)

Definitely, good catch, @martong, thank you very much! @aaron.ballman, what do you think? If I see this right, StructuralEquivalenceContext is part of libClangAST so should be readily available.

The only issue I'm seeing is that this class takes non-const ASTContext and Decl nodes...

[martong]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

122 ↗

(On Diff #336623)

FB stands for FunnyBitmask? Could you please either describe that in a comment or just spell it out?

182 ↗

(On Diff #336623)

Maybe it's just me, but AfterPre sounds ambiguous and AfterPost seems redundant.

210 ↗

(On Diff #336623)

So, we can never return with a vector with size > 4?

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.h

42 ↗

(On Diff #336623)

"qualified"
Do you consider volatile here as well, or just const?

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

657–667 ↗

(On Diff #327761)

Well, I started looking into putting up const whereever possible into the aforementioned type, but I hit a hurdle. When checking equivalence of records, the algorithm tries to ASTImport-complete the definition of a record if it's not fully defined yet... which is not a const method... I'll look into it some more, maybe we can do an overload on whether you're Structual equivalence checking in a const context or a non-const context.

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

122 ↗

(On Diff #336623)

FlagBit. @alexfh suggested in the base check to use hexa literals. I'm not too sold about that, but maybe we can cut the macro out and keep the bit shift instructions in. Given that the check has more or less earned its final form (for now), we know how many bits we need!

182 ↗

(On Diff #336623)

Should I use "AfterFirstStandard" or "AfterFirstStd"?

AfterPost isn't redundant. An implicit conversion sequence might be of 3 steps. Consider in a hypothetical void f(Complex x, const double d).

Complex ---(PRE: std qual adjustment)--> const Complex ---(UD: user defined conv)--> double ---(POST: std qual adjustment)--> const double

And because in case of many conversions a lot of combinations need to be checked, we can't have AfterPost be the same as End. First, because of the combinations, second, because of the other things the check is doing.

void g(ComplexTypedef CT, ConstDoubleTypedef CDT);

In this case, Start and End are the typedefs, and the inner sequence is the same as before. And in order to generate the diagnostic, we also need to have both pieces of information.

210 ↗

(On Diff #336623)

N in SmallVector<T, N> only specifies the pre-allocated smallness size. AFAIK, if you have >N elements, it will just put the vector out onto the heap.

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.h

42 ↗

(On Diff #336623)

Const, volatile, and in C mode, restrict, too.

[martong]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

122 ↗

(On Diff #336623)

FlagBit, I like it, perhaps we should rename FB to FlagBit?

182 ↗

(On Diff #336623)

Thanks for this explanation, it makes clearer! However, this highlights that a way better description (in the form of comments) is needed for these QualType members. Especially this line could really increase the readability.

Complex ---(PRE: std qual adjustment)--> const Complex ---(UD: user defined conv)--> double ---(POST: std qual adjustment)--> const double

In this case, Start and End are the typedefs, and the inner sequence is the same as before. And in order to generate the diagnostic, we also need to have both pieces of information.

I think it would be useful to document the cases with examples when End is not equal to AfterPost and such.

210 ↗

(On Diff #336623)

I meant the number 4, not SmallVector. So, is there a case when the conversion sequence is longer than 4? If it can be longer, then where do you store the types, you have 4 QualType members if I am not wrong. (Also, I am not an expert of conversions.)

To be honest, it is so terrible that we cannot reuse clang::StandardConversionSequence

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.h

42 ↗

(On Diff #336623)

Great!

[martong]

Perhaps all conversion related logic should go into their own implementation file? Seems like it adds up to roughly 1000 lines.

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

1171 ↗

(On Diff #336623)

I think that these overloaded operators are not elevating the readability, since we are not dealing with mathematical classes.
IMHO, we could simply use update or something that is less crypto.

[martong]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

550–551 ↗

(On Diff #336623)

Is this still WIP or do you use the DEBUG printouts in the tests? If not then could you please create a Diff without the DEBUG printouts, that could increase readability and ease the review.

[whisperity]

In D75041#2799023, @martong wrote:

Perhaps all conversion related logic should go into their own implementation file? Seems like it adds up to roughly 1000 lines.

That's against the usual conventions of the project (1 TU for 1 check implementation). The methods are grouped by namespace, you can fold it up in your editor.

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

550–551 ↗

(On Diff #336623)

As discussed earlier (and perhaps in the previous patches), these debug printouts are needed and shall stay here. The output is not used in automation, but it's intended for people who might pick up on further developing the check later. The recursive descent is too complex to be handleable in your mind without the debug information.

[whisperity]

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

657–667 ↗

(On Diff #327761)

Right. Unfortunately, it seems that fixing StructuralEquivalenceContext would require a set of nontrivial changes which, at least to my current understanding, would also require severely restructuring how the clients of that class use that class. The concrete example is that there needs to be a separate implementation for const and non-const record type equivalence checks, and the latter would not try importing, while the former continues to use the current logic. That is the part where "blindly" putting const everywhere just doesn't work anymore.

I would not dare to fix this for this patch right now, my understanding of the ASTImporter is not sufficient for details like this.

[whisperity]

NFC.

• Rebase and update for changes of base patch D69560.
• Remove the <<= and %= operators in favour of named functions.
• Elaborated the documentation for ConversionSequence.

[whisperity]

(Uploaded the prerequisite, wrong patch here by accident.)

[whisperity]

NC Rebase, buildbots, etc.

[aaron.ballman]

In D75041#2799036, @whisperity wrote:

In D75041#2799023, @martong wrote:

Perhaps all conversion related logic should go into their own implementation file? Seems like it adds up to roughly 1000 lines.

That's against the usual conventions of the project (1 TU for 1 check implementation). The methods are grouped by namespace, you can fold it up in your editor.

FWIW, there's not a hard rule for that -- we put other tidy logic into Utils files, for example. However, I think such a cleanup could be done post-commit as an NFC change as well.

It's taken me a while to convince myself that it's reasonable to reimplement so much of the conversion logic in clang-tidy, but I don't think it's reasonable to try to expose an API from Clang for its conversion logic to be reusable in this context. So despite my mild discomfort with how complex the logic is in this patch, I think it's an acceptable approach. LGTM, aside from some minor style nits.

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

249 ↗

(On Diff #354210)

Return a SmallVectorImpl<QualType> so that the size of the vector doesn't matter to callers?

556 ↗

(On Diff #354210)

One thing that could get interesting here are attributed types, as those may be "useless" or "useful" sugars depending on the attribute. However, I think we can deal with that later when we have more real-world uses in front of us.

962 ↗

(On Diff #354210)

1491 ↗

(On Diff #354210)

1493 ↗

(On Diff #354210)

1503 ↗

(On Diff #354210)

[whisperity]

NFC Fix nits.

Let's have one final run with the buildbots, just in case.

clang-tools-extra/clang-tidy/bugprone/EasilySwappableParametersCheck.cpp

249 ↗

(On Diff #354210)

Meh... that seems to only work if the context is polymorphic, like reference parameters or pointers... This tries to return by value and construct, which is not possible for Impl.

[martong]

Looks acceptable to me as well. Thanks!

clang-tools-extra/clang-tidy/experimental/CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck.h

public:
 
   /// The parameter type name suffixes (as written in the code) to be ignored
   /// when checking for adjacent parameter ranges.
   const std::vector<std::string> IgnoredParamTypes;
 
   /// Whether to consider 'T' and 'const T'/'volatile T'/etc. arguments to be
   /// possible mixup.
   const bool CVRMixPossible;
+
+  /// Whether to consider implicit conversion possibilities as a potential match
+  /// for adjacency.
+  const bool ImplicitConversion;
 };
 
 } // namespace experimental
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_EXPERIMENTAL_CPPCOREGUIDELINESAVOIDADJACENTPARAMETERSOFTHESAMETYPECHECK_H

clang-tools-extra/clang-tidy/experimental/CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck.cpp

 // CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck.cpp  clang-tidy //
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck.h"
 #include "../utils/OptionsUtils.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 
 #include <string>
 #include <utility>
 
 // clang-format off
 // FIXME: Remove debug things.
 #define  DEBUG_TYPE "AdjacentParameters"
 #include "llvm/Support/Debug.h"
 // clang-format on
+template <std::size_t Width>
+static inline std::string format_bytes_do(std::size_t N) {
+  static_assert(std::is_unsigned<decltype(N)>::value,
+                "size_t is not unsigned?!");
+  constexpr std::size_t WidthWithPadding = Width + (Width / 4);
+  char C[WidthWithPadding];
+  for (std::size_t CurPos = 0; CurPos < WidthWithPadding; ++CurPos) {
+    if (CurPos % 5 == 0) {
+      // Group digits by 4.
+      C[CurPos] = ' ';
+      continue;
+    }
+
+    C[CurPos] = N % 2 ? '1' : '0';
+    N >>= 1;
+  }
+
+  return std::string{std::rbegin(C), std::rend(C)};
+}
+
+template <typename T> static inline std::string format_bytes(T &&t) {
+  return format_bytes_do<sizeof(T) * 8>(t);
+}
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace experimental {
 
 namespace {
 
 /// Annotates a possible mix of parameters based on which language construct
 /// is responsible for allowing thee mix to happen. This is a bitflag.
 enum MixupTag : unsigned char {
   MIXUP_Invalid = 0, //< Sentinel 0 bit pattern value for masking. DO NOT USE!
 
 // Set the bit at index N to 1 as the enum constant. N = 0 is invalid.
 #define BIT(Name, N) MIXUP_##Name = (1ull << (N##ull - 1ull))
-  BIT(None, 1),    //< Mixup is not possible.
-  BIT(Trivial, 2), //< No extra information needed.
-  BIT(Typedef, 3), //< Parameter of a typedef which resolves to an effective
+  BIT(None, 1),     //< Mixup is not possible.
+  BIT(Trivial, 2),  //< No extra information needed.
+  BIT(Typedef, 3),  //< Parameter of a typedef which resolves to an effective
                     //< desugared type same as the other arg.
-  BIT(RefBind, 4), //< Parameter mixes with another due to reference binding.
-  BIT(CVR, 5),     //< Parameter mixes with another through implicit
+  BIT(RefBind, 4),  //< Parameter mixes with another due to reference binding.
+  BIT(CVR, 5),      //< Parameter mixes with another through implicit
                     //< qualification.
+  BIT(Implicit, 6), //< An implicit conversion may happen.
 #undef BIT
 
-  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ MIXUP_CVR)
+  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue = */ MIXUP_Implicit)
 };
+#undef FBIT
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
-/// A named tuple that contains which parameter with which other parameter
-/// can be mixed up in what fashion.
-struct Mixup {
-  const ParmVarDecl *First, *Second;
-  MixupTag Flags;
+/// Implicit conversion sequence steps resulting in types referred here.
+struct ConversionSequence {
+  /// Type of the intermediate value after the first standard conversion.
+  const Type *StdPre;
+  /// Type of the intermediate value after executing the user-defined conversion
+  /// which, in case of constructors, the user type, in case of conversion
+  /// operators, the result of the operator.
+  const Type *UserType;
+  /// Type of the intermediate value after the second standard conversion.
+  const Type *StdPost;
+
+  ConversionSequence() : StdPre(nullptr), UserType(nullptr), StdPost(nullptr) {}
+
+  explicit operator bool() const { return StdPre || UserType || StdPost; }
+
+  /// Whether the conversion sequence is single-step only.
+  bool single() const {
+    return ((bool)StdPre ^ (bool)UserType ^ (bool)StdPost) &&
+           !(StdPre && UserType && StdPost);
+  }
+};
 
-  Mixup(const ParmVarDecl *A, const ParmVarDecl *B, MixupTag Flags)
-      : First(A), Second(B), Flags(Flags) {}
+struct MixupData {
+  MixupTag Flag;
+  ConversionSequence ConvLTR, ConvRTL;
+
+  MixupData(MixupTag Flags) : Flag(Flags) {}
+  MixupData(MixupTag Flags, const ConversionSequence &Seq)
+      : Flag(Flags), ConvLTR(Seq), ConvRTL(Seq) {}
+  MixupData(MixupTag Flags, const ConversionSequence &LTR,
+            const ConversionSequence &RTL)
+      : Flag(Flags), ConvLTR(LTR), ConvRTL(RTL) {}
 
-  Mixup operator|(MixupTag EnableFlags) const {
-    return {First, Second, Flags | EnableFlags};
+  MixupData operator|(MixupTag EnableFlag) const {
+    return {Flag | EnableFlag, ConvLTR, ConvRTL};
   }
-  Mixup &operator|=(MixupTag EnableFlags) {
-    Flags |= EnableFlags;
+  MixupData &operator|=(MixupTag EnableFlag) {
+    Flag |= EnableFlag;
     return *this;
   }
 
   /// Sanitises the Mixup's flags so it doesn't contain contradictory bits.
   void sanitise() {
-    assert(Flags != MIXUP_Invalid &&
+    assert(Flag != MIXUP_Invalid &&
            "Mixup tag had full zero bit pattern value!");
 
-    if (Flags & MIXUP_None) {
+    if (Flag & MIXUP_None) {
       // If at any point the checks mark the mixup impossible, it is just simply
       // impossible.
-      Flags = MIXUP_None;
+      Flag = MIXUP_None;
       return;
     }
 
-    if (Flags == MIXUP_Trivial)
+    if (Flag == MIXUP_Trivial)
       return;
 
-    if (Flags ^ MIXUP_Trivial)
+    if (Flag ^ MIXUP_Trivial)
       // If any other bits than Trivial is set, unset Trivial, so only the
       // annotation bits warranting extra diagnostic are set.
-      Flags &= ~MIXUP_Trivial;
+      Flag &= ~MIXUP_Trivial;
+
+    // Set LTR and RTL implicity according to the members being set.
+    if (ConvLTR && ConvRTL)
+      Flag |= MIXUP_Implicit;
+    else
+      Flag &= ~MIXUP_Implicit;
   }
 };
 
+/// Named tuple that contains that the types of the arguments From and To
+/// are mixable with the given flags in a particular fashion.
+struct Mixup {
+  const ParmVarDecl *First, *Second;
+  MixupData Data;
+
+  Mixup(const ParmVarDecl *A, const ParmVarDecl *B, MixupData Data)
+      : First(A), Second(B), Data(Data) {}
+};
 static_assert(std::is_trivially_copyable<Mixup>::value,
-              "keep Mixup trivially copyable!");
+              "keep Mixup and components trivially copyable!");
 
 /// Represents a (closed) range of adjacent parameters that can be mixed up at
 /// a call site.
 struct MixableAdjacentParamRange {
   std::size_t NumParamsChecked = 0;
   llvm::SmallVector<Mixup, 8> Mixups;
 
   const ParmVarDecl *getFirstParm() const {
const ParmVarDecl *getLastParm() const {
     // the adjacency range.
     assert(!Mixups.empty());
     return Mixups.back().Second;
   }
 };
 
 } // namespace
 
-/// Returns whether an lvalue reference refers to the same type as T.
-static MixupTag RefBindsToSameType(const LValueReferenceType *LRef,
-                                   const Type *T, bool CVRMixPossible);
-
-/// Returns whether LType and RType refer to the same type in a sense that at a
-/// call site it is possible to mix the types up if the actual arguments are
-/// specified in opposite order.
-/// \returns MixupTag indicating how a mixup between the arguments happens.
-/// The final output of this potentially recursive function must be sanitised.
-static MixupTag HowPossibleToMixUpAtCallSite(const QualType LType,
+/// Returns how an lvalue reference refers to the same type as T.
+static MixupData RefBindsToSameType(const LValueReferenceType *LRef,
+                                    const Type *T, const ASTContext &Ctx,
+                                    bool IsRefRightType, bool CVRMixPossible,
+                                    bool ImplicitConversion);
+
+/// Returns whether the left side type is convertible to the right side type,
+/// by attempting to approximate implicit conversion sequences.
+/// \param AllowUserDefined If false, only standard conversions will be
+/// approximated.
+/// \note The result of this operation is not symmetric!
+static MixupData HowConvertible(const Type *LT, const Type *RT,
+                                const LangOptions &LOpts,
+                                bool AllowUserDefined = true);
+
+/// Returns how LType and RType may essentially refer to the same type - in a
+/// sense that at a call site it is possible to mix the arguments up if
+/// specified in the opposite order.
+/// \returns MixupData indicating how a mixup between the arguments happens.
+/// \note The final output of this potentially recursive function must be
+/// sanitised by 'sanitiseMixup' before it could be used, to ensure only the
+/// proper bits are set!
+static MixupData HowPossibleToMixUpAtCallSite(const QualType LType,
                                               const QualType RType,
                                               const ASTContext &Ctx,
-                                             const bool CVRMixPossible) {
+                                              const bool CVRMixPossible,
+                                              const bool ImplicitConversion) {
   LLVM_DEBUG(llvm::dbgs() << "HowPossibleToMixUpAtCallSite?\n Left:";
              LType.dump(llvm::dbgs()); llvm::dbgs() << "\n\t and \n Right: ";
              RType.dump(llvm::dbgs()); llvm::dbgs() << '\n';);
 
   if (LType == RType) {
     LLVM_DEBUG(llvm::dbgs() << "!!! Both Left and Right are same type.\n";);
     return MIXUP_Trivial;
   }
 
   // Remove certain sugars that don't affect mixability from the types.
-  if (dyn_cast<const ParenType>(LType.getTypePtr()))
+  if (dyn_cast<const ParenType>(LType.getTypePtr())) {
+    LLVM_DEBUG(llvm::dbgs() << "Left is some sugared Parens()\n");
     return HowPossibleToMixUpAtCallSite(LType.getSingleStepDesugaredType(Ctx),
-                                        RType, Ctx, CVRMixPossible);
-  if (dyn_cast<const ParenType>(RType.getTypePtr()))
+                                        RType, Ctx, CVRMixPossible,
+                                        ImplicitConversion);
+  }
+  if (dyn_cast<const ParenType>(RType.getTypePtr())) {
+    LLVM_DEBUG(llvm::dbgs() << "Right is some sugared Parens()\n");
     return HowPossibleToMixUpAtCallSite(
-        LType, RType.getSingleStepDesugaredType(Ctx), Ctx, CVRMixPossible);
+        LType, RType.getSingleStepDesugaredType(Ctx), Ctx, CVRMixPossible,
+        ImplicitConversion);
+  }
 
   // An argument of type 'T' and 'const T &' may bind with the same power.
   // (Note this is a different case, as 'const T &' is a '&' on the top level,
   // and only then a const.)
   if (LType->isLValueReferenceType() || RType->isLValueReferenceType()) {
     // (If both is the same reference type, earlier a return happened.)
 
     if (LType->isLValueReferenceType()) {
       LLVM_DEBUG(llvm::dbgs() << "!!! Left is an lvalue reference type\n";);
-      MixupTag RefBind = RefBindsToSameType(LType->getAs<LValueReferenceType>(),
-                                            RType.getTypePtr(), CVRMixPossible);
-      // RefBind may or may not have given us a tag (e.g. reference was to a
-      // typedef) via a recursive chain back to this function. Apply the
-      // "bind power" tag here to indicate a reference binding happened.
-      // (If RefBind was MIXUP_None, a later sanitise step will undo every bit
-      // except for None.)
-      return RefBind | MIXUP_RefBind;
+      // Return value of function call may or may not have given us a tag (e.g.
+      // reference was to a typedef) via a recursive chain back to this
+      // function. Apply the "bind power" tag here to indicate a reference
+      // binding happened. (If RefBind was MIXUP_None, a later sanitise step
+      // will undo every bit except for None.)
+      return RefBindsToSameType(LType->getAs<LValueReferenceType>(),
+                                RType.getTypePtr(), Ctx,
+                                /* IsRefRightType =*/false, CVRMixPossible,
+                                ImplicitConversion) |
+             MIXUP_RefBind;
     }
     if (RType->isLValueReferenceType()) {
       LLVM_DEBUG(llvm::dbgs() << "!!! Right is an lvalue reference type.\n";);
-      MixupTag RefBind = RefBindsToSameType(RType->getAs<LValueReferenceType>(),
-                                            LType.getTypePtr(), CVRMixPossible);
-      return RefBind | MIXUP_RefBind;
+      return RefBindsToSameType(RType->getAs<LValueReferenceType>(),
+                                LType.getTypePtr(), Ctx,
+                                /* IsRefRightType =*/true, CVRMixPossible,
+                                ImplicitConversion) |
+             MIXUP_RefBind;
     }
   }
 
-  // A parameter of type 'T' and 'const T' may bind with the same power.
+  // An argument of type 'T' and 'const T' may bind with the same power.
   // Case for both types being const qualified (for the same type) is handled
   // by LType == RType.
   if (LType.getLocalCVRQualifiers() || RType.getLocalCVRQualifiers()) {
-    LLVM_DEBUG(llvm::dbgs()
-               << "!!! Left or right is locally CVR: Left: "
-               << LType.getLocalQualifiers().getCVRQualifiers() << ", Right: "
-               << RType.getLocalQualifiers().getCVRQualifiers() << '\n');
+    LLVM_DEBUG(
+        llvm::dbgs()
+        << format_bytes(
+               (unsigned char)LType.getLocalQualifiers().getCVRQualifiers())
+        << ", Right: "
+        << format_bytes(
+               (unsigned char)RType.getLocalQualifiers().getCVRQualifiers())
+        << '\n');
     if (!CVRMixPossible)
       return MIXUP_None;
 
     return HowPossibleToMixUpAtCallSite(LType.getUnqualifiedType(),
                                         RType.getUnqualifiedType(), Ctx,
-                                        CVRMixPossible) |
+                                        CVRMixPossible, ImplicitConversion) |
            MIXUP_CVR;
   }
 
   {
     const auto *LTypedef = LType->getAs<TypedefType>();
     const auto *RTypedef = RType->getAs<TypedefType>();
     if (LTypedef && RTypedef) {
       LLVM_DEBUG(llvm::dbgs()
                      << "!!! Both Left and Right are typedef types.\n";);
-      return MIXUP_Typedef | HowPossibleToMixUpAtCallSite(LTypedef->desugar(),
-                                                          RTypedef->desugar(),
-                                                          Ctx, CVRMixPossible);
+      return HowPossibleToMixUpAtCallSite(LTypedef->desugar(),
+                                          RTypedef->desugar(), Ctx,
+                                          CVRMixPossible, ImplicitConversion) |
+             MIXUP_Typedef;
     }
     if (LTypedef) {
       LLVM_DEBUG(llvm::dbgs() << "!!! Left is typedef type.\n";);
-      return MIXUP_Typedef |
-             HowPossibleToMixUpAtCallSite(LTypedef->desugar(), RType, Ctx,
-                                          CVRMixPossible);
+      return HowPossibleToMixUpAtCallSite(LTypedef->desugar(), RType, Ctx,
+                                          CVRMixPossible, ImplicitConversion) |
+             MIXUP_Typedef;
     }
     if (RTypedef) {
       LLVM_DEBUG(llvm::dbgs() << "!!! Right is typedef type.\n";);
-      return MIXUP_Typedef |
-             HowPossibleToMixUpAtCallSite(LType, RTypedef->desugar(), Ctx,
-                                          CVRMixPossible);
+      return HowPossibleToMixUpAtCallSite(LType, RTypedef->desugar(), Ctx,
+                                          CVRMixPossible, ImplicitConversion) |
+             MIXUP_Typedef;
     }
   }
 
   if (LType->isPointerType() && RType->isPointerType()) {
     // (Both types being the exact same pointer is handled by LType == RType.)
+    // The implicit conversion between any T* and U* possible in C is ignored,
+    // as virtually all compilers emit a warning if the conversion is done at a
+    // call site.
     LLVM_DEBUG(llvm::dbgs() << "!!! Both Left and Right are pointer types.\n";);
+    // Implicit conversions of two pointers should be diagnosed if they point to
+    // C++ records to find Derived-To-Base implicit casts.
+    // For non-user-types, do not check - giving an unrelated, e.g. "long *" in
+    // place of an "int *" is diagnosed anyways by warnings or errors.
+    bool ShouldDiagnoseImplicitBehindPtr = ImplicitConversion &&
+                                           LType->getPointeeCXXRecordDecl() &&
+                                           RType->getPointeeCXXRecordDecl();
+    LLVM_DEBUG(
+        llvm::dbgs()
+        << "Checking mixup between pointed types. Allowing implicit modelling? "
+        << ShouldDiagnoseImplicitBehindPtr << "\nOriginally the user specified "
+        << ImplicitConversion << ".\n");
     return HowPossibleToMixUpAtCallSite(
-        LType->getPointeeType(), RType->getPointeeType(), Ctx, CVRMixPossible);
+        LType->getPointeeType(), RType->getPointeeType(), Ctx, CVRMixPossible,
+        ShouldDiagnoseImplicitBehindPtr);
   }
 
-  // A parameter of type 'T' and 'const T' may bind with the same power.
-  // Case for both types being const qualified (for the same type) is handled
-  // by LType == RType.
-  if (CVRMixPossible &&
-      (LType.isLocalConstQualified() || LType.isLocalVolatileQualified())) {
-    LLVM_DEBUG(llvm::dbgs() << "!!! Left is CV qualified.";
-               LType.dump(llvm::dbgs()); llvm::dbgs() << '\n';);
-    return MIXUP_CVR | HowPossibleToMixUpAtCallSite(LType.getUnqualifiedType(),
-                                                    RType, Ctx, CVRMixPossible);
-  }
-  if (CVRMixPossible &&
-      (RType.isLocalConstQualified() || RType.isLocalVolatileQualified())) {
-    LLVM_DEBUG(llvm::dbgs() << "!!! Right is CV qualified\n";
-               RType.dump(llvm::dbgs()); llvm::dbgs() << '\n';);
-    return MIXUP_CVR |
-           HowPossibleToMixUpAtCallSite(LType, RType.getUnqualifiedType(), Ctx,
-                                        CVRMixPossible);
+  if (ImplicitConversion) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "Implicit conversion check has been enabled! Checking...\n");
+
+    const Type *LT = LType.getTypePtr();
+    const Type *RT = RType.getTypePtr();
+
+    // Try approximating an implicit conversion sequence.
+    LLVM_DEBUG(llvm::dbgs() << "?????????? Check Left->Right ..............\n");
+    MixupData LTR =
+        HowConvertible(LT, RT, Ctx.getLangOpts(), /* AllowUserDefined =*/true);
+    LLVM_DEBUG(llvm::dbgs()
+               << "Left->Right flags: " << format_bytes(LTR.Flag) << '\n');
+    if (LTR.Flag != MIXUP_None)
+      LLVM_DEBUG(llvm::dbgs() << "Left -> Right mixup\n");
+
+    LLVM_DEBUG(llvm::dbgs() << "?????????? Check Right->Left ..............\n");
+    MixupData RTL =
+        HowConvertible(RT, LT, Ctx.getLangOpts(), /* AllowUserDefined =*/true);
+    LLVM_DEBUG(llvm::dbgs()
+               << "Left<-Right flags: " << format_bytes(RTL.Flag) << '\n');
+    if (RTL.Flag != MIXUP_None)
+      LLVM_DEBUG(llvm::dbgs() << "Left <- Right mixup\n");
+
+    if (LTR.ConvLTR && RTL.ConvRTL)
+      return {MIXUP_Implicit, LTR.ConvLTR, RTL.ConvRTL};
   }
 
-  LLVM_DEBUG(llvm::dbgs() << "<<< End of logic reached, types don't match.";);
+  LLVM_DEBUG(llvm::dbgs() << "<<< End of logic reached, types don't match.\n";);
   return MIXUP_None;
 }
 
-static MixupTag RefBindsToSameType(const LValueReferenceType *LRef,
-                                   const Type *T, bool CVRMixPossible) {
-  LLVM_DEBUG(llvm::dbgs() << "RefBindsToSameType?\n"; LRef->dump(llvm::dbgs());
+static MixupData RefBindsToSameType(const LValueReferenceType *LRef,
+                                    const Type *T, const ASTContext &Ctx,
+                                    const bool IsRefRightType,
+                                    const bool CVRMixPossible,
+                                    const bool ImplicitConversion) {
+  LLVM_DEBUG(llvm::dbgs() << "refBindsToSameType?\n"; LRef->dump(llvm::dbgs());
              llvm::dbgs() << "\n\t and \n"; T->dump(llvm::dbgs());
              llvm::dbgs() << '\n';);
 
   const QualType ReferredType = LRef->getPointeeType();
   LLVM_DEBUG(llvm::dbgs() << "Referred type:\n";
              ReferredType->dump(llvm::dbgs()););
   if (!ReferredType.isLocalConstQualified()) {
     // A non-const reference doesn't bind with the same power as a "normal"
     // by-value parameter.
     LLVM_DEBUG(llvm::dbgs() << "referred type is not const qualified.\n";);
     return MIXUP_None;
   }
 
-  if (const auto *TypedefTy = ReferredType.getTypePtr()->getAs<TypedefType>()) {
+  if (const auto *TypedefTy = ReferredType->getAs<TypedefType>()) {
     // If the referred type is a typedef, try checking the mixup-chance on the
     // desugared type.
     LLVM_DEBUG(llvm::dbgs() << "Reference to a typedef, calling back...\n";);
+    if (!IsRefRightType)
       return HowPossibleToMixUpAtCallSite(TypedefTy->desugar(), QualType{T, 0},
-                                        TypedefTy->getDecl()->getASTContext(),
-                                        CVRMixPossible);
+                                          Ctx, CVRMixPossible,
+                                          ImplicitConversion);
+    return HowPossibleToMixUpAtCallSite(QualType{T, 0}, TypedefTy->desugar(),
+                                        Ctx, CVRMixPossible,
+                                        ImplicitConversion);
   }
 
   LLVM_DEBUG(llvm::dbgs() << "is referred type type_ptr() and T the same? "
                           << (ReferredType.getTypePtr() == T) << '\n';);
-  return ReferredType.getTypePtr() == T ? MIXUP_Trivial : MIXUP_None;
+  if (ReferredType.getTypePtr() == T)
+    return MIXUP_Trivial;
+  if (ImplicitConversion) {
+    // Try to see if the reference can be bound through an implicit conversion.
+    if (!IsRefRightType)
+      return HowPossibleToMixUpAtCallSite(ReferredType.getUnqualifiedType(),
+                                          QualType{T, 0}, Ctx, CVRMixPossible,
+                                          ImplicitConversion);
+    return HowPossibleToMixUpAtCallSite(QualType{T, 0},
+                                        ReferredType.getUnqualifiedType(), Ctx,
+                                        CVRMixPossible, ImplicitConversion);
+  }
+  return MIXUP_None;
+}
+
+static inline bool IsNumericConvertible(const Type *LT, const Type *RT) {
+  LLVM_DEBUG(llvm::dbgs() << "IsNumericConvertible(" << LT << ", " << RT
+                          << ")\n");
+  if (!LT || !RT)
+    return false;
+
+  bool LI = LT->isIntegerType();
+  bool LF = LT->isFloatingType();
+  bool RI = RT->isIntegerType();
+  bool RF = RT->isFloatingType();
+
+  // Through promotions and conversions, there is free passage between
+  // "integer types" and "floating types".
+  // Promotions don't change value, conversions may result in value or precision
+  // loss, but for the sake of easy understanding, we put the two under
+  // one umbrella.
+  return (LI && RI) || (LF && RF) || (LI && RF) || (LF && RI);
+}
+
+/// Returns a Mixup indicating if the specified converting constructor can be
+/// called with LT or after applying a standard conversion sequence on LT.
+static MixupData TryConvertingConstructor(const Type *LT,
+                                          const CXXRecordDecl *RD,
+                                          const CXXConstructorDecl *Conv,
+                                          const LangOptions &LOpts) {
+  const ParmVarDecl *ConArg = Conv->getParamDecl(0);
+  MixupData Mix = HowPossibleToMixUpAtCallSite(
+      QualType{LT, 0}, ConArg->getType(), Conv->getASTContext(),
+      // Model qualifier mixing generously.
+      /* CVRMixPossible =*/true,
+      // Do not allow any further implicit conversions.
+      /* ImplicitConversion =*/false);
+  LLVM_DEBUG(llvm::dbgs() << "Conv no-std (pre  sanitise): "
+                          << format_bytes(Mix.Flag) << '\n');
+  Mix.sanitise();
+  LLVM_DEBUG(llvm::dbgs() << "Conv no-std (post sanitise): "
+                          << format_bytes(Mix.Flag) << '\n');
+  if (Mix.Flag != MIXUP_None) {
+    // If simply applying the user-defined constructor works as is, this is
+    // the right constructor.
+    LLVM_DEBUG(llvm::dbgs() << "Conversion constructor matches exactly.\n");
+    ConversionSequence Seq;
+    Seq.UserType = RD->getTypeForDecl();
+    Mix.ConvLTR = Seq;
+    return Mix;
+  }
+
+  // Otherwise, see if LT and the converting constructor's argument can be
+  // matched via a standard conversion before. This will take care of converting
+  // an int to another type.
+  ConversionSequence Seq;
+  MixupData Pre = HowConvertible(LT, ConArg->getType().getTypePtr(), LOpts,
+                                 /* AllowUserDefined =*/false);
+  LLVM_DEBUG(llvm::dbgs() << "Pre-UD: " << format_bytes(Pre.Flag)
+                          << " to type \n";
+             Pre.ConvLTR.StdPre->dump(llvm::dbgs()); llvm::dbgs() << '\n');
+  if (Pre.Flag == MIXUP_None || Pre.Flag == MIXUP_Trivial)
+    // If not possible to mix, don't check. If trivial, previous case should
+    // have returned already.
+    return MIXUP_None;
+  Seq.StdPre = Pre.ConvLTR.StdPre;
+
+  LLVM_DEBUG(llvm::dbgs()
+             << "Conversion constructor matches after standard conversion.\n");
+
+  Mix = HowPossibleToMixUpAtCallSite(
+      QualType{Seq.StdPre, 0}, ConArg->getType(), Conv->getASTContext(),
+      // Model qualifier mixing generously.
+      /* CVRMixPossible =*/true,
+      // Do not allow any further implicit conversions.
+      /* ImplicitConversion =*/false);
+  LLVM_DEBUG(llvm::dbgs() << "Conv (pre  sanitise): " << format_bytes(Mix.Flag)
+                          << '\n');
+  Mix.sanitise();
+  LLVM_DEBUG(llvm::dbgs() << "Conv (post sanitise): " << format_bytes(Mix.Flag)
+                          << '\n');
+  if (Mix.Flag != MIXUP_None) {
+    LLVM_DEBUG(llvm::dbgs() << "Conversion constructor matches!\n");
+    Seq.UserType = RD->getTypeForDecl();
+    Mix.ConvLTR = Seq;
+    return Mix;
+  }
+
+  return MIXUP_None;
+}
+
+static MixupData TryConversionOperator(const CXXConversionDecl *Conv,
+                                       const Type *RT,
+                                       const LangOptions &LOpts) {
+  MixupData Mix = HowPossibleToMixUpAtCallSite(
+      Conv->getConversionType(), QualType{RT, 0}, Conv->getASTContext(),
+      // Model qualifier mixing generously.
+      /* CVRMixPossible =*/true,
+      // Do not allow any further implicit conversions.
+      /* ImplicitConversion =*/false);
+  LLVM_DEBUG(llvm::dbgs() << "Conv no-std (pre  sanitise): "
+                          << format_bytes(Mix.Flag) << '\n');
+  Mix.sanitise();
+  LLVM_DEBUG(llvm::dbgs() << "Conv no-std (post sanitise): "
+                          << format_bytes(Mix.Flag) << '\n');
+  if (Mix.Flag != MIXUP_None) {
+    // If simply applying the user-defined operator works as is, this is
+    // the right conversion operator.
+    ConversionSequence Seq;
+    Seq.UserType = RT;
+    Mix.ConvLTR = Seq;
+    return Mix;
+  }
+
+  // Otherwise, see if the converting operator's result and RT can be
+  // matched via a standard conversion after. This will take care of converting
+  // a result of float to another type.
+  ConversionSequence Seq;
+  MixupData Post = HowConvertible(Conv->getConversionType().getTypePtr(), RT,
+                                  LOpts, /* AllowUserDefined =*/false);
+  LLVM_DEBUG(llvm::dbgs() << "Post-UD: " << format_bytes(Post.Flag)
+                          << " to type \n";
+             Post.ConvLTR.StdPre->dump(llvm::dbgs()); llvm::dbgs() << '\n');
+  if (Post.Flag == MIXUP_None || Post.Flag == MIXUP_Trivial)
+    // If not possible to mix, don't check. If trivial, previous case should
+    // have returned already.
+    return MIXUP_None;
+  // Save the result type of the user-defined conversion operator.
+  Seq.UserType = Conv->getConversionType().getTypePtr();
+
+  // The unqualified version of the conversion operator's return type can be
+  // converted to the "needed" Right-Type (output type wanted by the caller
+  // of this method). Now see if between we lost any qualifiers.
+  Mix = HowPossibleToMixUpAtCallSite(
+      Conv->getConversionType(),
+      QualType{Conv->getConversionType().getTypePtr(), 0},
+      Conv->getASTContext(),
+      // Model qualifier mixing generously.
+      /* CVRMixPossible =*/true,
+      // Do not allow any further implicit conversions.
+      /* ImplicitConversion =*/false);
+  LLVM_DEBUG(llvm::dbgs() << "Conv (pre  sanitise): " << format_bytes(Mix.Flag)
+                          << '\n');
+  Mix.sanitise();
+  LLVM_DEBUG(llvm::dbgs() << "Conv (post sanitise): " << format_bytes(Mix.Flag)
+                          << '\n');
+  if (Mix.Flag != MIXUP_None) {
+    LLVM_DEBUG(llvm::dbgs() << "Conversion operator matches!\n");
+    Seq.StdPost = RT;
+    Mix.ConvLTR = Seq;
+    return Mix;
+  }
+
+  return MIXUP_None;
+}
+
+static MixupData HowConvertible(const Type *LT, const Type *RT,
+                                const LangOptions &LOpts,
+                                bool AllowUserDefined) {
+  LLVM_DEBUG(llvm::dbgs() << ">>>>> How convertible? \n";
+             LT->dump(llvm::dbgs()); llvm::dbgs() << '\n';
+             RT->dump(llvm::dbgs()); llvm::dbgs() << '\n');
+  if (LT == RT) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "Left and right is the same, returning Trivial.\n");
+    return MIXUP_Trivial;
+  }
+
+  ConversionSequence Seq;
+
+  const auto *LBT = LT->getAs<BuiltinType>();
+  const auto *RBT = RT->getAs<BuiltinType>();
+  if (LBT && RBT && LBT == RBT)
+    return {MIXUP_Trivial};
+  if (IsNumericConvertible(LBT, RBT)) {
+    // Builtin numerical types are back-and-forth convertible.
+    LLVM_DEBUG(llvm::dbgs() << "Builtin conversion between numerics.\n");
+    Seq.StdPre = RBT;
+    return {MIXUP_Implicit, Seq};
+  }
+
+  const auto *LET = LT->getAs<EnumType>();
+  const auto *RET = RT->getAs<EnumType>();
+  if (LET && !LET->isScopedEnumeralType() && RBT &&
+      (RBT->isIntegerType() || RBT->isFloatingType())) {
+    // Enum can convert to underlying integer type.
+    LLVM_DEBUG(llvm::dbgs() << "Enum -> integer/float.\n");
+    Seq.StdPre = RBT;
+    return {MIXUP_Implicit, Seq};
+  }
+  if (LBT && (LBT->isFloatingType() || LBT->isIntegerType()) && RET) {
+    // Enum cannot be constructed from any builtin type (neither int, nor
+    // float).
+    if (LOpts.CPlusPlus) {
+      LLVM_DEBUG(llvm::dbgs() << "Numeric -/-> Enum NOT POSSIBLE (C++).\n");
+      return MIXUP_None;
+    }
+    // In C, you can go back and forth between numeric types.
+    Seq.StdPre = RET;
+    return {MIXUP_Implicit, Seq};
+  }
+
+  if (LOpts.CPlusPlus) {
+    // We are checking Left -> Right mixup, in which case Left <: Right should
+    // hold for DerivedToBase implicit cast. This is a standard implicit
+    // conversion.
+    const auto *LCXXRec = LT->getAsCXXRecordDecl();
+    const auto *RCXXRec = RT->getAsCXXRecordDecl();
+    LLVM_DEBUG(llvm::dbgs() << "Left as record: " << LCXXRec
+                            << ", Right as record: " << RCXXRec << '\n');
+    if (LCXXRec && RCXXRec && LCXXRec->isCompleteDefinition() &&
+        RCXXRec->isCompleteDefinition() &&
+        (LCXXRec->isDerivedFrom(RCXXRec) ||
+         LCXXRec->isVirtuallyDerivedFrom(RCXXRec))) {
+      LLVM_DEBUG(llvm::dbgs() << "Left <: Right, giving standard DerivedToBase "
+                                 "cast Left->Right.\n");
+      Seq.StdPre = RT;
+      return {MIXUP_Implicit, Seq};
+    }
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "Before checking user defined...\n");
+
+  if (!LOpts.CPlusPlus || !AllowUserDefined)
+    // User-defined conversions are only sensible in C++ mode.
+    return MIXUP_None;
+  assert(!Seq && "Non-user defined conversion check should've returned.");
+
+  LLVM_DEBUG(llvm::dbgs() << "Checking for user-defined conversions...\n");
+  MixupTag UserMixup = MIXUP_Invalid;
+  bool FoundConvertingCtor = false, FoundConversionOperator = false;
+  bool FoundMultipleMatches = false;
+  // An implicit conversion sequence may only contain at most *one* user-defined
+  // conversion.
+  if (const auto *RRT = RT->getAs<RecordType>()) {
+    LLVM_DEBUG(llvm::dbgs() << "Right hand side is a record type.\n");
+    const auto *RD = RRT->getAsCXXRecordDecl();
+    if (!RD)
+      // Initialisation of C-style record types from an unrelated type is not
+      // possible.
+      return MIXUP_None;
+    if (!RD->isCompleteDefinition())
+      // Incomplete definition means we don't know anything about members.
+      return MIXUP_None;
+
+    for (const CXXConstructorDecl *Con : RD->ctors()) {
+      if (Con->isCopyOrMoveConstructor() ||
+          !Con->isConvertingConstructor(/* AllowExplicit =*/false))
+        continue;
+      LLVM_DEBUG(llvm::dbgs() << "Found a converting constructor? \n";
+                 Con->dump(llvm::dbgs()); llvm::dbgs() << '\n');
+
+      MixupData ConvertingResult = TryConvertingConstructor(LT, RD, Con, LOpts);
+      if (ConvertingResult.Flag == MIXUP_None)
+        continue;
+
+      LLVM_DEBUG(llvm::dbgs() << "Came back with a positive result.\n");
+      FoundConvertingCtor = true;
+
+      if (!ConvertingResult.ConvLTR.StdPre) {
+        // A match without a pre-conversion was found for the converting ctor.
+        LLVM_DEBUG(llvm::dbgs() << "! EXACT MATCH.\n");
+        UserMixup |= ConvertingResult.Flag;
+        Seq = ConvertingResult.ConvLTR;
+        FoundMultipleMatches = false;
+        break;
+      }
+
+      if (!FoundMultipleMatches && Seq) {
+        // If the loop executes multiple times, it's possible to find multiple
+        // converting constructors with different, ambiguous conversion
+        // sequences leading up to them. This is an error, but we need to check
+        // all constructors first for a possible exact match.
+        FoundMultipleMatches = true;
+        continue;
+      }
+
+      // Register the match.
+      UserMixup |= ConvertingResult.Flag;
+      Seq = ConvertingResult.ConvLTR;
+    }
+  }
+
+  if (const auto *LRT = LT->getAs<RecordType>()) {
+    LLVM_DEBUG(llvm::dbgs() << "Left hand side is a record type.\n");
+    const auto *RD = LRT->getAsCXXRecordDecl();
+    if (!RD)
+      // Initialisation of things from an unrelated C-style record type is not
+      // possible.
+      return MIXUP_None;
+    if (!RD->isCompleteDefinition())
+      // Against getVisibleConversionFunctions() assert.
+      return MIXUP_None;
+
+    for (const NamedDecl *Method : RD->getVisibleConversionFunctions()) {
+      LLVM_DEBUG(llvm::dbgs() << "Found visible conv operator: \n";
+                 Method->dump(llvm::dbgs()); llvm::dbgs() << '\n';);
+
+      const auto *Con = dyn_cast<CXXConversionDecl>(Method);
+      if (!Con || Con->isExplicit())
+        continue;
+      LLVM_DEBUG(llvm::dbgs() << "Found a conversion method? \n";
+                 Con->dump(llvm::dbgs()); llvm::dbgs() << '\n');
+
+      MixupData ConvertingResult = TryConversionOperator(Con, RT, LOpts);
+      if (ConvertingResult.Flag == MIXUP_None)
+        continue;
+
+      LLVM_DEBUG(llvm::dbgs() << "Came back with a positive result.\n");
+      FoundConversionOperator = true;
+
+      if (!ConvertingResult.ConvLTR.StdPost) {
+        // A match without a pre-conversion was found for the converting oper.
+        LLVM_DEBUG(llvm::dbgs() << "! EXACT MATCH.\n");
+        UserMixup |= ConvertingResult.Flag;
+        Seq = ConvertingResult.ConvLTR;
+        FoundMultipleMatches = false;
+        break;
+      }
+
+      if (!FoundMultipleMatches && Seq) {
+        // If the loop executes multiple times, it's possible to find multiple
+        // conversion operators with different, ambiguous conversion
+        // sequences coming from them. This is an error, but we need to check
+        // all constructors first for a possible exact match.
+        FoundMultipleMatches = true;
+        continue;
+      }
+
+      // Register the match.
+      UserMixup |= ConvertingResult.Flag;
+      Seq = ConvertingResult.ConvLTR;
+    }
+  }
+
+  if (FoundMultipleMatches) {
+    LLVM_DEBUG(llvm::dbgs() << "Multiple conversion sequences found! :(\n");
+    return MIXUP_None;
+  }
+  if (FoundConvertingCtor && FoundConversionOperator) {
+    LLVM_DEBUG(llvm::dbgs() << "Left<->Right ambiguous as both can be "
+                               "converted to each other...\n");
+    return MIXUP_None;
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "Flags at the end of 'howConvertible?': "
+                          << format_bytes(UserMixup) << '\n');
+  return Seq ? MixupData{UserMixup, Seq} : MixupData{MIXUP_None};
 }
 
 /// Gets the mixable range of the parameters of F starting with the param at
 /// index StartIdx.
 static MixableAdjacentParamRange BuildMixableParameterRange(
     const CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck &Checker,
     const FunctionDecl *F, unsigned int StartIdx) {
   MixableAdjacentParamRange MixRange;
   const unsigned int ParamCount = F->getNumParams();
   assert(StartIdx < ParamCount && "invalid start index given!");
   const ASTContext &Ctx = F->getASTContext();
 
   const ParmVarDecl *First = F->getParamDecl(StartIdx);
   LLVM_DEBUG(llvm::dbgs() << "Start at " << StartIdx << "th param:\n";
              First->dump(llvm::dbgs()); llvm::dbgs() << '\n';);
 
   // A parameter (the one at StartIdx) was checked.
   MixRange.NumParamsChecked = 1;
 
   // Try checking parameters of the function from StartIdx until the range
-  // breaks. The range contains parameters that are mutually mixable with each
-  // other.
+  // breaks.
   for (unsigned int I = StartIdx + 1; I < ParamCount; ++I) {
     const ParmVarDecl *Ith = F->getParamDecl(I);
     LLVM_DEBUG(llvm::dbgs() << "Check " << I << "th param:\n";
                Ith->dump(llvm::dbgs()); llvm::dbgs() << '\n';);
 
     if (Checker.isIgnored(Ith))
       // If the next parameter in the range is ignored, break the range.
       break;
 
     bool AnyMixupStored = false;
     for (unsigned int J = StartIdx; J < I; ++J) {
       const ParmVarDecl *Jth = F->getParamDecl(J);
       LLVM_DEBUG(llvm::dbgs() << "Check " << J << "th param:\n";
                  Jth->dump(llvm::dbgs()); llvm::dbgs() << '\n';);
 
       Mixup M{Jth, Ith,
               HowPossibleToMixUpAtCallSite(Jth->getType(), Ith->getType(), Ctx,
-                                           Checker.CVRMixPossible)};
+                                           Checker.CVRMixPossible,
+                                           Checker.ImplicitConversion)};
       LLVM_DEBUG(llvm::dbgs() << "\tMixup (before sanitise)? "
-                              << llvm::format_bytes(M.Flags) << "\n";);
-      M.sanitise();
+                              << llvm::format_bytes(M.Data.Flag) << "\n";);
+      M.Data.sanitise();
       LLVM_DEBUG(llvm::dbgs() << "\tMixup (after  sanitise)? "
-                              << llvm::format_bytes(M.Flags) << "\n";);
-      assert(M.Flags != MIXUP_Invalid &&
+                              << llvm::format_bytes(M.Data.Flag) << "\n";);
+      assert(M.Data.Flag != MIXUP_Invalid &&
              "Bits fell off, result is sentinel value.");
 
-      if (M.Flags != MIXUP_None) {
+      if (M.Data.Flag != MIXUP_None) {
         MixRange.Mixups.emplace_back(M);
         AnyMixupStored = true;
       }
     }
 
     if (!AnyMixupStored)
       // If there is no "new" mixup possibility for the Ith param, it signifies
       // the end of range.
for (const TemplateArgument &Arg : SpecialisationTy->template_arguments()) {
       Arg.print(PP, OS);
     }
     OS << '>';
   } else if (const auto *ParenTy = dyn_cast<ParenType>(Ty))
     PutTypeName(ParenTy->getInnerType(), OS, PP);
   else if (const auto *PackTy = dyn_cast<PackExpansionType>(Ty)) {
     PutTypeName(PackTy->getPattern(), OS, PP);
     OS << "...";
   } else {
     // There are things like "GCC Vector type" and such that who knows how
     // to print properly?
     OS << "<unhandled Type of " << Ty->getTypeClassName() << '>';
   }
 }
 
 static std::string TypeNameAsString(const QualType QT,
                                     const PrintingPolicy &PP) {
CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck(
         StringRef Name, ClangTidyContext *Context)
     : ClangTidyCheck(Name, Context),
       MinimumLength(
           ClampMinimumLength(Options.get("MinimumLength", DefaultMinLength))),
       IgnoredParamNames(utils::options::parseStringList(
           Options.get("IgnoredNames", DefaultIgnoredParamNames))),
       IgnoredParamTypes(utils::options::parseStringList(
           Options.get("IgnoredTypes", DefaultIgnoredParamTypes))),
-      CVRMixPossible(Options.get("CVRMixPossible", false)) {}
+      CVRMixPossible(Options.get("CVRMixPossible", false)),
+      ImplicitConversion(Options.get("ImplicitConversion", false)) {}
 
 void CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinimumLength", MinimumLength);
   Options.store(Opts, "IgnoredNames",
                 utils::options::serializeStringList(IgnoredParamNames));
   Options.store(Opts, "IgnoredTypes",
                 utils::options::serializeStringList(IgnoredParamTypes));
   Options.store(Opts, "CVRMixPossible", CVRMixPossible);
+  Options.store(Opts, "ImplicitConversion", ImplicitConversion);
 }
 
 void CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck::
     registerMatchers(MatchFinder *Finder) {
   const LangOptions &Opts = getLangOpts();
   if (Opts.ObjC)
     // FIXME: Revise how this check could operate on ObjC code.
     return;
Finder->addMatcher(functionDecl(
                          isExplicitTemplateSpecialization())
                          .bind("fun"),
                      this);
 }
 
 /// Returns whether the given Mixup, when diagnosed, should elaborate the type
 /// of the arguments involved.
 static bool NeedsToPrintType(const Mixup &M) {
-  return M.Flags & (MIXUP_Typedef | MIXUP_RefBind | MIXUP_CVR);
+  return M.Data.Flag & (MIXUP_Typedef | MIXUP_RefBind | MIXUP_CVR);
+}
+
+/// Returns whether the given Mixup, when diagnosed, should elaborate on
+/// implicit conversions.
+static bool NeedsToElaborateImplicitConversion(const Mixup &M) {
+  return M.Data.Flag & MIXUP_Implicit;
 }
 
 void CppcoreguidelinesAvoidAdjacentParametersOfTheSameTypeCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *Fun = Result.Nodes.getNodeAs<FunctionDecl>("fun");
   LLVM_DEBUG(llvm::dbgs() << "\n#############################################"
                           << "\nHandling match for:\n";
              Fun->dump(llvm::dbgs()); llvm::dbgs() << "\n\n";);
while (ParamMixRangeStartIdx < NumArgs) {
     if (FunName.empty())
       FunName = "<unknown>";
 
     const PrintingPolicy &PP{Fun->getASTContext().getLangOpts()};
     std::string MainParmTypeAsWritten =
         MixingRange.getFirstParm()->getType().getAsString(PP);
 
     bool HasAnyTypePrint = llvm::any_of(MixingRange.Mixups, NeedsToPrintType);
+    bool HasAnyImplicits =
+        llvm::any_of(MixingRange.Mixups, NeedsToElaborateImplicitConversion);
 
     {
       const ParmVarDecl *RangeFirst = MixingRange.getFirstParm();
       const ParmVarDecl *RangeLast = MixingRange.getLastParm();
 
       {
         StringRef MainDiagnostic;
-        if (HasAnyTypePrint)
+        if (HasAnyImplicits)
+          MainDiagnostic =
+              "%0 adjacent parameters for '%1' of convertible types "
+              "may be easily swapped "
+              "by mistake";
+        else if (HasAnyTypePrint)
           MainDiagnostic = "%0 adjacent parameters for '%1' of similar type "
                            "are easily swapped "
                            "by mistake";
         else
           MainDiagnostic = "%0 adjacent parameters for '%1' of similar type "
                            "('%2') are easily "
                            "swapped by mistake";
 
         auto Diag = diag(RangeFirst->getOuterLocStart(), MainDiagnostic)
                     << static_cast<unsigned>(MixingRange.NumParamsChecked)
                     << FunName;
-        if (!HasAnyTypePrint)
+        if (!HasAnyImplicits && !HasAnyTypePrint)
           Diag << MainParmTypeAsWritten;
       }
 
       // Unfortunately, undersquiggly highlights of ranges is not supported by
       // ClangTidyDiagnosticConsumer without a fake fixit...
       diag(RangeFirst->getLocation(),
            "the first parameter in this range is '%0'", DiagnosticIDs::Note)
           << (!RangeFirst->getName().empty() ? RangeFirst->getName()
                                              : "<unnamed>");
       diag(RangeLast->getLocation(), "the last parameter in this range is '%0'",
            DiagnosticIDs::Note)
           << (!RangeLast->getName().empty() ? RangeLast->getName()
                                             : "<unnamed>");
     }
 
     llvm::SmallPtrSet<const ParmVarDecl *, 4> TypedefResolutionPrintedForParm;
     llvm::SmallPtrSet<const ParmVarDecl *, 4> CVRNotePrintedForParm;
     for (const Mixup &M : MixingRange.Mixups) {
-      assert(M.Flags >= MIXUP_Trivial && "Too low bits in mixup type.");
+      assert(M.Data.Flag >= MIXUP_Trivial && "Too low bits in mixup type.");
       // For MIXUP_Trivial no extra diagnostics required.
 
       std::string FirstParmType, SecondParmType;
-      if (NeedsToPrintType(M)) {
+      if (NeedsToPrintType(M) || NeedsToElaborateImplicitConversion(M)) {
         // Typedefs, and reference binds might result in the type of a variable
         // printed in the diagnostic, so we have to prepare it.
         LLVM_DEBUG(llvm::dbgs()
                        << "\n\nGenerating type names for diagnostic...\n\n";);
         FirstParmType = TypeNameAsString(M.First->getType(), PP);
         SecondParmType = TypeNameAsString(M.Second->getType(), PP);
         LLVM_DEBUG(llvm::dbgs() << "Type names generated: " << SecondParmType
                                 << " >> and << " << SecondParmType << '\n';);
       }
 
       if (NeedsToPrintType(M)) {
-        if (M.Flags & MIXUP_Typedef) {
+        if (M.Data.Flag & MIXUP_Typedef) {
           // FIXME: Don't emit the typedef note for the parameter that isn't
           // actually a typedef.
           if (!TypedefResolutionPrintedForParm.count(M.First)) {
             diag(M.First->getOuterLocStart(),
                  "after resolving type aliases, type of parameter '%0' is '%1'",
                  DiagnosticIDs::Note)
                 << M.First->getName() << FirstParmType;
             TypedefResolutionPrintedForParm.insert(M.First);
           }
 
           if (!TypedefResolutionPrintedForParm.count(M.Second)) {
             diag(M.Second->getOuterLocStart(),
                  "after resolving type aliases, type of parameter '%0' is '%1'",
                  DiagnosticIDs::Note)
                 << M.Second->getName() << SecondParmType;
             TypedefResolutionPrintedForParm.insert(M.Second);
           }
         }
 
-        if (M.Flags & (MIXUP_RefBind | MIXUP_CVR)) {
+        if (M.Data.Flag & (MIXUP_RefBind | MIXUP_CVR)) {
           if (!CVRNotePrintedForParm.count(M.Second)) {
             diag(M.Second->getOuterLocStart(),
                  "at a call site, '%0' might bind with same force as '%1'",
                  DiagnosticIDs::Note)
                 << SecondParmType << MainParmTypeAsWritten;
             CVRNotePrintedForParm.insert(M.Second);
           }
         }
       }
+
+      if (NeedsToElaborateImplicitConversion(M)) {
+        // FIXME: This seems to be VERY VERBOSE in some cases...
+        const ConversionSequence &LTR = M.Data.ConvLTR, &RTL = M.Data.ConvRTL;
+        const auto DiagnoseSequence =
+            [&M, &PP](const std::string &StartType,
+                      const ConversionSequence &Seq) -> std::string {
+          assert((&Seq == &M.Data.ConvLTR || &Seq == &M.Data.ConvRTL) &&
+                 "sequence should be a sequence from the capture.");
+          llvm::SmallString<256> SS;
+          llvm::raw_svector_ostream OS{SS};
+
+          OS << '\'' << StartType << '\'';
+          if (Seq.StdPre)
+            OS << " -> '" << TypeNameAsString(QualType{Seq.StdPre, 0}, PP)
+               << '\'';
+          if (Seq.UserType)
+            OS << " -> '" << TypeNameAsString(QualType{Seq.UserType, 0}, PP)
+               << '\'';
+          if (Seq.StdPost)
+            OS << " -> '" << TypeNameAsString(QualType{Seq.StdPost, 0}, PP)
+               << '\'';
+
+          return OS.str().str();
+        };
+
+        if (LTR && RTL) {
+          std::string ConvMsg =
+              "'%0' and '%1' can suffer implicit conversions between one "
+              "another";
+          if (!LTR.single() && !RTL.single())
+            ConvMsg.append(": %2 and %3");
+          else if (!LTR.single())
+            ConvMsg.append(": %2 and trivially");
+          else if (!RTL.single())
+            ConvMsg.append(": trivially and %2");
+
+          auto Diag =
+              diag(M.Second->getOuterLocStart(), ConvMsg, DiagnosticIDs::Note)
+              << FirstParmType << SecondParmType;
+          if (!LTR.single() && !RTL.single())
+            Diag << DiagnoseSequence(FirstParmType, LTR)
+                 << DiagnoseSequence(SecondParmType, RTL);
+          else if (!LTR.single())
+            Diag << DiagnoseSequence(FirstParmType, LTR);
+          else if (!RTL.single())
+            Diag << DiagnoseSequence(SecondParmType, RTL);
+        }
+      }
     }
   }
 }
 
 } // namespace experimental
 } // namespace tidy
 } // namespace clang

clang-tools-extra/docs/clang-tidy/checks/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type.rst

.. option:: CVRMixPossible
     The following example will not produce a diagnostic unless
     *CVRMixPossible* is set to a non-zero value.
 
     .. code-block:: c++
 
         struct T {};
         void f(T *tp, const T *ctp) {}
 
+.. option:: ImplicitConversion
+
+    Whether to allow the approximation of some usual
+    `implicit conversions <http://en.cppreference.com/w/cpp/language/implicit_conversion>`_
+    when considering which type might be potentially mixed up with another.
+    If `0` (default value), the check does not consider **any** implicit
+    conversions.
+    A non-zero value turns this **on**.
+    A non-zero value will in almost all cases produce a **significantly broader**
+    set of results.
+
+    .. warning::
+        Turning the modelling of implicit conversion sequences on
+        relaxes the constraints for "type convertibility" significantly,
+        however, it also applies a generous performance hit on the check's cost.
+        The check will have to explore a **polynomially more** possibilities:
+        O(n\ :sup:`2`\ ) instead of O(n) for each function's ``n`` parameters.
+        The emitted diagnostics will also be more verbose, which might take more
+        time to stringify.
+
+        It is advised to normally leave this option *off*.
+
+    For details on what is matched by this option, see
+    `Implicit conversion modelling`_.
+
+    The following examples will not produce a diagnostic unless
+    *ImplicitConversion* is set to a non-zero value.
+
+    .. code-block:: c++
+
+        void f(char c, int i, double d) {}
+
 Limitations
 -----------
 
 This check does not investigate functions that were instantiated from function
 templates.
 As such, only the primary template definitions and explicit specialisations are
 checked.
 

 
 The following example will not be warned about, despite it should be, as the
 last parameters to the function in the example are of type ``const T &``.
 
 .. code-block:: c++
 
     template <typename T>
     struct vector {
-        typedef       T          element_type;
-        typedef const T    const_element_type;
-        typedef       T &        reference_type;
-        typedef const T &  const_reference_type;
+        typename       T         element_type;
+        typename const T   const_element_type;
+        typename       T &       reference_type;
+        typename const T & const_reference_type;
     };
 
     // Finds the longest occurrence's length between elements "RightEnd"
     // and "LeftBegin". For example, in a vector of
     //     <1, 2, 3, 4, 2, 8, 8, 8, 8, 4>
     // findLongestOccurrenceLengthBetween(2, 4) should return 4 (the 4 8s).
     template <typename T>
     unsigned int findLongestOccurrenceLengthBetween(
         const          vector<T>                       & Vector,
               typename vector<T>::const_reference_type   RightEnd,
         const typename vector<T>::element_type         & LeftBegin) { /* ... */ }
+
+
+Implicit conversion modelling
+-----------------------------
+
+Given a function ``void f(T1 t, T2 u)``, unless ``T1`` and ``T2`` are the same,
+the check won't warn in *"default"* mode. If ``ImplicitConversion`` is turned on
+(see Options_), and either ``T1``
+`can be converted to <https://en.cppreference.com/w/cpp/language/implicit_conversion>`_
+``T2``, or vice versa, diagnostics will be made.
+
+In the case of the following function, the numeric parameters can be
+converted between one another.
+``SomeEnum`` is convertible to any numeric type.
+Thus, an "adjacent parameter range" of **4** is diagnosed here.
+
+.. code-blocK:: c++
+
+    enum SomeEnum { /* ... */ };
+    void SomeFunction(int, float, double, unsigned long, SomeEnum) {}
+
+Currently, the following implicit conversions are modelled:
+
+ - *standard conversion* sequences:
+    - numeric promotion and conversion between integer (including ``enum``) and
+      floating types, considered essentially the same under the umbrella term
+      "conversion"
+    - For **C** projects, the numeric conversion rules are relaxed to conform
+      to C rules.
+ - *user defined conversions*: non-``explicit`` converting constructors and
+   conversion operators.

clang-tools-extra/test/clang-tidy/checkers/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type-cvr-on.cpp

 // RUN: %check_clang_tidy %s \
 // RUN:   experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type %t \
+// RUN:   --debug --debug-only=AdjacentParameters \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type.CVRMixPossible, value: 1} \
 // RUN:   ]}' --
 
 void library(void *vp, void *vp2, void *vp3, int n, int m);
 // NO-WARN: The user has no chance to change only declared (usually library)
 // functions, so no diagnostic is made.
 

clang-tools-extra/test/clang-tidy/checkers/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type-implicits.c

+// RUN: %check_clang_tidy %s \
+// RUN:   experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type.ImplicitConversion, value: 1} \
+// RUN:   ]}' --
+
+void compare(int a, int b, int c) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: 3 adjacent parameters for 'compare' of similar type ('int') are easily swapped by mistake [experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type]
+// CHECK-MESSAGES: :[[@LINE-2]]:18: note: the first parameter in this range is 'a'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in this range is 'c'
+
+void b(_Bool b1, _Bool b2, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 3 adjacent parameters for 'b' of convertible types may be easily swapped by mistake [experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type]
+// CHECK-MESSAGES: :[[@LINE-2]]:14: note: the first parameter in this range is 'b1'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:28: note: '_Bool' and 'int' can suffer implicit conversions between one another{{$}}
+
+void integral1(signed char sc, int si) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'integral1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:28: note: the first parameter in this range is 'sc'
+// CHECK-MESSAGES: :[[@LINE-3]]:36: note: the last parameter in this range is 'si'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'signed char' and 'int' can suffer implicit conversions between one another{{$}}
+
+void integral2(long l, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'integral2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in this range is 'l'
+// CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:24: note: 'long' and 'int' can suffer implicit conversions between one another{{$}}
+
+void integral3(int i, long l) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'integral3' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:20: note: the first parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in this range is 'l'
+// CHECK-MESSAGES: :[[@LINE-4]]:23: note: 'int' and 'long' can suffer implicit conversions between one another{{$}}
+
+void integral4(char c, int i, long l) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 3 adjacent parameters for 'integral4' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in this range is 'c'
+// CHECK-MESSAGES: :[[@LINE-3]]:36: note: the last parameter in this range is 'l'
+// CHECK-MESSAGES: :[[@LINE-4]]:24: note: 'char' and 'int' can suffer implicit conversions between one another{{$}}
+// CHECK-MESSAGES: :[[@LINE-5]]:31: note: 'char' and 'long' can suffer implicit conversions between one another{{$}}
+
+void floating1(float f, double d) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'floating1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:22: note: the first parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-4]]:25: note: 'float' and 'double' can suffer implicit conversions between one another{{$}}
+
+typedef double D;
+void floating2(float f, D d) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'floating2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:22: note: the first parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-3]]:27: note: the last parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-4]]:16: note: after resolving type aliases, type of parameter 'f' is 'float'
+// CHECK-MESSAGES: :[[@LINE-5]]:25: note: after resolving type aliases, type of parameter 'd' is 'double'
+// CHECK-MESSAGES: :[[@LINE-6]]:25: note: 'float' and 'double' can suffer implicit conversions between one another{{$}}
+
+void floatToInt(float f, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: 2 adjacent parameters for 'floatToInt' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:23: note: the first parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-3]]:30: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:26: note: 'float' and 'int' can suffer implicit conversions between one another{{$}}
+
+enum En { A,
+          B };
+
+void unscopedEnumToIntegral(enum En e, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters for 'unscopedEnumToIntegral' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:37: note: the first parameter in this range is 'e'
+// CHECK-MESSAGES: :[[@LINE-3]]:44: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:40: note: 'enum En' and 'int' can suffer implicit conversions between one another{{$}}
+
+void unscopedEnumToIntegral2(enum En e, unsigned long long ull) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:30: warning: 2 adjacent parameters for 'unscopedEnumToIntegral2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:38: note: the first parameter in this range is 'e'
+// CHECK-MESSAGES: :[[@LINE-3]]:60: note: the last parameter in this range is 'ull'
+// CHECK-MESSAGES: :[[@LINE-4]]:41: note: 'enum En' and 'unsigned long long' can suffer implicit conversions between one another{{$}}
+
+void unscopedEnum3(char c, enum En e, char c2) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:20: warning: 3 adjacent parameters for 'unscopedEnum3' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:25: note: the first parameter in this range is 'c'
+// CHECK-MESSAGES: :[[@LINE-3]]:44: note: the last parameter in this range is 'c2'
+// CHECK-MESSAGES: :[[@LINE-4]]:28: note: 'char' and 'enum En' can suffer implicit conversions between one another{{$}}
+// CHECK-MESSAGES: :[[@LINE-5]]:39: note: 'enum En' and 'char' can suffer implicit conversions between one another{{$}}
+
+void unscopedEnumToFloating(enum En e, long double ld) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters for 'unscopedEnumToFloating' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:37: note: the first parameter in this range is 'e'
+// CHECK-MESSAGES: :[[@LINE-3]]:52: note: the last parameter in this range is 'ld'
+// CHECK-MESSAGES: :[[@LINE-4]]:40: note: 'enum En' and 'long double' can suffer implicit conversions between one another{{$}}
+
+void unscopedEnumToIntOrFloat(enum En e, int i, float f) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:31: warning: 3 adjacent parameters for 'unscopedEnumToIntOrFloat' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:39: note: the first parameter in this range is 'e'
+// CHECK-MESSAGES: :[[@LINE-3]]:55: note: the last parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-4]]:42: note: 'enum En' and 'int' can suffer implicit conversions between one another{{$}}
+// CHECK-MESSAGES: :[[@LINE-5]]:49: note: 'enum En' and 'float' can suffer implicit conversions between one another{{$}}
+// CHECK-MESSAGES: :[[@LINE-6]]:49: note: 'int' and 'float' can suffer implicit conversions between one another{{$}}
+
+void ptr(int *i, long *l) {}
+// NO-WARN: Though 'int' and 'long' can be converted between one-another
+// implicitly, mixing such pointers is diagnosed by compiler warnings.

clang-tools-extra/test/clang-tidy/checkers/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type-implicits.cpp

+// RUN: %check_clang_tidy %s \
+// RUN:   experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type.ImplicitConversion, value: 1} \
+// RUN:   ]}' --
+
+void compare(int a, int b, int c) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:14: warning: 3 adjacent parameters for 'compare' of similar type ('int') are easily swapped by mistake [experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type]
+// CHECK-MESSAGES: :[[@LINE-2]]:18: note: the first parameter in this range is 'a'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in this range is 'c'
+
+void b(bool b1, bool b2, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:8: warning: 3 adjacent parameters for 'b' of convertible types may be easily swapped by mistake [experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type]
+// CHECK-MESSAGES: :[[@LINE-2]]:13: note: the first parameter in this range is 'b1'
+// CHECK-MESSAGES: :[[@LINE-3]]:30: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:26: note: 'bool' and 'int' can suffer implicit conversions between one another{{$}}
+
+void integral1(signed char sc, int si) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'integral1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:28: note: the first parameter in this range is 'sc'
+// CHECK-MESSAGES: :[[@LINE-3]]:36: note: the last parameter in this range is 'si'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'signed char' and 'int' can suffer implicit conversions between one another{{$}}
+
+void integral2(long l, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'integral2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in this range is 'l'
+// CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:24: note: 'long' and 'int' can suffer implicit conversions between one another{{$}}
+
+void integral3(int i, long l) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'integral3' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:20: note: the first parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-3]]:28: note: the last parameter in this range is 'l'
+// CHECK-MESSAGES: :[[@LINE-4]]:23: note: 'int' and 'long' can suffer implicit conversions between one another{{$}}
+
+void integral4(char c, int i, long l) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 3 adjacent parameters for 'integral4' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in this range is 'c'
+// CHECK-MESSAGES: :[[@LINE-3]]:36: note: the last parameter in this range is 'l'
+// CHECK-MESSAGES: :[[@LINE-4]]:24: note: 'char' and 'int' can suffer implicit conversions between one another{{$}}
+// CHECK-MESSAGES: :[[@LINE-5]]:31: note: 'char' and 'long' can suffer implicit conversions between one another{{$}}
+
+void floating1(float f, double d) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'floating1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:22: note: the first parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-4]]:25: note: 'float' and 'double' can suffer implicit conversions between one another{{$}}
+
+typedef double D;
+void floating2(float f, D d) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'floating2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:22: note: the first parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-3]]:27: note: the last parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-4]]:16: note: after resolving type aliases, type of parameter 'f' is 'float'
+// CHECK-MESSAGES: :[[@LINE-5]]:25: note: after resolving type aliases, type of parameter 'd' is 'double'
+// CHECK-MESSAGES: :[[@LINE-6]]:25: note: 'float' and 'double' can suffer implicit conversions between one another{{$}}
+
+void floatToInt(float f, int i) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:17: warning: 2 adjacent parameters for 'floatToInt' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:23: note: the first parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-3]]:30: note: the last parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-4]]:26: note: 'float' and 'int' can suffer implicit conversions between one another{{$}}
+
+enum En { A,
+          B };
+
+// NO-WARN: In C++, unscoped enums can be converted to scalars, but not the
+// other way around.
+
+void unscopedEnumToIntegral(En e, int i) {} // NO-WARN
+
+void unscopedEnumToIntegral2(En e, unsigned long long ull) {} // NO-WARN
+
+void unscopedEnum3(char c, En e, char c2) {} // NO-WARN
+
+void unscopedEnumToFloating(En e, long double ld) {} // NO-WARN
+
+void unscopedEnumToIntOrFloat(En e, int i, float f) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:37: warning: 2 adjacent parameters for 'unscopedEnumToIntOrFloat' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:41: note: the first parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-3]]:50: note: the last parameter in this range is 'f'
+// CHECK-MESSAGES: :[[@LINE-4]]:44: note: 'int' and 'float' can suffer implicit conversions between one another{{$}}
+
+enum class SEn { C,
+                 D };
+void scopedEnumToIntegral(SEn e, int i) {}
+// NO-WARN: Scoped enumerations mustn't be promoted.
+
+struct FromInt {
+  FromInt(int);
+};
+
+// NO-WARN: User-defined conversions in just one direction.
+
+void userConv1(int i, FromInt fi) {}
+
+void userConv1c(int i, const FromInt cfi) {}
+// NO-WARN: CVRMixPossible is set to 0, so an 'int' and a 'const "int"' does not mix.
+
+void userConv1cr(int i, const FromInt &cfir) {}
+
+void userConv2(unsigned long long ull, FromInt fi) {}
+
+struct ToInt {
+  operator int() const;
+};
+
+void userConv3(int i, ToInt ti) {}
+
+void userConv4(double d, FromInt fi) {}
+
+void userConv4cr(double d, const FromInt &cfir) {}
+
+struct FromDouble {
+  FromDouble(double);
+};
+
+void userConv5(En e, FromDouble fd) {}
+
+struct Ambiguous {
+  Ambiguous(int);
+  Ambiguous(long);
+};
+
+void userConv6(En e, Ambiguous a) {}
+
+struct ToExplicitInt {
+  explicit operator int() const;
+};
+struct FromExplicitInt {
+  explicit FromExplicitInt(int);
+};
+
+void nonConverting1(int i, FromExplicitInt fei) {}
+
+void nonConverting2(int i, ToExplicitInt tei) {}
+
+struct Both {
+  Both(int);
+  operator int() const;
+};
+
+typedef int I;
+typedef double D;
+
+void both1(int i, Both b) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters for 'both1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:16: note: the first parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-3]]:24: note: the last parameter in this range is 'b'
+// CHECK-MESSAGES: :[[@LINE-4]]:19: note: 'int' and 'Both' can suffer implicit conversions between one another{{$}}
+
+void both2(double d, Both b) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:12: warning: 2 adjacent parameters for 'both2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:19: note: the first parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-3]]:27: note: the last parameter in this range is 'b'
+// CHECK-MESSAGES: :[[@LINE-4]]:22: note: 'double' and 'Both' can suffer implicit conversions between one another: 'double' -> 'int' -> 'Both' and 'Both' -> 'int' -> 'double'
+
+void both2typedef(D d, Both b) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters for 'both2typedef' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:21: note: the first parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-3]]:29: note: the last parameter in this range is 'b'
+// CHECK-MESSAGES: :[[@LINE-4]]:19: note: after resolving type aliases, type of parameter 'd' is 'double'
+// CHECK-MESSAGES: :[[@LINE-5]]:24: note: after resolving type aliases, type of parameter 'b' is 'Both'
+// CHECK-MESSAGES: :[[@LINE-6]]:24: note: 'double' and 'Both' can suffer implicit conversions between one another: 'double' -> 'int' -> 'Both' and 'Both' -> 'int' -> 'double'
+
+struct BoxedInt {
+  BoxedInt();
+  BoxedInt(const BoxedInt &);
+  BoxedInt(BoxedInt &&);
+  BoxedInt(const Both &B);
+};
+
+void both3(int i, BoxedInt biv) {}
+// NO-WARN: Two converting constructor calls (int->both->BoxedInt) is not
+// possible implicitly.
+
+struct IntAndDouble {
+  IntAndDouble(const int);
+  IntAndDouble(const double);
+
+  operator int() const;
+  operator double() const;
+};
+
+void twoTypes1(int i, IntAndDouble iad) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'twoTypes1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:20: note: the first parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-3]]:36: note: the last parameter in this range is 'iad'
+// CHECK-MESSAGES: :[[@LINE-4]]:23: note: 'int' and 'IntAndDouble' can suffer implicit conversions between one another{{$}}
+
+void twoTypes2(double d, IntAndDouble iad) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:16: warning: 2 adjacent parameters for 'twoTypes2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:23: note: the first parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-3]]:39: note: the last parameter in this range is 'iad'
+// CHECK-MESSAGES: :[[@LINE-4]]:26: note: 'double' and 'IntAndDouble' can suffer implicit conversions between one another{{$}}
+
+void twoTypes3(unsigned long ul, IntAndDouble iad) {}
+// NO-WARN: Ambiguous constructor call and conversion call, should we take
+// 'int' or 'double' route from 'unsigned long'?
+
+struct IADTypedef {
+  IADTypedef(I);
+  IADTypedef(D);
+  operator I() const;
+  operator D() const;
+};
+
+void twoTypedefs1(int i, IADTypedef iadt) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters for 'twoTypedefs1' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:23: note: the first parameter in this range is 'i'
+// CHECK-MESSAGES: :[[@LINE-3]]:37: note: the last parameter in this range is 'iadt'
+// CHECK-MESSAGES: :[[@LINE-4]]:26: note: 'int' and 'IADTypedef' can suffer implicit conversions between one another{{$}}
+
+void twoTypedefs2(double d, IADTypedef iadt) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters for 'twoTypedefs2' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:26: note: the first parameter in this range is 'd'
+// CHECK-MESSAGES: :[[@LINE-3]]:40: note: the last parameter in this range is 'iadt'
+// CHECK-MESSAGES: :[[@LINE-4]]:29: note: 'double' and 'IADTypedef' can suffer implicit conversions between one another{{$}}
+
+void twoTypedefs3(unsigned long ul, IADTypedef iadt) {}
+// NO-WARN: Ambiguous constructor call and conversion call, should we take
+// 'int' or 'double' route from 'unsigned long'?
+
+struct Fwd1;
+struct Fwd2;
+void forwards(Fwd1 *f1, Fwd2 *f2) {}
+// NO-WARN and NO-CRASH: Don't try to compare incomplete types.
+
+struct Rec {};
+struct FromRec {
+  FromRec(const Rec &);
+};
+struct ToRec {
+  operator Rec() const;
+};
+struct RecBoth {
+  RecBoth(Rec);
+  operator Rec() const;
+};
+
+void record2record_1(Rec r, FromRec fr) {}
+// NO-WARN: One-way used defined conversion only.
+
+void record2record_2(Rec r, ToRec tr) {}
+// NO-WARN: One-way used defined conversion only.
+
+void record2record_3(Rec r, RecBoth rb) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:22: warning: 2 adjacent parameters for 'record2record_3' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:26: note: the first parameter in this range is 'r'
+// CHECK-MESSAGES: :[[@LINE-3]]:37: note: the last parameter in this range is 'rb'
+// CHECK-MESSAGES: :[[@LINE-4]]:29: note: 'Rec' and 'RecBoth' can suffer implicit conversions between one another{{$}}
+
+void record2record_4(Rec r, FromRec fr, ToRec tr, RecBoth rb) {}
+// NO-WARN: "Rec" and "RecBoth" are not adjacent.
+
+struct X;
+struct Y;
+struct X {
+  X();
+  X(Y);
+  operator Y();
+};
+struct Y {
+  Y();
+  Y(X);
+  operator X();
+};
+void ambiguous_records(X x, Y y) {}
+// NO-WARN: Ambiguous conversion if the arguments are swapped, which results in
+// compiler error: f3(Y{}, X{})
+
+struct Base {};
+struct Derived1 : Base {};
+struct Derived2 : Base {};
+void upcasting(Base *bp, Derived1 *d1p, Derived2 *d2p) {}
+// NO-WARN: Upcasts are unidirectional.
+
+void upcasting_ref(const Base &br, const Derived1 &d1r, const Derived2 &d2r) {}
+
+// This example is weird, because normally * or & upcasts are unidirectional,
+// except when the user explicitly writes converting functions.
+struct WeirdDerived;
+struct WeirdBase {
+  operator WeirdDerived() const;
+};
+struct WeirdDerived : WeirdBase {};
+
+void weird_upcast(const WeirdBase &wbr, const WeirdDerived &wdr) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters for 'weird_upcast' of convertible
+// CHECK-MESSAGES: :[[@LINE-2]]:36: note: the first parameter in this range is 'wbr'
+// CHECK-MESSAGES: :[[@LINE-3]]:61: note: the last parameter in this range is 'wdr'
+// CHECK-MESSAGES: :[[@LINE-4]]:41: note: at a call site, 'const WeirdDerived &' might bind with same force as 'const WeirdBase &'
+// CHECK-MESSAGES: :[[@LINE-5]]:41: note: 'const WeirdBase &' and 'const WeirdDerived &' can suffer implicit conversions between one another{{$}}
+
+// Reduced case from live crash on OpenCV
+// http://github.com/opencv/opencv/blob/1996ae4a42d7c7cd338fbdd4abbd83b41b448328/modules/core/include/opencv2/core/types.hpp#L173
+template <typename T>
+struct TemplateConversion {
+  TemplateConversion();
+  TemplateConversion(const T &);
+  template <typename T2>
+  operator TemplateConversion<T2>() const;
+};
+typedef TemplateConversion<int> IntConvert;
+typedef TemplateConversion<float> FloatConvert;
+void templated_conversion_to_other_specialisation(FloatConvert fc, IntConvert ic) {}
+// NO-WARN: Template conversion operators are not resolved, we have approximated
+// much of Sema already...

clang-tools-extra/test/clang-tidy/checkers/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type-minlen3.cpp

void setColouredOutput2(BackColour Background,
                         ForeColour Foreground,
                         BorderColour Border) {}
 // CHECK-MESSAGES: :[[@LINE-3]]:25: warning: 3 adjacent parameters for 'setColouredOutput2' of similar type are
 // CHECK-MESSAGES: :[[@LINE-4]]:36: note: the first parameter in this range is 'Background'
 // CHECK-MESSAGES: :[[@LINE-3]]:38: note: the last parameter in this range is 'Border'
 // CHECK-MESSAGES: :[[@LINE-6]]:25: note: after resolving type aliases, type of parameter 'Background' is 'OldSchoolTermColour'
 // CHECK-MESSAGES: :[[@LINE-6]]:25: note: after resolving type aliases, type of parameter 'Foreground' is 'OldSchoolTermColour'
 // CHECK-MESSAGES: :[[@LINE-6]]:25: note: after resolving type aliases, type of parameter 'Border' is 'OldSchoolTermColour'
+
+// NO-WARN: Implicit conversions should not warn if the check option is turned off.
+
+void integral1(signed char sc, int si) {}
+
+struct FromInt {
+  FromInt(int);
+};
+void userConv1(int i, FromInt fi) {}
+
+struct Base {};
+struct Derived1 : Base {};
+struct Derived2 : Base {};
+void upcasting(Base *bp, Derived1 *d1p, Derived2 *d2p) {}
+void upcasting_ref(const Base &br, const Derived1 &d1r, const Derived2 &d2r) {}
+
+// END of NO-WARN.

clang-tools-extra/test/clang-tidy/checkers/experimental-cppcoreguidelines-avoid-adjacent-parameters-of-the-same-type.c

 typedef struct {
   int x;
 } S;
 
 int equals2(S l, S r) { return l.x == r.x; }
 // CHECK-MESSAGES: :[[@LINE-1]]:13: warning: 2 adjacent parameters for 'equals2' of similar type ('S') are
 // CHECK-MESSAGES: :[[@LINE-2]]:15: note: the first parameter in this range is 'l'
 // CHECK-MESSAGES: :[[@LINE-3]]:20: note: the last parameter in this range is 'r'
+
+void ptrs(int *i, long *l) {}
+// NO-WARN: Mixing fundamentals' pointers is diagnosed by compiler warnings.