[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

747 ↗

(On Diff #259324)

'chute, I hate merge conflicts...

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

113–120 ↗

(On Diff #259324)

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

162

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

723–733

@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

251–261

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

345–346

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

441

Should this be MIX_WorkaroundDisableCanonicalEquivalence instead of MIX_None?

551–552

569–570

589–591

What about a DecayedType?

723–733

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).

826

[whisperity]

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

441

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

158

162

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

723–733

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

723–733

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

85–101

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

128

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

156

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

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

42–43

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

[whisperity]

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

723–733

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

85–101

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!

128

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.

156

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–43

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

[martong]

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

85–101

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

128

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.

156

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–43

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

1210

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

590–591

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

590–591

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

723–733

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

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

556

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

1491

1493

1503

[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

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/bugprone/EasilySwappableParametersCheck.h

public:
 
   /// The parameter names (as written in the source text) to be ignored.
   const std::vector<std::string> IgnoredParameterNames;
 
   /// The parameter typename suffixes (as written in the source code) to be
   /// ignored.
   const std::vector<std::string> IgnoredParameterTypeSuffixes;
 
-  /// Whether to consider an unqualified and a qualified type mixable.
+  /// Whether to consider differently qualified versions of the same type
+  /// mixable.
   const bool QualifiersMix;
+
+  /// Whether to model implicit conversions "in full" (conditions apply)
+  /// during analysis and consider types that are implicitly convertible to
+  /// one another mixable.
+  const bool ModelImplicitConversions;
 };
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_TIDY_BUGPRONE_EASILYSWAPPABLEPARAMETERSCHECK_H

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

optutils::serializeStringList({"bool",
                                    "Const_Reverse_Iterator",
                                    "const_reverse_iterator"
                                    "Constreverseiterator",
                                    "constreverseiterator"});
 
 /// The default value for the QualifiersMix check option.
 static constexpr bool DefaultQualifiersMix = false;
 
+/// The default value for the ModelImplicitConversions check option.
+static constexpr bool DefaultModelImplicitConversions = true;
+
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace bugprone {
 
 using TheCheck = EasilySwappableParametersCheck;
 
 namespace filter {
 static bool isIgnoredParameter(const TheCheck &Check, const ParmVarDecl *Node);
 } // namespace filter
 
 namespace model {
 
 /// The language features involved in allowing the mix between two parameters.
 enum class MixFlags : unsigned char {
   Invalid = 0, //< Sentinel bit pattern. DO NOT USE!
 
-  None = 1,           //< Mix between the two parameters is not possible.
-  Trivial = 2,        //< The two mix trivially, and are the exact same type.
-  Canonical = 4,      //< The two mix because the types refer to the same
+  //< Certain constructs (such as pointers to noexcept/non-noexcept functions)
+  // have the same CanonicalType, which would result in false positives.
+  // During the recursive modelling call, this flag is set if a later diagnosed
+  // canonical type equivalence should be thrown away.
+  WorkaroundDisableCanonicalEquivalence = 1,
+
+  None = 2,           //< Mix between the two parameters is not possible.
+  Trivial = 4,        //< The two mix trivially, and are the exact same type.
+  Canonical = 8,      //< The two mix because the types refer to the same
                       // CanonicalType, but we do not elaborate as to how.
-  TypeAlias = 8,      //< The path from one type to the other involves
+  TypeAlias = 16,     //< The path from one type to the other involves
                       // desugaring type aliases.
-  ReferenceBind = 16, //< The mix involves the binding power of "const &".
-  Qualifiers = 32,    //< The mix involves change in the qualifiers.
+  ReferenceBind = 32, //< The mix involves the binding power of "const &".
+  Qualifiers = 64,    //< The mix involves change in the qualifiers.
+  ImplicitConversion = 128, //< The mixing of the parameters is possible
+                            // through implicit conversions between the types.
 
-  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue =*/Qualifiers)
+  LLVM_MARK_AS_BITMASK_ENUM(/* LargestValue =*/ImplicitConversion)
 };
 LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
 
 /// Returns whether the SearchedFlag is turned on in the Data.
 static inline bool hasFlag(MixFlags Data, MixFlags SearchedFlag) {
   assert(SearchedFlag != MixFlags::Invalid &&
          "can't be used to detect lack of all bits!");
 
   // "Data & SearchedFlag" would need static_cast<bool>() in conditions.
   return (Data & SearchedFlag) == SearchedFlag;
 }
 
 #ifndef NDEBUG
 
 // The modelling logic of this check is more complex than usual, and
 // potentially hard to understand without the ability to see into the
 // representation during the recursive descent. This debug code is only
 // compiled in 'Debug' mode, or if LLVM_ENABLE_ASSERTIONS config is turned on.
 
 /// Formats the MixFlags enum into a useful, user-readable representation.
 static inline std::string formatMixFlags(MixFlags F) {
   if (F == MixFlags::Invalid)
     return "#Inv!";
 
-  SmallString<8> Str{"------"};
+  SmallString<8> Str{"-------"};
 
   if (hasFlag(F, MixFlags::None))
     // Shows the None bit explicitly, as it can be applied in the recursion
     // even if other bits are set.
     Str[0] = '!';
   if (hasFlag(F, MixFlags::Trivial))
     Str[1] = 'T';
   if (hasFlag(F, MixFlags::Canonical))
     Str[2] = 'C';
   if (hasFlag(F, MixFlags::TypeAlias))
     Str[3] = 't';
   if (hasFlag(F, MixFlags::ReferenceBind))
     Str[4] = '&';
   if (hasFlag(F, MixFlags::Qualifiers))
     Str[5] = 'Q';
+  if (hasFlag(F, MixFlags::ImplicitConversion))
+    Str[6] = 'i';
+
+  if (hasFlag(F, MixFlags::WorkaroundDisableCanonicalEquivalence))
+    Str.append("(~C)");
 
   return Str.str().str();
 }
 
 #else
 
 static inline std::string formatMixFlags(MixFlags F);
 
 #endif // NDEBUG
 
+/// The results of the steps of an Implicit Conversion Sequence is saved in
+/// an instance of this record.
+///
+/// A ConversionSequence maps the steps of the conversion with a member for
+/// each type involved in the conversion. Imagine going from a hypothetical
+/// Complex class to projecting it to the real part as a const double.
+///
+/// I.e., given:
+///
+///    struct Complex {
+///      operator double() const;
+///    };
+///
+///    void functionBeingAnalysed(Complex C, const double R);
+///
+/// we will get the following sequence:
+///
+/// (Begin=) Complex
+///
+///     The first standard conversion is a qualification adjustment.
+/// (AfterFirstStandard=) const Complex
+///
+///     Then the user-defined conversion is executed.
+/// (UDConvOp.ConversionOperatorResultType=) double
+///
+///     Then this 'double' is qualifier-adjusted to 'const double'.
+/// (AfterSecondStandard=) double
+///
+/// The conversion's result has now been calculated, so it ends here.
+/// (End=) double.
+///
+/// Explicit storing of Begin and End in this record is needed, because
+/// getting to what Begin and End here are needs further resolution of types,
+/// e.g. in the case of typedefs:
+///
+///     using Comp = Complex;
+///     using CD = const double;
+///     void functionBeingAnalysed2(Comp C, CD R);
+///
+/// In this case, the user will be diagnosed with a potential conversion
+/// between the two typedefs as written in the code, but to elaborate the
+/// reasoning behind this conversion, we also need to show what the typedefs
+/// mean. See FormattedConversionSequence towards the bottom of this file!
+struct ConversionSequence {
+  enum UserDefinedConversionKind { UDCK_None, UDCK_Ctor, UDCK_Oper };
+
+  struct UserDefinedConvertingConstructor {
+    const CXXConstructorDecl *Fun;
+    QualType ConstructorParameterType;
+    QualType UserDefinedType;
+  };
+
+  struct UserDefinedConversionOperator {
+    const CXXConversionDecl *Fun;
+    QualType UserDefinedType;
+    QualType ConversionOperatorResultType;
+  };
+
+  /// The type the conversion stared from.
+  QualType Begin;
+
+  /// The intermediate type after the first Standard Conversion Sequence.
+  QualType AfterFirstStandard;
+
+  /// The details of the user-defined conversion involved, as a tagged union.
+  union {
+    char None;
+    UserDefinedConvertingConstructor UDConvCtor;
+    UserDefinedConversionOperator UDConvOp;
+  };
+  UserDefinedConversionKind UDConvKind;
+
+  /// The intermediate type after performing the second Standard Conversion
+  /// Sequence.
+  QualType AfterSecondStandard;
+
+  /// The result type the conversion targeted.
+  QualType End;
+
+  ConversionSequence() : None(0), UDConvKind(UDCK_None) {}
+  ConversionSequence(QualType From, QualType To)
+      : Begin(From), None(0), UDConvKind(UDCK_None), End(To) {}
+
+  explicit operator bool() const {
+    return !AfterFirstStandard.isNull() || UDConvKind != UDCK_None ||
+           !AfterSecondStandard.isNull();
+  }
+
+  /// Returns all the "steps" (non-unique and non-similar) types involved in
+  /// the conversion sequence. This method does **NOT** return Begin and End.
+  SmallVector<QualType, 4> getInvolvedTypesInSequence() const {
+    SmallVector<QualType, 4> Ret;
+    auto EmplaceIfDifferent = [&Ret](QualType QT) {
+      if (QT.isNull())
+        return;
+      if (Ret.empty())
+        Ret.emplace_back(QT);
+      else if (Ret.back() != QT)
+        Ret.emplace_back(QT);
+    };
+
+    EmplaceIfDifferent(AfterFirstStandard);
+    switch (UDConvKind) {
+    case UDCK_Ctor:
+      EmplaceIfDifferent(UDConvCtor.ConstructorParameterType);
+      EmplaceIfDifferent(UDConvCtor.UserDefinedType);
+      break;
+    case UDCK_Oper:
+      EmplaceIfDifferent(UDConvOp.UserDefinedType);
+      EmplaceIfDifferent(UDConvOp.ConversionOperatorResultType);
+      break;
+    case UDCK_None:
+      break;
+    }
+    EmplaceIfDifferent(AfterSecondStandard);
+
+    return Ret;
+  }
+
+  /// Updates the steps of the conversion sequence with the steps from the
+  /// other instance.
+  ///
+  /// \note This method does not check if the resulting conversion sequence is
+  /// sensible!
+  ConversionSequence &update(const ConversionSequence &RHS) {
+    if (!RHS.AfterFirstStandard.isNull())
+      AfterFirstStandard = RHS.AfterFirstStandard;
+    switch (RHS.UDConvKind) {
+    case UDCK_Ctor:
+      UDConvKind = UDCK_Ctor;
+      UDConvCtor = RHS.UDConvCtor;
+      break;
+    case UDCK_Oper:
+      UDConvKind = UDCK_Oper;
+      UDConvOp = RHS.UDConvOp;
+      break;
+    case UDCK_None:
+      break;
+    }
+    if (!RHS.AfterSecondStandard.isNull())
+      AfterSecondStandard = RHS.AfterSecondStandard;
+
+    return *this;
+  }
+
+  /// Sets the user-defined conversion to the given constructor.
+  void setConversion(const UserDefinedConvertingConstructor &UDCC) {
+    UDConvKind = UDCK_Ctor;
+    UDConvCtor = UDCC;
+  }
+
+  /// Sets the user-defined conversion to the given operator.
+  void setConversion(const UserDefinedConversionOperator &UDCO) {
+    UDConvKind = UDCK_Oper;
+    UDConvOp = UDCO;
+  }
+
+  /// Returns the type in the conversion that's formally "in our hands" once
+  /// the user-defined conversion is executed.
+  QualType getTypeAfterUserDefinedConversion() const {
+    switch (UDConvKind) {
+    case UDCK_Ctor:
+      return UDConvCtor.UserDefinedType;
+    case UDCK_Oper:
+      return UDConvOp.ConversionOperatorResultType;
+    case UDCK_None:
+      return {};
+    }
+    llvm_unreachable("Invalid UDConv kind.");
+  }
+
+  const CXXMethodDecl *getUserDefinedConversionFunction() const {
+    switch (UDConvKind) {
+    case UDCK_Ctor:
+      return UDConvCtor.Fun;
+    case UDCK_Oper:
+      return UDConvOp.Fun;
+    case UDCK_None:
+      return {};
+    }
+    llvm_unreachable("Invalid UDConv kind.");
+  }
+
+  /// Returns the SourceRange in the text that corresponds to the interesting
+  /// part of the user-defined conversion. This is either the parameter type
+  /// in a converting constructor, or the conversion result type in a conversion
+  /// operator.
+  SourceRange getUserDefinedConversionHighlight() const {
+    switch (UDConvKind) {
+    case UDCK_Ctor:
+      return UDConvCtor.Fun->getParamDecl(0)->getSourceRange();
+    case UDCK_Oper:
+      // getReturnTypeSourceRange() does not work for CXXConversionDecls as the
+      // returned type is physically behind the declaration's name ("operator").
+      if (const FunctionTypeLoc FTL = UDConvOp.Fun->getFunctionTypeLoc())
+        if (const TypeLoc RetLoc = FTL.getReturnLoc())
+          return RetLoc.getSourceRange();
+      return {};
+    case UDCK_None:
+      return {};
+    }
+    llvm_unreachable("Invalid UDConv kind.");
+  }
+};
+
 /// Contains the metadata for the mixability result between two types,
 /// independently of which parameters they were calculated from.
 struct MixData {
   /// The flag bits of the mix indicating what language features allow for it.
-  MixFlags Flags;
+  MixFlags Flags = MixFlags::Invalid;
 
   /// A potentially calculated common underlying type after desugaring, that
   /// both sides of the mix can originate from.
   QualType CommonType;
 
+  /// The steps an implicit conversion performs to get from one type to the
+  /// other.
+  ConversionSequence Conversion, ConversionRTL;
+
+  /// True if the MixData was specifically created with only a one-way
+  /// conversion modelled.
+  bool CreatedFromOneWayConversion = false;
+
   MixData(MixFlags Flags) : Flags(Flags) {}
   MixData(MixFlags Flags, QualType CommonType)
       : Flags(Flags), CommonType(CommonType) {}
+  MixData(MixFlags Flags, ConversionSequence Conv)
+      : Flags(Flags), Conversion(Conv), CreatedFromOneWayConversion(true) {}
+  MixData(MixFlags Flags, ConversionSequence LTR, ConversionSequence RTL)
+      : Flags(Flags), Conversion(LTR), ConversionRTL(RTL) {}
+  MixData(MixFlags Flags, QualType CommonType, ConversionSequence LTR,
+          ConversionSequence RTL)
+      : Flags(Flags), CommonType(CommonType), Conversion(LTR),
+        ConversionRTL(RTL) {}
 
   void sanitize() {
     assert(Flags != MixFlags::Invalid && "sanitize() called on invalid bitvec");
 
+    MixFlags CanonicalAndWorkaround =
+        MixFlags::Canonical | MixFlags::WorkaroundDisableCanonicalEquivalence;
+    if ((Flags & CanonicalAndWorkaround) == CanonicalAndWorkaround) {
+      // A workaround for too eagerly equivalent canonical types was requested,
+      // and a canonical equivalence was proven. Fulfill the request and throw
+      // this result away.
+      Flags = MixFlags::None;
+      return;
+    }
+
     if (hasFlag(Flags, MixFlags::None)) {
       // If anywhere down the recursion a potential mix "path" is deemed
       // impossible, throw away all the other bits because the mix is not
       // possible.
       Flags = MixFlags::None;
       return;
     }
 
     if (Flags == MixFlags::Trivial)
       return;
 
     if (static_cast<bool>(Flags ^ MixFlags::Trivial))
       // If the mix involves somewhere trivial equivalence but down the
       // recursion other bit(s) were set, remove the trivial bit, as it is not
       // trivial.
       Flags &= ~MixFlags::Trivial;
+
+    bool ShouldHaveImplicitConvFlag = false;
+    if (CreatedFromOneWayConversion && Conversion)
+      ShouldHaveImplicitConvFlag = true;
+    else if (!CreatedFromOneWayConversion && Conversion && ConversionRTL)
+      // Only say that we have implicit conversion mix possibility if it is
+      // bidirectional. Otherwise, the compiler would report an *actual* swap
+      // at a call site...
+      ShouldHaveImplicitConvFlag = true;
+
+    if (ShouldHaveImplicitConvFlag)
+      Flags |= MixFlags::ImplicitConversion;
+    else
+      Flags &= ~MixFlags::ImplicitConversion;
   }
 
+  bool isValid() const { return Flags >= MixFlags::None; }
+
+  bool indicatesMixability() const { return Flags > MixFlags::None; }
+
   /// Add the specified flag bits to the flags.
   MixData operator|(MixFlags EnableFlags) const {
-    return {Flags | EnableFlags, CommonType};
+    if (CreatedFromOneWayConversion) {
+      MixData M{Flags | EnableFlags, Conversion};
+      M.CommonType = CommonType;
+      return M;
+    }
+    return {Flags | EnableFlags, CommonType, Conversion, ConversionRTL};
   }
 
   /// Add the specified flag bits to the flags.
   MixData &operator|=(MixFlags EnableFlags) {
     Flags |= EnableFlags;
     return *this;
   }
 
   /// Add the specified qualifiers to the common type in the Mix.
   MixData qualify(Qualifiers Quals) const {
     SplitQualType Split = CommonType.split();
     Split.Quals.addQualifiers(Quals);
+    QualType CommonType{Split.Ty, Split.Quals.getAsOpaqueValue()};
 
-    return {Flags, QualType(Split.Ty, Split.Quals.getAsOpaqueValue())};
+    if (CreatedFromOneWayConversion) {
+      MixData M{Flags, Conversion};
+      M.CommonType = CommonType;
+      return M;
+    }
+    return {Flags, CommonType, Conversion, ConversionRTL};
   }
 };
 
 /// A named tuple that contains the information for a mix between two concrete
 /// parameters.
 struct Mix {
   const ParmVarDecl *First, *Second;
   MixData Data;
 
   Mix(const ParmVarDecl *F, const ParmVarDecl *S, MixData Data)
       : First(F), Second(S), Data(std::move(Data)) {}
 
   void sanitize() { Data.sanitize(); }
   MixFlags flags() const { return Data.Flags; }
+  bool flagsValid() const { return Data.isValid(); }
+  bool mixable() const { return Data.indicatesMixability(); }
   QualType commonUnderlyingType() const { return Data.CommonType; }
+  const ConversionSequence &leftToRightConversionSequence() const {
+    return Data.Conversion;
+  }
+  const ConversionSequence &rightToLeftConversionSequence() const {
+    return Data.ConversionRTL;
+  }
 };
 
 // NOLINTNEXTLINE(misc-redundant-expression): Seems to be a bogus warning.
 static_assert(std::is_trivially_copyable<Mix>::value &&
                   std::is_trivially_move_constructible<Mix>::value &&
                   std::is_trivially_move_assignable<Mix>::value,
               "Keep frequently used data simple!");
 
const ParmVarDecl *getLastParam() const {
     // finds something that can not be mixed with the rest, by going *forward*
     // in the list of parameters. So at any moment of break, the RHS of the last
     // element of the mix vector is also the last element of the mixing range.
     assert(!Mixes.empty());
     return Mixes.back().Second;
   }
 };
 
-static MixData isLRefEquallyBindingToType(const TheCheck &Check,
-                                          const LValueReferenceType *LRef,
-                                          QualType Ty, const ASTContext &Ctx,
-                                          bool IsRefRHS);
+/// Helper enum for the recursive calls in the modelling that toggle what kinds
+/// of implicit conversions are to be modelled.
+enum ImplicitConversionModellingMode : unsigned char {
+  //< No implicit conversions are modelled.
+  ICMM_None,
+
+  //< The full implicit conversion sequence is modelled.
+  ICMM_All,
+
+  //< Only model a unidirectional implicit conversion and within it only one
+  // standard conversion sequence.
+  ICMM_OneWaySingleStandardOnly
+};
+
+static MixData
+isLRefEquallyBindingToType(const TheCheck &Check,
+                           const LValueReferenceType *LRef, QualType Ty,
+                           const ASTContext &Ctx, bool IsRefRHS,
+                           ImplicitConversionModellingMode ImplicitMode);
+
+static MixData
+approximateImplicitConversion(const TheCheck &Check, QualType LType,
+                              QualType RType, const ASTContext &Ctx,
+                              ImplicitConversionModellingMode ImplicitMode);
+
+static inline bool isUselessSugar(const Type *T) {
+  return isa<DecayedType, ElaboratedType, ParenType>(T);
+}
 
 /// Approximate the way how LType and RType might refer to "essentially the
 /// same" type, in a sense that at a particular call site, an expression of
 /// type LType and RType might be successfully passed to a variable (in our
 /// specific case, a parameter) of type RType and LType, respectively.
 /// Note the swapped order!
 ///
 /// The returned data structure is not guaranteed to be properly set, as this
 /// function is potentially recursive. It is the caller's responsibility to
 /// call sanitize() on the result once the recursion is over.
-static MixData calculateMixability(const TheCheck &Check, const QualType LType,
-                                   const QualType RType,
-                                   const ASTContext &Ctx) {
+static MixData
+calculateMixability(const TheCheck &Check, QualType LType, QualType RType,
+                    const ASTContext &Ctx,
+                    ImplicitConversionModellingMode ImplicitMode) {
   LLVM_DEBUG(llvm::dbgs() << ">>> calculateMixability for LType:\n";
              LType.dump(llvm::dbgs(), Ctx); llvm::dbgs() << "\nand RType:\n";
              RType.dump(llvm::dbgs(), Ctx); llvm::dbgs() << '\n';);
 
+  // Certain constructs match on the last catch-all getCanonicalType() equality,
+  // which is perhaps something not what we want. If this variable is true,
+  // the canonical type equality will be ignored.
+  bool RecursiveReturnDiscardingCanonicalType = false;
+
   if (LType == RType) {
     LLVM_DEBUG(llvm::dbgs() << "<<< calculateMixability. Trivial equality.\n");
     return {MixFlags::Trivial, LType};
   }
 
   // Dissolve certain type sugars that do not affect the mixability of one type
   // with the other, and also do not require any sort of elaboration for the
   // user to understand.
-  if (isa<ParenType>(LType.getTypePtr())) {
-    LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. LHS is ParenType.\n");
+  if (isUselessSugar(LType.getTypePtr())) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- calculateMixability. LHS is useless sugar.\n");
     return calculateMixability(Check, LType.getSingleStepDesugaredType(Ctx),
-                               RType, Ctx);
+                               RType, Ctx, ImplicitMode);
   }
-  if (isa<ParenType>(RType.getTypePtr())) {
-    LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. RHS is ParenType.\n");
-    return calculateMixability(Check, LType,
-                               RType.getSingleStepDesugaredType(Ctx), Ctx);
+  if (isUselessSugar(RType.getTypePtr())) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- calculateMixability. RHS is useless sugar.\n");
+    return calculateMixability(
+        Check, LType, RType.getSingleStepDesugaredType(Ctx), Ctx, ImplicitMode);
   }
 
   // At a particular call site, what could be passed to a 'T' or 'const T' might
   // also be passed to a 'const T &' without the call site putting a direct
   // side effect on the passed expressions.
   if (const auto *LRef = LType->getAs<LValueReferenceType>()) {
     LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. LHS is &.\n");
-    return isLRefEquallyBindingToType(Check, LRef, RType, Ctx, false) |
+    return isLRefEquallyBindingToType(Check, LRef, RType, Ctx, false,
+                                      ImplicitMode) |
            MixFlags::ReferenceBind;
   }
   if (const auto *RRef = RType->getAs<LValueReferenceType>()) {
     LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. RHS is &.\n");
-    return isLRefEquallyBindingToType(Check, RRef, LType, Ctx, true) |
+    return isLRefEquallyBindingToType(Check, RRef, LType, Ctx, true,
+                                      ImplicitMode) |
            MixFlags::ReferenceBind;
   }
 
   // Dissolve typedefs after the qualifiers outside the typedef are dealt with.
   if (LType->getAs<TypedefType>()) {
     LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. LHS is typedef.\n");
     return calculateMixability(Check, LType.getSingleStepDesugaredType(Ctx),
-                               RType, Ctx) |
+                               RType, Ctx, ImplicitMode) |
            MixFlags::TypeAlias;
   }
   if (RType->getAs<TypedefType>()) {
     LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. RHS is typedef.\n");
     return calculateMixability(Check, LType,
-                               RType.getSingleStepDesugaredType(Ctx), Ctx) |
+                               RType.getSingleStepDesugaredType(Ctx), Ctx,
+                               ImplicitMode) |
            MixFlags::TypeAlias;
   }
 
   // A parameter of type 'cvr1 T' and another of potentially differently
   // qualified 'cvr2 T' may bind with the same power, if the user so requested.
   if (LType.getLocalCVRQualifiers() != RType.getLocalCVRQualifiers()) {
     LLVM_DEBUG(if (LType.getLocalCVRQualifiers()) llvm::dbgs()
                << "--- calculateMixability. LHS is CVR.\n");
     LLVM_DEBUG(if (RType.getLocalCVRQualifiers()) llvm::dbgs()
                << "--- calculateMixability. RHS is CVR.\n");
 
     if (!Check.QualifiersMix) {
       LLVM_DEBUG(llvm::dbgs()
                  << "<<< calculateMixability. QualifiersMix turned off.\n");
       return {MixFlags::None};
     }
 
     return calculateMixability(Check, LType.getLocalUnqualifiedType(),
-                               RType.getLocalUnqualifiedType(), Ctx) |
+                               RType.getLocalUnqualifiedType(), Ctx,
+                               ImplicitMode) |
            MixFlags::Qualifiers;
   }
   if (LType.getLocalCVRQualifiers() == RType.getLocalCVRQualifiers() &&
       LType.getLocalCVRQualifiers() != 0) {
     LLVM_DEBUG(llvm::dbgs()
                << "--- calculateMixability. LHS and RHS same CVR.\n");
     // Apply the same qualifier back into the found common type if we found
     // a common type between the unqualified versions.
     return calculateMixability(Check, LType.getLocalUnqualifiedType(),
-                               RType.getLocalUnqualifiedType(), Ctx)
+                               RType.getLocalUnqualifiedType(), Ctx,
+                               ImplicitMode)
         .qualify(LType.getLocalQualifiers());
   }
 
   if (LType->isPointerType() && RType->isPointerType()) {
     // If both types are pointers, and pointed to the exact same type,
-    // LType == RType took care of that.
-    // Try to see if the pointee type has some other match.
+    // LType == RType took care of that. Try to see if the pointee type has
+    // some other match. However, this must not consider implicit conversions.
     LLVM_DEBUG(llvm::dbgs()
                << "--- calculateMixability. LHS and RHS are Ptrs.\n");
-    return calculateMixability(Check, LType->getPointeeType(),
-                               RType->getPointeeType(), Ctx);
+    MixData MixOfPointee =
+        calculateMixability(Check, LType->getPointeeType(),
+                            RType->getPointeeType(), Ctx, ICMM_None);
+    if (hasFlag(MixOfPointee.Flags,
+                MixFlags::WorkaroundDisableCanonicalEquivalence))
+      RecursiveReturnDiscardingCanonicalType = true;
+
+    MixOfPointee.sanitize();
+    if (MixOfPointee.indicatesMixability()) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "<<< calculateMixability. Pointees are mixable.\n");
+      return MixOfPointee;
+    }
+  }
+
+  if (ImplicitMode > ICMM_None) {
+    LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. Start implicit...\n");
+    MixData MixLTR =
+        approximateImplicitConversion(Check, LType, RType, Ctx, ImplicitMode);
+    LLVM_DEBUG(
+        if (hasFlag(MixLTR.Flags, MixFlags::ImplicitConversion)) llvm::dbgs()
+            << "--- calculateMixability. Implicit Left -> Right found.\n";);
+
+    if (ImplicitMode == ICMM_OneWaySingleStandardOnly && MixLTR.Conversion &&
+        !MixLTR.Conversion.AfterFirstStandard.isNull() &&
+        MixLTR.Conversion.UDConvKind == ConversionSequence::UDCK_None &&
+        MixLTR.Conversion.AfterSecondStandard.isNull()) {
+      // The invoker of the method requested only modelling a single standard
+      // conversion, in only the forward direction, and they got just that.
+      LLVM_DEBUG(llvm::dbgs() << "<<< calculateMixability. Implicit "
+                                 "conversion, one-way, standard-only.\n");
+      return {MixFlags::ImplicitConversion, MixLTR.Conversion};
+    }
+
+    // Otherwise if the invoker requested a full modelling, do the other
+    // direction as well.
+    MixData MixRTL =
+        approximateImplicitConversion(Check, RType, LType, Ctx, ImplicitMode);
+    LLVM_DEBUG(
+        if (hasFlag(MixRTL.Flags, MixFlags::ImplicitConversion)) llvm::dbgs()
+            << "--- calculateMixability. Implicit Right -> Left found.\n";);
+
+    if (MixLTR.Conversion && MixRTL.Conversion) {
+      LLVM_DEBUG(
+          llvm::dbgs()
+          << "<<< calculateMixability. Implicit conversion, bidirectional.\n");
+      return {MixFlags::ImplicitConversion, MixLTR.Conversion,
+              MixRTL.Conversion};
+    }
+  }
+
+  if (RecursiveReturnDiscardingCanonicalType)
+    LLVM_DEBUG(llvm::dbgs() << "--- calculateMixability. Before CanonicalType, "
+                               "Discard was enabled.\n");
+
+  // Certain kinds unfortunately need to be side-stepped for canonical type
+  // matching.
+  if (LType->getAs<FunctionProtoType>() || RType->getAs<FunctionProtoType>()) {
+    // Unfortunately, the canonical type of a function pointer becomes the
+    // same even if exactly one is "noexcept" and the other isn't, making us
+    // give a false positive report irrespective of implicit conversions.
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- calculateMixability. Discarding potential canonical "
+                  "equivalence on FunctionProtoTypes.\n");
+    RecursiveReturnDiscardingCanonicalType = true;
   }
 
+  MixData MixToReturn{MixFlags::None};
+
   // If none of the previous logic found a match, try if Clang otherwise
   // believes the types to be the same.
-  if (LType.getCanonicalType() == RType.getCanonicalType()) {
+  QualType LCanonical = LType.getCanonicalType();
+  if (LCanonical == RType.getCanonicalType()) {
     LLVM_DEBUG(llvm::dbgs()
                << "<<< calculateMixability. Same CanonicalType.\n");
-    return {MixFlags::Canonical, LType.getCanonicalType()};
+    MixToReturn = {MixFlags::Canonical, LCanonical};
   }
 
-  LLVM_DEBUG(llvm::dbgs() << "<<< calculateMixability. No match found.\n");
-  return {MixFlags::None};
+  if (RecursiveReturnDiscardingCanonicalType)
+    MixToReturn |= MixFlags::WorkaroundDisableCanonicalEquivalence;
+
+  LLVM_DEBUG(if (MixToReturn.Flags == MixFlags::None) llvm::dbgs()
+             << "<<< calculateMixability. No match found.\n");
+  return MixToReturn;
 }
 
 /// Calculates if the reference binds an expression of the given type. This is
 /// true iff 'LRef' is some 'const T &' type, and the 'Ty' is 'T' or 'const T'.
-static MixData isLRefEquallyBindingToType(const TheCheck &Check,
-                                          const LValueReferenceType *LRef,
-                                          QualType Ty, const ASTContext &Ctx,
-                                          bool IsRefRHS) {
+///
+/// \param ImplicitMode is forwarded in the possible recursive call to
+/// calculateMixability.
+static MixData
+isLRefEquallyBindingToType(const TheCheck &Check,
+                           const LValueReferenceType *LRef, QualType Ty,
+                           const ASTContext &Ctx, bool IsRefRHS,
+                           ImplicitConversionModellingMode ImplicitMode) {
   LLVM_DEBUG(llvm::dbgs() << ">>> isLRefEquallyBindingToType for LRef:\n";
              LRef->dump(llvm::dbgs(), Ctx); llvm::dbgs() << "\nand Type:\n";
              Ty.dump(llvm::dbgs(), Ctx); llvm::dbgs() << '\n';);
 
   QualType ReferredType = LRef->getPointeeType();
   if (!ReferredType.isLocalConstQualified() &&
       ReferredType->getAs<TypedefType>()) {
     LLVM_DEBUG(
if (NonConstReferredType == Ty) {
     LLVM_DEBUG(llvm::dbgs() << "<<< isLRefEquallyBindingToType. Type of "
                                "referred matches to non-const qualified.\n");
     return {MixFlags::Trivial, NonConstReferredType};
   }
 
   LLVM_DEBUG(
       llvm::dbgs()
       << "--- isLRefEquallyBindingToType. Checking mix for underlying type.\n");
-  return IsRefRHS ? calculateMixability(Check, Ty, NonConstReferredType, Ctx)
-                  : calculateMixability(Check, NonConstReferredType, Ty, Ctx);
+  return IsRefRHS ? calculateMixability(Check, Ty, NonConstReferredType, Ctx,
+                                        ImplicitMode)
+                  : calculateMixability(Check, NonConstReferredType, Ty, Ctx,
+                                        ImplicitMode);
+}
+
+static inline bool isDerivedToBase(const CXXRecordDecl *Derived,
+                                   const CXXRecordDecl *Base) {
+  return Derived && Base && Derived->isCompleteDefinition() &&
+         Base->isCompleteDefinition() && Derived->isDerivedFrom(Base);
+}
+
+static Optional<QualType>
+approximateStandardConversionSequence(const TheCheck &Check, QualType From,
+                                      QualType To, const ASTContext &Ctx) {
+  LLVM_DEBUG(llvm::dbgs() << ">>> approximateStdConv for LType:\n";
+             From.dump(llvm::dbgs(), Ctx); llvm::dbgs() << "\nand RType:\n";
+             To.dump(llvm::dbgs(), Ctx); llvm::dbgs() << '\n';);
+
+  // A standard conversion sequence consists of the following, in order:
+  //  * Maybe either LValue->RValue conv., Array->Ptr conv., Function->Ptr conv.
+  //  * Maybe Numeric promotion or conversion.
+  //  * Maybe function pointer conversion.
+  //  * Maybe qualifier adjustments.
+  QualType WorkType = From;
+  // Get out the qualifiers of the original type. This will always be
+  // re-applied to the WorkType to ensure it is the same qualification as the
+  // original From was.
+  auto QualifiersToApply = From.split().Quals.getAsOpaqueValue();
+
+  // LValue->RValue is irrelevant for the check, because it is a thing to be
+  // done at a call site, and will be performed if need be performed.
+
+  // Array->Ptr decay.
+  if (const auto *ArrayT = dyn_cast<ArrayType>(From)) {
+    LLVM_DEBUG(llvm::dbgs() << "--- approximateStdConv. Array->Ptr decayed.\n");
+    WorkType = ArrayT->getPointeeType();
+  }
+
+  // Function->Pointer conversions are also irrelevant, because a
+  // "FunctionType" cannot be the type of a parameter variable, so this
+  // conversion is only meaningful at call sites.
+
+  // Numeric promotions and conversions.
+  const auto *FromBuiltin = WorkType->getAs<BuiltinType>();
+  const auto *ToBuiltin = To->getAs<BuiltinType>();
+  bool FromNumeric = FromBuiltin && (FromBuiltin->isIntegerType() ||
+                                     FromBuiltin->isFloatingType());
+  bool ToNumeric =
+      ToBuiltin && (ToBuiltin->isIntegerType() || ToBuiltin->isFloatingType());
+  if (FromNumeric && ToNumeric) {
+    // If both are integral types, the numeric conversion is performed.
+    // Reapply the qualifiers of the original type, however, so
+    // "const int -> double" in this case moves over to
+    // "const double -> double".
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- approximateStdConv. Conversion between numerics.\n");
+    WorkType = QualType{ToBuiltin, QualifiersToApply};
+  }
+
+  const auto *FromEnum = WorkType->getAs<EnumType>();
+  const auto *ToEnum = To->getAs<EnumType>();
+  if (FromEnum && ToNumeric && FromEnum->isUnscopedEnumerationType()) {
+    // Unscoped enumerations (or enumerations in C) convert to numerics.
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- approximateStdConv. Unscoped enum to numeric.\n");
+    WorkType = QualType{ToBuiltin, QualifiersToApply};
+  } else if (FromNumeric && ToEnum && ToEnum->isUnscopedEnumerationType()) {
+    // Numeric types convert to enumerations only in C.
+    if (Ctx.getLangOpts().CPlusPlus) {
+      LLVM_DEBUG(llvm::dbgs() << "<<< approximateStdConv. Numeric to unscoped "
+                                 "enum, not possible in C++!\n");
+      return {};
+    }
+
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- approximateStdConv. Numeric to unscoped enum.\n");
+    WorkType = QualType{ToEnum, QualifiersToApply};
+  }
+
+  // Check for pointer conversions.
+  const auto *FromPtr = WorkType->getAs<PointerType>();
+  const auto *ToPtr = To->getAs<PointerType>();
+  if (FromPtr && ToPtr) {
+    if (ToPtr->isVoidPointerType()) {
+      LLVM_DEBUG(llvm::dbgs() << "--- approximateStdConv. To void pointer.\n");
+      WorkType = QualType{ToPtr, QualifiersToApply};
+    }
+
+    const auto *FromRecordPtr = FromPtr->getPointeeCXXRecordDecl();
+    const auto *ToRecordPtr = ToPtr->getPointeeCXXRecordDecl();
+    if (isDerivedToBase(FromRecordPtr, ToRecordPtr)) {
+      LLVM_DEBUG(llvm::dbgs() << "--- approximateStdConv. Derived* to Base*\n");
+      WorkType = QualType{ToPtr, QualifiersToApply};
+    }
+  }
+
+  // Model the slicing Derived-to-Base too, as "BaseT temporary = derived;"
+  // can also be compiled.
+  const auto *FromRecord = WorkType->getAsCXXRecordDecl();
+  const auto *ToRecord = To->getAsCXXRecordDecl();
+  if (isDerivedToBase(FromRecord, ToRecord)) {
+    LLVM_DEBUG(llvm::dbgs() << "--- approximateStdConv. Derived To Base.\n");
+    WorkType = QualType{ToRecord->getTypeForDecl(), QualifiersToApply};
+  }
+
+  if (Ctx.getLangOpts().CPlusPlus17 && FromPtr && ToPtr) {
+    // Function pointer conversion: A noexcept function pointer can be passed
+    // to a non-noexcept one.
+    const auto *FromFunctionPtr =
+        FromPtr->getPointeeType()->getAs<FunctionProtoType>();
+    const auto *ToFunctionPtr =
+        ToPtr->getPointeeType()->getAs<FunctionProtoType>();
+    if (FromFunctionPtr && ToFunctionPtr &&
+        FromFunctionPtr->hasNoexceptExceptionSpec() &&
+        !ToFunctionPtr->hasNoexceptExceptionSpec()) {
+      LLVM_DEBUG(llvm::dbgs() << "--- approximateStdConv. noexcept function "
+                                 "pointer to non-noexcept.\n");
+      WorkType = QualType{ToPtr, QualifiersToApply};
+    }
+  }
+
+  // Qualifier adjustments are modelled according to the user's request in
+  // the QualifiersMix check config.
+  LLVM_DEBUG(llvm::dbgs()
+             << "--- approximateStdConv. Trying qualifier adjustment...\n");
+  MixData QualConv = calculateMixability(Check, WorkType, To, Ctx, ICMM_None);
+  QualConv.sanitize();
+  if (hasFlag(QualConv.Flags, MixFlags::Qualifiers)) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "<<< approximateStdConv. Qualifiers adjusted.\n");
+    WorkType = To;
+  }
+
+  if (WorkType == To) {
+    LLVM_DEBUG(llvm::dbgs() << "<<< approximateStdConv. Reached 'To' type.\n");
+    return {WorkType};
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "<<< approximateStdConv. Did not reach 'To'.\n");
+  return {};
+}
+
+namespace {
+
+/// Helper class for storing possible user-defined conversion calls that
+/// *could* take place in an implicit conversion, and selecting the one that
+/// most likely *does*, if any.
+class UserDefinedConversionSelector {
+public:
+  /// The conversion associated with a conversion function, together with the
+  /// mixability flags of the conversion function's parameter or return type
+  /// to the rest of the sequence the selector is used in, and the sequence
+  /// that applied through the conversion itself.
+  struct PreparedConversion {
+    const CXXMethodDecl *ConversionFun;
+    MixFlags Flags;
+    ConversionSequence Seq;
+
+    PreparedConversion(const CXXMethodDecl *CMD, MixFlags F,
+                       ConversionSequence S)
+        : ConversionFun(CMD), Flags(F), Seq(S) {}
+  };
+
+  UserDefinedConversionSelector(const TheCheck &Check) : Check(Check) {}
+
+  /// Adds the conversion between the two types for the given function into
+  /// the possible implicit conversion set. FromType and ToType is either:
+  ///   * the result of a standard sequence and a converting ctor parameter
+  ///   * the return type of a conversion operator and the expected target of
+  ///     an implicit conversion.
+  void addConversion(const CXXMethodDecl *ConvFun, QualType FromType,
+                     QualType ToType) {
+    // Try to go from the FromType to the ToType wiht only a single implicit
+    // conversion, to see if the conversion function is applicable.
+    MixData Mix =
+        calculateMixability(Check, FromType, ToType, ConvFun->getASTContext(),
+                            ICMM_OneWaySingleStandardOnly);
+    Mix.sanitize();
+    if (!Mix.indicatesMixability())
+      return;
+
+    LLVM_DEBUG(llvm::dbgs() << "--- tryConversion. Found viable with flags: "
+                            << formatMixFlags(Mix.Flags) << '\n');
+    FlaggedConversions.emplace_back(ConvFun, Mix.Flags, Mix.Conversion);
+  }
+
+  /// Selects the best conversion function that is applicable from the
+  /// prepared set of potential conversion functions taken.
+  Optional<PreparedConversion> operator()() const {
+    if (FlaggedConversions.empty()) {
+      LLVM_DEBUG(llvm::dbgs() << "--- selectUserDefinedConv. Empty.\n");
+      return {};
+    }
+    if (FlaggedConversions.size() == 1) {
+      LLVM_DEBUG(llvm::dbgs() << "--- selectUserDefinedConv. Single.\n");
+      return FlaggedConversions.front();
+    }
+
+    Optional<PreparedConversion> BestConversion;
+    unsigned short HowManyGoodConversions = 0;
+    for (const auto &Prepared : FlaggedConversions) {
+      LLVM_DEBUG(llvm::dbgs() << "--- selectUserDefinedConv. Candidate flags: "
+                              << formatMixFlags(Prepared.Flags) << '\n');
+      if (!BestConversion) {
+        BestConversion = Prepared;
+        ++HowManyGoodConversions;
+        continue;
+      }
+
+      bool BestConversionHasImplicit =
+          hasFlag(BestConversion->Flags, MixFlags::ImplicitConversion);
+      bool ThisConversionHasImplicit =
+          hasFlag(Prepared.Flags, MixFlags::ImplicitConversion);
+      if (!BestConversionHasImplicit && ThisConversionHasImplicit)
+        // This is a worse conversion, because a better one was found earlier.
+        continue;
+
+      if (BestConversionHasImplicit && !ThisConversionHasImplicit) {
+        // If the so far best selected conversion needs a previous implicit
+        // conversion to match the user-defined converting function, but this
+        // conversion does not, this is a better conversion, and we can throw
+        // away the previously selected conversion(s).
+        BestConversion = Prepared;
+        HowManyGoodConversions = 1;
+        continue;
+      }
+
+      if (BestConversionHasImplicit == ThisConversionHasImplicit)
+        // The current conversion is the same in term of goodness than the
+        // already selected one.
+        ++HowManyGoodConversions;
+    }
+
+    if (HowManyGoodConversions == 1) {
+      LLVM_DEBUG(llvm::dbgs()
+                 << "--- selectUserDefinedConv. Unique result. Flags: "
+                 << formatMixFlags(BestConversion->Flags) << '\n');
+      return BestConversion;
+    }
+
+    LLVM_DEBUG(llvm::dbgs()
+               << "--- selectUserDefinedConv. No, or ambiguous.\n");
+    return {};
+  }
+
+private:
+  llvm::SmallVector<PreparedConversion, 2> FlaggedConversions;
+  const TheCheck &Check;
+};
+
+} // namespace
+
+static Optional<ConversionSequence>
+tryConversionOperators(const TheCheck &Check, const CXXRecordDecl *RD,
+                       QualType ToType) {
+  if (!RD || !RD->isCompleteDefinition())
+    return {};
+  RD = RD->getDefinition();
+
+  LLVM_DEBUG(llvm::dbgs() << ">>> tryConversionOperators: " << RD->getName()
+                          << " to:\n";
+             ToType.dump(llvm::dbgs(), RD->getASTContext());
+             llvm::dbgs() << '\n';);
+
+  UserDefinedConversionSelector ConversionSet{Check};
+
+  for (const NamedDecl *Method : RD->getVisibleConversionFunctions()) {
+    const auto *Con = dyn_cast<CXXConversionDecl>(Method);
+    if (!Con || Con->isExplicit())
+      continue;
+    LLVM_DEBUG(llvm::dbgs() << "--- tryConversionOperators. Trying:\n";
+               Con->dump(llvm::dbgs()); llvm::dbgs() << '\n';);
+
+    // Try to go from the result of conversion operator to the expected type,
+    // without calculating another user-defined conversion.
+    ConversionSet.addConversion(Con, Con->getConversionType(), ToType);
+  }
+
+  if (Optional<UserDefinedConversionSelector::PreparedConversion>
+          SelectedConversion = ConversionSet()) {
+    QualType RecordType{RD->getTypeForDecl(), 0};
+
+    ConversionSequence Result{RecordType, ToType};
+    // The conversion from the operator call's return type to ToType was
+    // modelled as a "pre-conversion" in the operator call, but it is the
+    // "post-conversion" from the point of view of the original conversion
+    // we are modelling.
+    Result.AfterSecondStandard = SelectedConversion->Seq.AfterFirstStandard;
+
+    ConversionSequence::UserDefinedConversionOperator ConvOp;
+    ConvOp.Fun = cast<CXXConversionDecl>(SelectedConversion->ConversionFun);
+    ConvOp.UserDefinedType = RecordType;
+    ConvOp.ConversionOperatorResultType = ConvOp.Fun->getConversionType();
+    Result.setConversion(ConvOp);
+
+    LLVM_DEBUG(llvm::dbgs() << "<<< tryConversionOperators. Found result.\n");
+    return Result;
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "<<< tryConversionOperators. No conversion.\n");
+  return {};
+}
+
+static Optional<ConversionSequence>
+tryConvertingConstructors(const TheCheck &Check, QualType FromType,
+                          const CXXRecordDecl *RD) {
+  if (!RD || !RD->isCompleteDefinition())
+    return {};
+  RD = RD->getDefinition();
+
+  LLVM_DEBUG(llvm::dbgs() << ">>> tryConveringConstructors: " << RD->getName()
+                          << " from:\n";
+             FromType.dump(llvm::dbgs(), RD->getASTContext());
+             llvm::dbgs() << '\n';);
+
+  UserDefinedConversionSelector ConversionSet{Check};
+
+  for (const CXXConstructorDecl *Con : RD->ctors()) {
+    if (Con->isCopyOrMoveConstructor() ||
+        !Con->isConvertingConstructor(/* AllowExplicit =*/false))
+      continue;
+    LLVM_DEBUG(llvm::dbgs() << "--- tryConvertingConstructors. Trying:\n";
+               Con->dump(llvm::dbgs()); llvm::dbgs() << '\n';);
+
+    // Try to go from the original FromType to the converting constructor's
+    // parameter type without another user-defined conversion.
+    ConversionSet.addConversion(Con, FromType, Con->getParamDecl(0)->getType());
+  }
+
+  if (Optional<UserDefinedConversionSelector::PreparedConversion>
+          SelectedConversion = ConversionSet()) {
+    QualType RecordType{RD->getTypeForDecl(), 0};
+
+    ConversionSequence Result{FromType, RecordType};
+    Result.AfterFirstStandard = SelectedConversion->Seq.AfterFirstStandard;
+
+    ConversionSequence::UserDefinedConvertingConstructor Ctor;
+    Ctor.Fun = cast<CXXConstructorDecl>(SelectedConversion->ConversionFun);
+    Ctor.ConstructorParameterType = Ctor.Fun->getParamDecl(0)->getType();
+    Ctor.UserDefinedType = RecordType;
+    Result.setConversion(Ctor);
+
+    LLVM_DEBUG(llvm::dbgs()
+               << "<<< tryConvertingConstructors. Found result.\n");
+    return Result;
+  }
+
+  LLVM_DEBUG(llvm::dbgs() << "<<< tryConvertingConstructors. No conversion.\n");
+  return {};
+}
+
+/// Returns whether an expression of LType can be used in an RType context, as
+/// per the implicit conversion rules.
+///
+/// Note: the result of this operation, unlike that of calculateMixability, is
+/// **NOT** symmetric.
+static MixData
+approximateImplicitConversion(const TheCheck &Check, QualType LType,
+                              QualType RType, const ASTContext &Ctx,
+                              ImplicitConversionModellingMode ImplicitMode) {
+  LLVM_DEBUG(llvm::dbgs() << ">>> approximateImplicitConversion for LType:\n";
+             LType.dump(llvm::dbgs(), Ctx); llvm::dbgs() << "\nand RType:\n";
+             RType.dump(llvm::dbgs(), Ctx);
+             llvm::dbgs() << "\nimplicit mode: " << ImplicitMode << '\n';);
+  if (LType == RType)
+    return {MixFlags::Trivial, LType};
+
+  // An implicit conversion sequence consists of the following, in order:
+  //  * Maybe standard conversion sequence.
+  //  * Maybe user-defined conversion.
+  //  * Maybe standard conversion sequence.
+  ConversionSequence ImplicitSeq{LType, RType};
+  QualType WorkType = LType;
+
+  Optional<QualType> AfterFirstStdConv =
+      approximateStandardConversionSequence(Check, LType, RType, Ctx);
+  if (AfterFirstStdConv) {
+    LLVM_DEBUG(llvm::dbgs() << "--- approximateImplicitConversion. Standard "
+                               "Pre-Conversion found!\n");
+    ImplicitSeq.AfterFirstStandard = AfterFirstStdConv.getValue();
+    WorkType = ImplicitSeq.AfterFirstStandard;
+  }
+
+  if (ImplicitMode == ICMM_OneWaySingleStandardOnly)
+    // If the caller only requested modelling of a standard conversion, bail.
+    return {ImplicitSeq.AfterFirstStandard.isNull()
+                ? MixFlags::None
+                : MixFlags::ImplicitConversion,
+            ImplicitSeq};
+
+  if (Ctx.getLangOpts().CPlusPlus) {
+    bool FoundConversionOperator = false, FoundConvertingCtor = false;
+
+    if (const auto *LRD = WorkType->getAsCXXRecordDecl()) {
+      Optional<ConversionSequence> ConversionOperatorResult =
+          tryConversionOperators(Check, LRD, RType);
+      if (ConversionOperatorResult) {
+        LLVM_DEBUG(llvm::dbgs() << "--- approximateImplicitConversion. Found "
+                                   "conversion operator.\n");
+        ImplicitSeq.update(ConversionOperatorResult.getValue());
+        WorkType = ImplicitSeq.getTypeAfterUserDefinedConversion();
+        FoundConversionOperator = true;
+      }
+    }
+
+    if (const auto *RRD = RType->getAsCXXRecordDecl()) {
+      // Use the original "LType" here, and not WorkType, because the
+      // conversion to the converting constructors' parameters will be
+      // modelled in the recursive call.
+      Optional<ConversionSequence> ConvCtorResult =
+          tryConvertingConstructors(Check, LType, RRD);
+      if (ConvCtorResult) {
+        LLVM_DEBUG(llvm::dbgs() << "--- approximateImplicitConversion. Found "
+                                   "converting constructor.\n");
+        ImplicitSeq.update(ConvCtorResult.getValue());
+        WorkType = ImplicitSeq.getTypeAfterUserDefinedConversion();
+        FoundConvertingCtor = true;
+      }
+    }
+
+    if (FoundConversionOperator && FoundConvertingCtor) {
+      // If both an operator and a ctor matches, the sequence is ambiguous.
+      LLVM_DEBUG(llvm::dbgs()
+                 << "<<< approximateImplicitConversion. Found both "
+                    "user-defined conversion kinds in the same sequence!\n");
+      return {MixFlags::None};
+    }
+  }
+
+  // After the potential user-defined conversion, another standard conversion
+  // sequence might exist.
+  LLVM_DEBUG(
+      llvm::dbgs()
+      << "--- approximateImplicitConversion. Try to find post-conversion.\n");
+  MixData SecondStdConv = approximateImplicitConversion(
+      Check, WorkType, RType, Ctx, ICMM_OneWaySingleStandardOnly);
+  if (SecondStdConv.indicatesMixability()) {
+    LLVM_DEBUG(llvm::dbgs() << "--- approximateImplicitConversion. Standard "
+                               "Post-Conversion found!\n");
+
+    // The single-step modelling puts the modelled conversion into the "PreStd"
+    // variable in the recursive call, but from the PoV of this function, it is
+    // the post-conversion.
+    ImplicitSeq.AfterSecondStandard =
+        SecondStdConv.Conversion.AfterFirstStandard;
+    WorkType = ImplicitSeq.AfterSecondStandard;
+  }
+
+  if (ImplicitSeq) {
+    LLVM_DEBUG(llvm::dbgs()
+               << "<<< approximateImplicitConversion. Found a conversion.\n");
+    return {MixFlags::ImplicitConversion, ImplicitSeq};
+  }
+
+  LLVM_DEBUG(
+      llvm::dbgs() << "<<< approximateImplicitConversion. No match found.\n");
+  return {MixFlags::None};
 }
 
 static MixableParameterRange modelMixingRange(const TheCheck &Check,
                                               const FunctionDecl *FD,
                                               std::size_t StartIndex) {
   std::size_t NumParams = FD->getNumParams();
   assert(StartIndex < NumParams && "out of bounds for start");
   const ASTContext &Ctx = FD->getASTContext();
for (std::size_t I = StartIndex + 1; I < NumParams; ++I) {
     // parameters that can be messed up at a call site.
     MixableParameterRange::MixVector MixesOfIth;
     for (std::size_t J = StartIndex; J < I; ++J) {
       const ParmVarDecl *Jth = FD->getParamDecl(J);
       LLVM_DEBUG(llvm::dbgs()
                  << "Check mix of #" << J << " against #" << I << "...\n");
 
       Mix M{Jth, Ith,
-            calculateMixability(Check, Jth->getType(), Ith->getType(), Ctx)};
+            calculateMixability(Check, Jth->getType(), Ith->getType(), Ctx,
+                                Check.ModelImplicitConversions ? ICMM_All
+                                                               : ICMM_None)};
       LLVM_DEBUG(llvm::dbgs() << "Mix flags (raw)           : "
                               << formatMixFlags(M.flags()) << '\n');
       M.sanitize();
       LLVM_DEBUG(llvm::dbgs() << "Mix flags (after sanitize): "
                               << formatMixFlags(M.flags()) << '\n');
 
-      assert(M.flags() != MixFlags::Invalid && "All flags decayed!");
+      assert(M.flagsValid() && "All flags decayed!");
 
-      if (M.flags() != MixFlags::None)
+      if (M.mixable())
         MixesOfIth.emplace_back(std::move(M));
     }
 
     if (MixesOfIth.empty()) {
       // If there weren't any new mixes stored for Ith, the range is
       // [Start, ..., I].
       LLVM_DEBUG(llvm::dbgs()
                  << "Param #" << I

 /// types involved diagnosed to the user. This is only a flag check.
 static inline bool needsToPrintTypeInDiagnostic(const model::Mix &M) {
   using namespace model;
   return static_cast<bool>(
       M.flags() &
       (MixFlags::TypeAlias | MixFlags::ReferenceBind | MixFlags::Qualifiers));
 }
 
+/// Returns whether a particular Mix between the two parameters should have
+/// implicit conversions elaborated.
+static inline bool needsToElaborateImplicitConversion(const model::Mix &M) {
+  return hasFlag(M.flags(), model::MixFlags::ImplicitConversion);
+}
+
 namespace {
 
+/// This class formats a conversion sequence into a "Ty1 -> Ty2 -> Ty3" line
+/// that can be used in diagnostics.
+struct FormattedConversionSequence {
+  std::string DiagnosticText;
+
+  /// The formatted sequence is trivial if it is "Ty1 -> Ty2", but Ty1 and
+  /// Ty2 are the types that are shown in the code. A trivial diagnostic
+  /// does not need to be printed.
+  bool Trivial;
+
+  FormattedConversionSequence(const PrintingPolicy &PP,
+                              StringRef StartTypeAsDiagnosed,
+                              const model::ConversionSequence &Conv,
+                              StringRef DestinationTypeAsDiagnosed) {
+    Trivial = true;
+    llvm::raw_string_ostream OS{DiagnosticText};
+
+    // Print the type name as it is printed in other places in the diagnostic.
+    OS << '\'' << StartTypeAsDiagnosed << '\'';
+    std::string LastAddedType = StartTypeAsDiagnosed.str();
+    std::size_t NumElementsAdded = 1;
+
+    // However, the parameter's defined type might not be what the implicit
+    // conversion started with, e.g. if a typedef is found to convert.
+    std::string SeqBeginTypeStr = Conv.Begin.getAsString(PP);
+    std::string SeqEndTypeStr = Conv.End.getAsString(PP);
+    if (StartTypeAsDiagnosed != SeqBeginTypeStr) {
+      OS << " (as '" << SeqBeginTypeStr << "')";
+      LastAddedType = SeqBeginTypeStr;
+      Trivial = false;
+    }
+
+    auto AddType = [&](StringRef ToAdd) {
+      if (LastAddedType != ToAdd && ToAdd != SeqEndTypeStr) {
+        OS << " -> '" << ToAdd << "'";
+        LastAddedType = ToAdd.str();
+        ++NumElementsAdded;
+      }
+    };
+    for (QualType InvolvedType : Conv.getInvolvedTypesInSequence())
+      // Print every type that's unique in the sequence into the diagnosis.
+      AddType(InvolvedType.getAsString(PP));
+
+    if (LastAddedType != DestinationTypeAsDiagnosed) {
+      OS << " -> '" << DestinationTypeAsDiagnosed << "'";
+      LastAddedType = DestinationTypeAsDiagnosed.str();
+      ++NumElementsAdded;
+    }
+
+    // Same reasoning as with the Begin, e.g. if the converted-to type is a
+    // typedef, it will not be the same inside the conversion sequence (where
+    // the model already tore off typedefs) as in the code.
+    if (DestinationTypeAsDiagnosed != SeqEndTypeStr) {
+      OS << " (as '" << SeqEndTypeStr << "')";
+      LastAddedType = SeqEndTypeStr;
+      Trivial = false;
+    }
+
+    if (Trivial && NumElementsAdded > 2)
+      // If the thing is still marked trivial but we have more than the
+      // from and to types added, it should not be trivial, and elaborated
+      // when printing the diagnostic.
+      Trivial = false;
+  }
+};
+
 /// Retains the elements called with and returns whether the call is done with
 /// a new element.
 template <typename E, std::size_t N> class InsertOnce {
   llvm::SmallSet<E, N> CalledWith;
 
 public:
   bool operator()(E El) { return CalledWith.insert(std::move(El)).second; }
 
EasilySwappableParametersCheck::EasilySwappableParametersCheck(
     : ClangTidyCheck(Name, Context),
       MinimumLength(clampMinimumLength(
           Options.get("MinimumLength", DefaultMinimumLength))),
       IgnoredParameterNames(optutils::parseStringList(
           Options.get("IgnoredParameterNames", DefaultIgnoredParameterNames))),
       IgnoredParameterTypeSuffixes(optutils::parseStringList(
           Options.get("IgnoredParameterTypeSuffixes",
                       DefaultIgnoredParameterTypeSuffixes))),
-      QualifiersMix(Options.get("QualifiersMix", DefaultQualifiersMix)) {}
+      QualifiersMix(Options.get("QualifiersMix", DefaultQualifiersMix)),
+      ModelImplicitConversions(Options.get("ModelImplicitConversions",
+                                           DefaultModelImplicitConversions)) {}
 
 void EasilySwappableParametersCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "MinimumLength", MinimumLength);
   Options.store(Opts, "IgnoredParameterNames",
                 optutils::serializeStringList(IgnoredParameterNames));
   Options.store(Opts, "IgnoredParameterTypeSuffixes",
                 optutils::serializeStringList(IgnoredParameterTypeSuffixes));
   Options.store(Opts, "QualifiersMix", QualifiersMix);
+  Options.store(Opts, "ModelImplicitConversions", ModelImplicitConversions);
 }
 
 void EasilySwappableParametersCheck::registerMatchers(MatchFinder *Finder) {
   const auto BaseConstraints = functionDecl(
       // Only report for definition nodes, as fixing the issues reported
       // requires the user to be able to change code.
       isDefinition(), parameterCountGE(MinimumLength),
       unless(isOverloadedUnaryOrBinaryOperator()));
while (MixableRangeStartIndex < NumParams) {
     MixableRangeStartIndex += R.NumParamsChecked;
     if (R.NumParamsChecked < MinimumLength) {
       LLVM_DEBUG(llvm::dbgs() << "Ignoring range of " << R.NumParamsChecked
                               << " lower than limit.\n");
       continue;
     }
 
     bool NeedsAnyTypeNote = llvm::any_of(R.Mixes, needsToPrintTypeInDiagnostic);
+    bool HasAnyImplicits =
+        llvm::any_of(R.Mixes, needsToElaborateImplicitConversion);
     const ParmVarDecl *First = R.getFirstParam(), *Last = R.getLastParam();
     std::string FirstParamTypeAsWritten = First->getType().getAsString(PP);
     {
       StringRef DiagText;
 
-      if (NeedsAnyTypeNote)
+      if (HasAnyImplicits)
+        DiagText = "%0 adjacent parameters of %1 of convertible types are "
+                   "easily swapped by mistake";
+      else if (NeedsAnyTypeNote)
         DiagText = "%0 adjacent parameters of %1 of similar type are easily "
                    "swapped by mistake";
       else
         DiagText = "%0 adjacent parameters of %1 of similar type ('%2') are "
                    "easily swapped by mistake";
 
       auto Diag = diag(First->getOuterLocStart(), DiagText)
                   << static_cast<unsigned>(R.NumParamsChecked) << FD;
diag(Last->getLocation(), "the last parameter in the range is '%0'",
         << getNameOrUnnamed(Last)
         << CharSourceRange::getTokenRange(Last->getLocation(),
                                           Last->getLocation());
 
     // Helper classes to silence elaborative diagnostic notes that would be
     // too verbose.
     UniqueTypeAliasDiagnosticHelper UniqueTypeAlias;
     InsertOnce<SwappedEqualQualTypePair, 8> UniqueBindPower;
+    InsertOnce<SwappedEqualQualTypePair, 8> UniqueImplicitConversion;
 
-    for (const Mix &M : R.Mixes) {
-      assert(M.flags() >= MixFlags::Trivial &&
-             "Sentinel or false mix in result.");
+    for (const model::Mix &M : R.Mixes) {
+      assert(M.mixable() && "Sentinel or false mix in result.");
+      if (!needsToPrintTypeInDiagnostic(M) &&
+          !needsToElaborateImplicitConversion(M))
+        continue;
 
-      if (needsToPrintTypeInDiagnostic(M)) {
-        // Typedefs might result in the type of the variable needing to be
-        // emitted to a note diagnostic, so prepare it.
-        const ParmVarDecl *LVar = M.First;
-        const ParmVarDecl *RVar = M.Second;
-        QualType LType = LVar->getType();
-        QualType RType = RVar->getType();
-        QualType CommonType = M.commonUnderlyingType();
-        std::string LTypeStr = LType.getAsString(PP);
-        std::string RTypeStr = RType.getAsString(PP);
-        std::string CommonTypeStr = CommonType.getAsString(PP);
 
-        if (hasFlag(M.flags(), MixFlags::TypeAlias) &&
-            UniqueTypeAlias(LType, RType, CommonType)) {
-          StringRef DiagText;
-          bool ExplicitlyPrintCommonType = false;
-          if (LTypeStr == CommonTypeStr || RTypeStr == CommonTypeStr)
-            if (hasFlag(M.flags(), MixFlags::Qualifiers))
-              DiagText = "after resolving type aliases, '%0' and '%1' share a "
-                         "common type";
-            else
-              DiagText =
-                  "after resolving type aliases, '%0' and '%1' are the same";
-          else {
-            DiagText = "after resolving type aliases, the common type of '%0' "
-                       "and '%1' is '%2'";
-            ExplicitlyPrintCommonType = true;
-          }
+        else if (!CommonType.isNull()) {
 
-          auto Diag =
-              diag(LVar->getOuterLocStart(), DiagText, DiagnosticIDs::Note)
-              << LTypeStr << RTypeStr;
-          if (ExplicitlyPrintCommonType)
-            Diag << CommonTypeStr;
-        }
 
-        if ((hasFlag(M.flags(), MixFlags::ReferenceBind) ||
-             hasFlag(M.flags(), MixFlags::Qualifiers)) &&
-            UniqueBindPower({LType, RType})) {
-          StringRef DiagText = "'%0' and '%1' parameters accept and bind the "
-                               "same kind of values";
-          diag(RVar->getOuterLocStart(), DiagText, DiagnosticIDs::Note)
-              << LTypeStr << RTypeStr;
-        }
+
+      if (needsToElaborateImplicitConversion(M) &&
+          UniqueImplicitConversion({LType, RType})) {
+        const model::ConversionSequence &LTR =
+            M.leftToRightConversionSequence();
+        const model::ConversionSequence &RTL =
+            M.rightToLeftConversionSequence();
+        FormattedConversionSequence LTRFmt{PP, LTypeStr, LTR, RTypeStr};
+        FormattedConversionSequence RTLFmt{PP, RTypeStr, RTL, LTypeStr};
+
+        StringRef DiagText = "'%0' and '%1' may be implicitly converted";
+        if (!LTRFmt.Trivial || !RTLFmt.Trivial)
+          DiagText = "'%0' and '%1' may be implicitly converted: %2, %3";
+
+        {
+          auto Diag =
+              diag(RVar->getOuterLocStart(), DiagText, DiagnosticIDs::Note)
+              << LTypeStr << RTypeStr;
+
+          if (!LTRFmt.Trivial || !RTLFmt.Trivial)
+            Diag << LTRFmt.DiagnosticText << RTLFmt.DiagnosticText;
+        }
+
+        StringRef ConversionFunctionDiagText =
+            "the implicit conversion involves the "
+            "%select{|converting constructor|conversion operator}0 "
+            "declared here";
+        if (const FunctionDecl *LFD = LTR.getUserDefinedConversionFunction())
+          diag(LFD->getLocation(), ConversionFunctionDiagText,
+               DiagnosticIDs::Note)
+              << static_cast<unsigned>(LTR.UDConvKind)
+              << LTR.getUserDefinedConversionHighlight();
+        if (const FunctionDecl *RFD = RTL.getUserDefinedConversionFunction())
+          diag(RFD->getLocation(), ConversionFunctionDiagText,
+               DiagnosticIDs::Note)
+              << static_cast<unsigned>(RTL.UDConvKind)
+              << RTL.getUserDefinedConversionHighlight();
       }
     }
   }
 }
 
 } // namespace bugprone
 } // namespace tidy
 } // namespace clang

clang-tools-extra/docs/clang-tidy/checks/bugprone-easily-swappable-parameters.rst

.. option:: QualifiersMix
     `True` turns the warnings on.
     Defaults to `false`.
 
     The following example produces a diagnostic only if `QualifiersMix` is
     enabled:
 
     .. code-block:: c++
 
-        void *memcpy(const void *Destination, void *Source, std::size_t N) {}
+        void *memcpy(const void *Destination, void *Source, std::size_t N) { /* ... */ }
 
+.. option:: ModelImplicitConversions
+
+    Whether to consider parameters of type ``T`` and ``U`` mixable if there
+    exists an implicit conversion from ``T`` to ``U`` and ``U`` to ``T``.
+    If `false`, the check will not consider implicitly convertible types for
+    mixability.
+    `True` turns warnings for implicit conversions on.
+    Defaults to `true`.
+
+    The following examples produce a diagnostic only if
+    `ModelImplicitConversions` is enabled:
+
+    .. code-block:: c++
+
+        void fun(int Int, double Double) { /* ... */ }
+        void compare(const char *CharBuf, std::string String) { /* ... */ }
+
+    .. note::
+
+        Changing the qualifiers of an expression's type (e.g. from ``int`` to
+        ``const int``) is defined as an *implicit conversion* in the C++
+        Standard.
+        However, the check separates this decision-making on the mixability of
+        differently qualified types based on whether `QualifiersMix` was
+        enabled.
+
+        For example, the following code snippet will only produce a diagnostic
+        if **both** `QualifiersMix` and `ModelImplicitConversions` are enabled:
+
+        .. code-block:: c++
+
+            void fun2(int Int, const double Double) { /* ... */ }
 
 Filtering options
 ^^^^^^^^^^^^^^^^^
 
 Filtering options can be used to lessen the size of the diagnostics emitted by
 the checker, whether the aim is to ignore certain constructs or dampen the
 noisiness.
 

 .. code-block:: c++
 
     int printf(const char *Format, ...) { /* ... */ }
     int someOldCFunction() { /* ... */ }
 
     template <typename T, typename U>
     int add(T X, U Y) { return X + Y };
 
-    void TheseAreNotWarnedAbout() {
+    void theseAreNotWarnedAbout() {
         printf("%d %d\n", 1, 2);   // Two ints passed, they could be swapped.
         someOldCFunction(1, 2, 3); // Similarly, multiple ints passed.
 
         add(1, 2); // Instantiates 'add<int, int>', but that's not a user-defined function.
     }
 
 Due to the limitation above, parameters which type are further dependent upon
 template instantiations to *prove* that they mix with another parameter's is
 not diagnosed.
 
 .. code-block:: c++
 
     template <typename T>
     struct Vector {
       typedef T element_type;
     };
 
     // Diagnosed: Explicit instantiation was done by the user, we can prove it
     // is the same type.
-    void Explicit(int A, Vector<int>::element_type B) { /* ... */ }
+    void instantiated(int A, Vector<int>::element_type B) { /* ... */ }
 
     // Diagnosed: The two parameter types are exactly the same.
     template <typename T>
-    void Exact(typename Vector<T>::element_type A,
+    void exact(typename Vector<T>::element_type A,
                typename Vector<T>::element_type B) { /* ... */ }
 
     // Skipped: The two parameters are both 'T' but we can not prove this
     // without actually instantiating.
     template <typename T>
-    void FalseNegative(T A, typename Vector<T>::element_type B) { /* ... */ }
+    void falseNegative(T A, typename Vector<T>::element_type B) { /* ... */ }
+
+In the context of *implicit conversions* (when `ModelImplicitConversions` is
+enabled), the modelling performed by the check
+warns if the parameters are swappable and the swapped order matches implicit
+conversions.
+It does not model whether there exists an unrelated third type from which
+*both* parameters can be given in a function call.
+This means that in the following example, even while ``strs()`` clearly carries
+the possibility to be called with swapped arguments (as long as the arguments
+are string literals), will not be warned about.
+
+.. code-block:: c++
+
+    struct String {
+        String(const char *Buf);
+    };
+
+    struct StringView {
+        StringView(const char *Buf);
+        operator const char *() const;
+    };
+
+    // Skipped: Directly swapping expressions of the two type cannot mix.
+    // (Note: StringView -> const char * -> String would be **two**
+    // user-defined conversions, which is disallowed by the language.)
+    void strs(String Str, StringView SV) { /* ... */ }
+
+    // Diagnosed: StringView implicitly converts to and from a buffer.
+    void cStr(StringView SV, const char *Buf() { /* ... */ }

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

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: "\"\";Foo;Bar"}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "T"}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0} \
 // RUN:  ]}' --
 
 void ignoredUnnamed(int I, int, int) {} // NO-WARN: No >= 2 length of non-unnamed.
 
 void nothingIgnored(int I, int J) {}
 // CHECK-MESSAGES: :[[@LINE-1]]:21: warning: 2 adjacent parameters of 'nothingIgnored' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:25: note: the first parameter in the range is 'I'
 // CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'J'

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

+// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 1}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1} \
+// RUN:  ]}' --
+
+void numericAndQualifierConversion(int I, const double CD) { numericAndQualifierConversion(CD, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'numericAndQualifierConversion' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
+// CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:56: note: the last parameter in the range is 'CD'
+// CHECK-MESSAGES: :[[@LINE-4]]:43: note: 'int' and 'const double' parameters accept and bind the same kind of values
+// CHECK-MESSAGES: :[[@LINE-5]]:43: note: 'int' and 'const double' may be implicitly converted: 'int' -> 'const double' (as 'double'), 'const double' (as 'double') -> 'int'

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

+// RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1} \
+// RUN:  ]}' --
+
+void implicitDoesntBreakOtherStuff(int A, int B) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
+// CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A'
+// CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B'
+
+void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); }
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr1' of similar type ('int *')
+// CHECK-MESSAGES: :[[@LINE-2]]:24: note: the first parameter in the range is 'IP'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'IA'
+
+void arrayAndPtr2(int *IP, int IA[8]) { arrayAndPtr2(IA, IP); }
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr2' of similar type ('int *')
+// CHECK-MESSAGES: :[[@LINE-2]]:24: note: the first parameter in the range is 'IP'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'IA'
+
+void arrayAndElement(int I, int IA[]) {} // NO-WARN.
+
+void numericConversion1(int I, double D) { numericConversion1(D, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion1' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
+// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:39: note: the last parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'double' may be implicitly converted{{$}}
+
+void numericConversion2(int I, short S) { numericConversion2(S, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion2' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:38: note: the last parameter in the range is 'S'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'short' may be implicitly converted{{$}}
+
+void numericConversion3(float F, unsigned long UL) { numericConversion3(UL, F); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion3' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:31: note: the first parameter in the range is 'F'
+// CHECK-MESSAGES: :[[@LINE-3]]:48: note: the last parameter in the range is 'UL'
+// CHECK-MESSAGES: :[[@LINE-4]]:34: note: 'float' and 'unsigned long' may be implicitly converted{{$}}
+
+enum Unscoped { U_A,
+                U_B };
+enum UnscopedFixed : char { UF_A,
+                            UF_B };
+
+void numericConversion4(int I, enum Unscoped U) { numericConversion4(U, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion4' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:46: note: the last parameter in the range is 'U'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'enum Unscoped' may be implicitly converted{{$}}
+
+void numericConversion5(int I, enum UnscopedFixed UF) { numericConversion5(UF, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion5' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:51: note: the last parameter in the range is 'UF'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'enum UnscopedFixed' may be implicitly converted{{$}}
+
+void numericConversion7(double D, enum Unscoped U) { numericConversion7(U, D); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion7' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:32: note: the first parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-3]]:49: note: the last parameter in the range is 'U'
+// CHECK-MESSAGES: :[[@LINE-4]]:35: note: 'double' and 'enum Unscoped' may be implicitly converted{{$}}
+
+void numericConversion8(double D, enum UnscopedFixed UF) { numericConversion8(UF, D); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion8' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:32: note: the first parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-3]]:54: note: the last parameter in the range is 'UF'
+// CHECK-MESSAGES: :[[@LINE-4]]:35: note: 'double' and 'enum UnscopedFixed' may be implicitly converted{{$}}
+
+void pointeeConverison(int *IP, double *DP) { pointeeConversion(DP, IP); }
+// NO-WARN: Even though this is possible in C, a swap is diagnosed by the compiler.

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

+// RUN: %check_clang_tidy -std=c++17 %s bugprone-easily-swappable-parameters %t \
+// RUN:   -config='{CheckOptions: [ \
+// RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 1} \
+// RUN:  ]}' --
+
+void implicitDoesntBreakOtherStuff(int A, int B) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:36: warning: 2 adjacent parameters of 'implicitDoesntBreakOtherStuff' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
+// CHECK-MESSAGES: :[[@LINE-2]]:40: note: the first parameter in the range is 'A'
+// CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'B'
+
+void arrayAndPtr1(int *IP, int IA[]) { arrayAndPtr1(IA, IP); }
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr1' of similar type ('int *')
+// CHECK-MESSAGES: :[[@LINE-2]]:24: note: the first parameter in the range is 'IP'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'IA'
+
+void arrayAndPtr2(int *IP, int IA[8]) { arrayAndPtr2(IA, IP); }
+// CHECK-MESSAGES: :[[@LINE-1]]:19: warning: 2 adjacent parameters of 'arrayAndPtr2' of similar type ('int *')
+// CHECK-MESSAGES: :[[@LINE-2]]:24: note: the first parameter in the range is 'IP'
+// CHECK-MESSAGES: :[[@LINE-3]]:32: note: the last parameter in the range is 'IA'
+
+void arrayAndElement(int I, int IA[]) {} // NO-WARN.
+
+void numericConversion1(int I, double D) { numericConversion1(D, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion1' of convertible types are easily swapped by mistake [bugprone-easily-swappable-parameters]
+// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:39: note: the last parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'double' may be implicitly converted{{$}}
+
+void numericConversion2(int I, short S) { numericConversion2(S, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion2' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:29: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:38: note: the last parameter in the range is 'S'
+// CHECK-MESSAGES: :[[@LINE-4]]:32: note: 'int' and 'short' may be implicitly converted{{$}}
+
+void numericConversion3(float F, unsigned long long ULL) { numericConversion3(ULL, F); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'numericConversion3' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:31: note: the first parameter in the range is 'F'
+// CHECK-MESSAGES: :[[@LINE-3]]:53: note: the last parameter in the range is 'ULL'
+// CHECK-MESSAGES: :[[@LINE-4]]:34: note: 'float' and 'unsigned long long' may be implicitly converted{{$}}
+
+enum Unscoped { U_A,
+                U_B };
+enum UnscopedFixed : char { UF_A,
+                            UF_B };
+enum struct Scoped { A,
+                     B };
+
+void numericConversion4(int I, Unscoped U) {} // NO-WARN.
+
+void numericConversion5(int I, UnscopedFixed UF) {} // NO-WARN.
+
+void numericConversion6(int I, Scoped S) {} // NO-WARN.
+
+void numericConversion7(double D, Unscoped U) {} // NO-WARN.
+
+void numericConversion8(double D, UnscopedFixed UF) {} // NO-WARN.
+
+void numericConversion9(double D, Scoped S) {} // NO-WARN.
+
+void numericConversionMultiUnique(int I, double D1, double D2) {}
+// CHECK-MESSAGES: :[[@LINE-1]]:35: warning: 3 adjacent parameters of 'numericConversionMultiUnique' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:39: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:60: note: the last parameter in the range is 'D2'
+// CHECK-MESSAGES: :[[@LINE-4]]:42: note: 'int' and 'double' may be implicitly converted{{$}}
+// (Note: int<->double conversion for I<->D2 not diagnosed again.)
+
+typedef int MyInt;
+using MyDouble = double;
+
+void numericConversion10(MyInt MI, MyDouble MD) { numericConversion10(MD, MI); }
+// CHECK-MESSAGES: :[[@LINE-1]]:26: warning: 2 adjacent parameters of 'numericConversion10' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:32: note: the first parameter in the range is 'MI'
+// CHECK-MESSAGES: :[[@LINE-3]]:45: note: the last parameter in the range is 'MD'
+// CHECK-MESSAGES: :[[@LINE-4]]:36: note: 'MyInt' and 'MyDouble' may be implicitly converted: 'MyInt' (as 'int') -> 'MyDouble' (as 'double'), 'MyDouble' (as 'double') -> 'MyInt' (as 'int')
+
+void numericAndQualifierConversion(int I, const double CD) { numericAndQualifierConversion(CD, I); }
+// NO-WARN: Qualifier mixing is handled by a different check option.
+
+struct FromInt {
+  FromInt(int);
+};
+
+void oneWayConversion1(int I, FromInt FI) {} // NO-WARN: One-way.
+
+struct AmbiguousConvCtor {
+  AmbiguousConvCtor(int);
+  AmbiguousConvCtor(double);
+};
+
+void ambiguous1(long L, AmbiguousConvCtor ACC) {} // NO-WARN: Ambiguous, one-way.
+
+struct ToInt {
+  operator int() const;
+};
+
+void oneWayConversion2(ToInt TI, int I) {} // NO-WARN: One-way.
+
+struct AmbiguousConvOp {
+  operator int() const;
+  operator double() const;
+};
+
+void ambiguous2(AmbiguousConvOp ACO, long L) {} // NO-WARN: Ambiguous, one-way.
+
+struct AmbiguousEverything1;
+struct AmbiguousEverything2;
+struct AmbiguousEverything1 {
+  AmbiguousEverything1();
+  AmbiguousEverything1(AmbiguousEverything2);
+  operator AmbiguousEverything2() const;
+};
+struct AmbiguousEverything2 {
+  AmbiguousEverything2();
+  AmbiguousEverything2(AmbiguousEverything1);
+  operator AmbiguousEverything1() const;
+};
+
+void ambiguous3(AmbiguousEverything1 AE1, AmbiguousEverything2 AE2) {} // NO-WARN: Ambiguous.
+
+struct Integer {
+  Integer(int);
+  operator int() const;
+};
+
+void userDefinedConversion1(int I1, Integer I2) { userDefinedConversion1(I2, I1); }
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters of 'userDefinedConversion1' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:33: note: the first parameter in the range is 'I1'
+// CHECK-MESSAGES: :[[@LINE-3]]:45: note: the last parameter in the range is 'I2'
+// CHECK-MESSAGES: :[[@LINE-4]]:37: note: 'int' and 'Integer' may be implicitly converted{{$}}
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the conversion operator declared here
+
+struct Ambiguous {
+  Ambiguous(int);
+  Ambiguous(double);
+  operator long() const;
+  operator float() const;
+};
+
+void ambiguous3(char C, Ambiguous A) {} // NO-WARN: Ambiguous.
+
+struct CDouble {
+  CDouble(const double &);
+  operator const double &() const;
+};
+
+void userDefinedConversion2(double D, CDouble CD) { userDefinedConversion2(CD, D); }
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters of 'userDefinedConversion2' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:36: note: the first parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-3]]:47: note: the last parameter in the range is 'CD'
+// CHECK-MESSAGES: :[[@LINE-4]]:39: note: 'double' and 'CDouble' may be implicitly converted: 'double' -> 'const double &' -> 'CDouble', 'CDouble' -> 'const double &' -> 'double'
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the conversion operator declared here
+
+void userDefinedConversion3(int I, CDouble CD) { userDefinedConversion3(CD, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters of 'userDefinedConversion3' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:33: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:44: note: the last parameter in the range is 'CD'
+// CHECK-MESSAGES: :[[@LINE-4]]:36: note: 'int' and 'CDouble' may be implicitly converted: 'int' -> 'double' -> 'const double &' -> 'CDouble', 'CDouble' -> 'const double &' -> 'int'
+// CHECK-MESSAGES: :[[@LINE-17]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-17]]:3: note: the implicit conversion involves the conversion operator declared here
+
+struct TDInt {
+  TDInt(const MyInt &);
+  operator MyInt() const;
+};
+
+void userDefinedConversion4(int I, TDInt TDI) { userDefinedConversion4(TDI, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters of 'userDefinedConversion4' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:33: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:42: note: the last parameter in the range is 'TDI'
+// CHECK-MESSAGES: :[[@LINE-4]]:36: note: 'int' and 'TDInt' may be implicitly converted: 'int' -> 'const MyInt &' -> 'TDInt', 'TDInt' -> 'MyInt' -> 'int'
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the conversion operator declared here
+
+struct TDIntDouble {
+  TDIntDouble(const MyInt &);
+  TDIntDouble(const MyDouble &);
+  operator MyInt() const;
+  operator MyDouble() const;
+};
+
+void userDefinedConversion5(int I, TDIntDouble TDID) { userDefinedConversion5(TDID, I); }
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters of 'userDefinedConversion5' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:33: note: the first parameter in the range is 'I'
+// CHECK-MESSAGES: :[[@LINE-3]]:48: note: the last parameter in the range is 'TDID'
+// CHECK-MESSAGES: :[[@LINE-4]]:36: note: 'int' and 'TDIntDouble' may be implicitly converted: 'int' -> 'const MyInt &' -> 'TDIntDouble', 'TDIntDouble' -> 'MyInt' -> 'int'
+// CHECK-MESSAGES: :[[@LINE-11]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-10]]:3: note: the implicit conversion involves the conversion operator declared here
+
+void userDefinedConversion6(double D, TDIntDouble TDID) { userDefinedConversion6(TDID, D); }
+// CHECK-MESSAGES: :[[@LINE-1]]:29: warning: 2 adjacent parameters of 'userDefinedConversion6' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:36: note: the first parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-3]]:51: note: the last parameter in the range is 'TDID'
+// CHECK-MESSAGES: :[[@LINE-4]]:39: note: 'double' and 'TDIntDouble' may be implicitly converted: 'double' -> 'const MyDouble &' -> 'TDIntDouble', 'TDIntDouble' -> 'MyDouble' -> 'double'
+// CHECK-MESSAGES: :[[@LINE-18]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-17]]:3: note: the implicit conversion involves the conversion operator declared here
+
+void userDefinedConversion7(char C, TDIntDouble TDID) {} // NO-WARN: Ambiguous.
+
+struct Forward1;
+struct Forward2;
+
+void incomplete(Forward1 *F1, Forward2 *F2) {} // NO-WARN: Do not compare incomplete types.
+
+void pointeeConverison(int *IP, double *DP) {} // NO-WARN.
+
+void pointerConversion1(void *VP, int *IP) {} // NO-WARN: One-way.
+
+struct PointerBox {
+  PointerBox(void *);
+  operator int *() const;
+};
+
+void pointerConversion2(PointerBox PB, int *IP) { pointerConversion2(IP, PB); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'pointerConversion2' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:36: note: the first parameter in the range is 'PB'
+// CHECK-MESSAGES: :[[@LINE-3]]:45: note: the last parameter in the range is 'IP'
+// CHECK-MESSAGES: :[[@LINE-4]]:40: note: 'PointerBox' and 'int *' may be implicitly converted: 'PointerBox' -> 'int *', 'int *' -> 'void *' -> 'PointerBox'
+// CHECK-MESSAGES: :[[@LINE-8]]:3: note: the implicit conversion involves the conversion operator declared here
+// CHECK-MESSAGES: :[[@LINE-10]]:3: note: the implicit conversion involves the converting constructor declared here
+
+void pointerConversion3(PointerBox PB, double *DP) {} // NO-WARN: Not convertible.
+
+struct Base {};
+struct Derived : Base {};
+
+void pointerConversion4(Base *BP, Derived *DP) {} // NO-WARN: One-way.
+
+struct BaseAndDerivedInverter {
+  BaseAndDerivedInverter(Base); // Takes a Base
+  operator Derived() const;     // and becomes a Derived.
+};
+
+void pointerConversion5(BaseAndDerivedInverter BADI, Derived D) { pointerConversion5(D, BADI); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'pointerConversion5' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:48: note: the first parameter in the range is 'BADI'
+// CHECK-MESSAGES: :[[@LINE-3]]:62: note: the last parameter in the range is 'D'
+// CHECK-MESSAGES: :[[@LINE-4]]:54: note: 'BaseAndDerivedInverter' and 'Derived' may be implicitly converted: 'BaseAndDerivedInverter' -> 'Derived', 'Derived' -> 'Base' -> 'BaseAndDerivedInverter'
+// CHECK-MESSAGES: :[[@LINE-8]]:3: note: the implicit conversion involves the conversion operator declared here
+// CHECK-MESSAGES: :[[@LINE-10]]:3: note: the implicit conversion involves the converting constructor declared here
+
+void pointerConversion6(void (*NTF)() noexcept, void (*TF)()) {}
+// NO-WARN: This call cannot be swapped, even if "getCanonicalType()" believes otherwise.
+
+using NonThrowingFunction = void (*)() noexcept;
+
+struct NoexceptMaker {
+  NoexceptMaker(void (*ThrowingFunction)());
+  // Need to use a typedef here because
+  // "conversion function cannot convert to a function type".
+  // operator (void (*)() noexcept) () const;
+  operator NonThrowingFunction() const;
+};
+
+void pointerConversion7(void (*NTF)() noexcept, NoexceptMaker NM) { pointerConversion7(NM, NTF); }
+// CHECK-MESSAGES: :[[@LINE-1]]:25: warning: 2 adjacent parameters of 'pointerConversion7' of convertible types
+// CHECK-MESSAGES: :[[@LINE-2]]:32: note: the first parameter in the range is 'NTF'
+// CHECK-MESSAGES: :[[@LINE-3]]:63: note: the last parameter in the range is 'NM'
+// CHECK-MESSAGES: :[[@LINE-4]]:49: note: 'void (*)() noexcept' and 'NoexceptMaker' may be implicitly converted: 'void (*)() noexcept' -> 'void (*)()' -> 'NoexceptMaker', 'NoexceptMaker' -> 'NonThrowingFunction' -> 'void (*)() noexcept'
+// CHECK-MESSAGES: :[[@LINE-12]]:3: note: the implicit conversion involves the converting constructor declared here
+// CHECK-MESSAGES: :[[@LINE-9]]:3: note: the implicit conversion involves the conversion operator declared here
+
+struct ToType;
+struct MiddleStep1 {
+  operator ToType() const;
+};
+struct FromType {
+  operator MiddleStep1() const;
+};
+struct MiddleStep2 {
+  operator FromType() const;
+};
+struct ToType {
+  operator MiddleStep2() const;
+};
+
+void f(FromType F, ToType T) { // NO-WARN: The path takes two steps.
+  MiddleStep2 MS2 = T;
+  FromType F2 = MS2;
+
+  MiddleStep1 MS1 = F;
+  ToType T2 = MS1;
+
+  f(F2, T2);
+}
+
+// Synthesised example from OpenCV.
+template <typename T>
+struct TemplateConversion {
+  template <typename T2>
+  operator TemplateConversion<T2>() const;
+};
+using IntConverter = TemplateConversion<int>;
+using FloatConverter = TemplateConversion<float>;
+
+void templateConversion(IntConverter IC, FloatConverter FC) { templateConversion(FC, IC); }
+// Note: even though this swap is possible, we do not model things when it comes to "template magic".
+// But at least the check should not crash!

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

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0} \
 // RUN:  ]}' --
 
 namespace std {
 using size_t = decltype(sizeof(int));
 } // namespace std
 
 #define assert(X) ((void)(X))
 

 template <typename T>
 void memberTypedefDependentReference3(
     typename Vector<T>::element_type E,
     const typename Vector<T>::element_type &R) {}
 // CHECK-MESSAGES: :[[@LINE-2]]:5: warning: 2 adjacent parameters of 'memberTypedefDependentReference3' of similar type are
 // CHECK-MESSAGES: :[[@LINE-3]]:38: note: the first parameter in the range is 'E'
 // CHECK-MESSAGES: :[[@LINE-3]]:45: note: the last parameter in the range is 'R'
 // CHECK-MESSAGES: :[[@LINE-4]]:5: note: 'typename Vector<T>::element_type' and 'const typename Vector<T>::element_type &' parameters accept and bind the same kind of values
+
+void functionPrototypeLosesNoexcept(void (*NonThrowing)() noexcept, void (*Throwing)()) {}
+// NO-WARN: This call cannot be swapped, even if "getCanonicalType()" believes otherwise.

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

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 3}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0} \
 // RUN:  ]}' --
 
 int add(int Left, int Right) { return Left + Right; } // NO-WARN: Only 2 parameters.
 
 int magic(int Left, int Right, int X, int Y) { return 0; }
 // CHECK-MESSAGES: :[[@LINE-1]]:11: warning: 4 adjacent parameters of 'magic' of similar type ('int') are easily swapped by mistake [bugprone-easily-swappable-parameters]
 // CHECK-MESSAGES: :[[@LINE-2]]:15: note: the first parameter in the range is 'Left'
 // CHECK-MESSAGES: :[[@LINE-3]]:43: note: the last parameter in the range is 'Y'

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

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: ""}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 1} \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 1}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0} \
 // RUN:  ]}' --
 
 typedef int MyInt1;
 typedef int MyInt2;
 using CInt = const int;
 using CMyInt1 = const MyInt1;
 using CMyInt2 = const MyInt2;
 

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

 // RUN: %check_clang_tidy %s bugprone-easily-swappable-parameters %t \
 // RUN:   -config='{CheckOptions: [ \
 // RUN:     {key: bugprone-easily-swappable-parameters.MinimumLength, value: 2}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterNames, value: ""}, \
 // RUN:     {key: bugprone-easily-swappable-parameters.IgnoredParameterTypeSuffixes, value: "bool;MyBool;struct U;MAKE_LOGICAL_TYPE(int)"}, \
-// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0} \
+// RUN:     {key: bugprone-easily-swappable-parameters.QualifiersMix, value: 0}, \
+// RUN:     {key: bugprone-easily-swappable-parameters.ModelImplicitConversions, value: 0} \
 // RUN:  ]}' -- -x c
 
 #define bool _Bool
 #define true 1
 #define false 0
 
 typedef bool MyBool;