[clang] 9e43e7e - [clang] Fix using-enum breakage
Nathan Sidwell via cfe-commits
cfe-commits at lists.llvm.org
Mon Jun 7 07:13:03 PDT 2021
Author: Nathan Sidwell
Date: 2021-06-07T07:12:34-07:00
New Revision: 9e43e7ec111d9029da1b2098733f67a239e4edef
URL: https://github.com/llvm/llvm-project/commit/9e43e7ec111d9029da1b2098733f67a239e4edef
DIFF: https://github.com/llvm/llvm-project/commit/9e43e7ec111d9029da1b2098733f67a239e4edef.diff
LOG: [clang] Fix using-enum breakage
This fixes a build breakage. I managed to attach this particular
change to the wrong diff in the stack when rebasing. And flubbed
testing :(
Differential Revision: https://reviews.llvm.org/D101777
Added:
clang/lib/Sema/SemaOverload.cpp.blame
Modified:
clang/lib/Sema/SemaDeclCXX.cpp
Removed:
################################################################################
diff --git a/clang/lib/Sema/SemaDeclCXX.cpp b/clang/lib/Sema/SemaDeclCXX.cpp
index 6b2fc0358a79..e25a5f03658c 100644
--- a/clang/lib/Sema/SemaDeclCXX.cpp
+++ b/clang/lib/Sema/SemaDeclCXX.cpp
@@ -11751,11 +11751,11 @@ bool Sema::CheckUsingShadowDecl(BaseUsingDecl *BUD, NamedDecl *Orig,
(isa_and_nonnull<UnresolvedUsingIfExistsDecl>(NonTag))) {
if (!NonTag && !Tag)
return false;
- Diag(Using->getLocation(), diag::err_using_decl_conflict);
+ Diag(BUD->getLocation(), diag::err_using_decl_conflict);
Diag(Target->getLocation(), diag::note_using_decl_target);
Diag((NonTag ? NonTag : Tag)->getLocation(),
diag::note_using_decl_conflict);
- Using->setInvalidDecl();
+ BUD->setInvalidDecl();
return true;
}
diff --git a/clang/lib/Sema/SemaOverload.cpp.blame b/clang/lib/Sema/SemaOverload.cpp.blame
new file mode 100644
index 000000000000..d6bb6a9f12ff
--- /dev/null
+++ b/clang/lib/Sema/SemaOverload.cpp.blame
@@ -0,0 +1,15202 @@
+e112151a35826 (Nick Lewycky 2013-01-24 01:12:16 +0000 1) //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2) //
+2946cd7010674 (Chandler Carruth 2019-01-19 08:50:56 +0000 3) // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+2946cd7010674 (Chandler Carruth 2019-01-19 08:50:56 +0000 4) // See https://llvm.org/LICENSE.txt for license information.
+2946cd7010674 (Chandler Carruth 2019-01-19 08:50:56 +0000 5) // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6) //
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 7) //===----------------------------------------------------------------------===//
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 8) //
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9) // This file provides Sema routines for C++ overloading.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10) //
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 11) //===----------------------------------------------------------------------===//
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 12)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 13) #include "clang/AST/ASTContext.h"
+36d1b14ddedb3 (Douglas Gregor 2009-10-06 17:59:45 +0000 14) #include "clang/AST/CXXInheritance.h"
+de6836a384d86 (John McCall 2010-08-24 07:21:54 +0000 15) #include "clang/AST/DeclObjC.h"
+67d25914b2a42 (Haojian Wu 2020-03-16 13:43:40 +0100 16) #include "clang/AST/DependenceFlags.h"
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 17) #include "clang/AST/Expr.h"
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 18) #include "clang/AST/ExprCXX.h"
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 19) #include "clang/AST/ExprObjC.h"
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 20) #include "clang/AST/TypeOrdering.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 21) #include "clang/Basic/Diagnostic.h"
+f3ca2698393c5 (Benjamin Kramer 2014-05-10 16:31:55 +0000 22) #include "clang/Basic/DiagnosticOptions.h"
+d624e16833af6 (Anders Carlsson 2009-08-26 23:45:07 +0000 23) #include "clang/Basic/PartialDiagnostic.h"
+86565c1309423 (Reid Kleckner 2020-02-27 11:01:58 -0800 24) #include "clang/Basic/SourceManager.h"
+c729b0b50669e (David Majnemer 2013-09-16 22:44:20 +0000 25) #include "clang/Basic/TargetInfo.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 26) #include "clang/Sema/Initialization.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 27) #include "clang/Sema/Lookup.h"
+ec3060c72de6a (Ilya Biryukov 2020-03-02 16:07:09 +0100 28) #include "clang/Sema/Overload.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 29) #include "clang/Sema/SemaInternal.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 30) #include "clang/Sema/Template.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 31) #include "clang/Sema/TemplateDeduction.h"
+2bbc0266e0749 (Douglas Gregor 2010-09-12 04:28:07 +0000 32) #include "llvm/ADT/DenseSet.h"
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 33) #include "llvm/ADT/Optional.h"
+3a02247dc9e39 (Chandler Carruth 2012-12-04 09:13:33 +0000 34) #include "llvm/ADT/STLExtras.h"
+58e008d2a61a7 (Douglas Gregor 2008-11-13 20:12:29 +0000 35) #include "llvm/ADT/SmallPtrSet.h"
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 36) #include "llvm/ADT/SmallString.h"
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 37) #include <algorithm>
+8ad22e6a5cb2c (David Blaikie 2014-05-01 23:01:41 +0000 38) #include <cstdlib>
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 39)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 40) using namespace clang;
+19c1bfd1b0750 (John McCall 2010-08-25 05:32:35 +0000 41) using namespace sema;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 42)
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 43) using AllowedExplicit = Sema::AllowedExplicit;
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 44)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 45) static bool functionHasPassObjectSizeParams(const FunctionDecl *FD) {
+21081364f84dc (George Burgess IV 2016-07-24 23:12:40 +0000 46) return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
+21081364f84dc (George Burgess IV 2016-07-24 23:12:40 +0000 47) return P->hasAttr<PassObjectSizeAttr>();
+21081364f84dc (George Burgess IV 2016-07-24 23:12:40 +0000 48) });
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 49) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 50)
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 51) /// A convenience routine for creating a decayed reference to a function.
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 52) static ExprResult
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 53) CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 54) const Expr *Base, bool HadMultipleCandidates,
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 55) SourceLocation Loc = SourceLocation(),
+e9d62935d3c42 (Douglas Gregor 2011-07-15 16:25:15 +0000 56) const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 57) if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 58) return ExprError();
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 59) // If FoundDecl is
diff erent from Fn (such as if one is a template
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 60) // and the other a specialization), make sure DiagnoseUseOfDecl is
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 61) // called on both.
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 62) // FIXME: This would be more comprehensively addressed by modifying
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 63) // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 64) // being used.
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 65) if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 66) return ExprError();
+5fc4db75798c8 (Bruno Ricci 2018-12-21 14:10:18 +0000 67) DeclRefExpr *DRE = new (S.Context)
+5fc4db75798c8 (Bruno Ricci 2018-12-21 14:10:18 +0000 68) DeclRefExpr(S.Context, Fn, false, Fn->getType(), VK_LValue, Loc, LocInfo);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 69) if (HadMultipleCandidates)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 70) DRE->setHadMultipleCandidates(true);
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 71)
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 72) S.MarkDeclRefReferenced(DRE, Base);
+0ec1e99001291 (Richard Smith 2019-12-13 14:06:24 -0800 73) if (auto *FPT = DRE->getType()->getAs<FunctionProtoType>()) {
+0ec1e99001291 (Richard Smith 2019-12-13 14:06:24 -0800 74) if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
+0ec1e99001291 (Richard Smith 2019-12-13 14:06:24 -0800 75) S.ResolveExceptionSpec(Loc, FPT);
+0ec1e99001291 (Richard Smith 2019-12-13 14:06:24 -0800 76) DRE->setType(Fn->getType());
+0ec1e99001291 (Richard Smith 2019-12-13 14:06:24 -0800 77) }
+0ec1e99001291 (Richard Smith 2019-12-13 14:06:24 -0800 78) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 79) return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 80) CK_FunctionToPointerDecay);
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 81) }
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 82)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 83) static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 84) bool InOverloadResolution,
+582813596a100 (Douglas Gregor 2011-01-27 00:58:17 +0000 85) StandardConversionSequence &SCS,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 86) bool CStyle,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 87) bool AllowObjCWritebackConversion);
+04390a63c89b0 (Sam Panzer 2012-08-16 02:38:47 +0000 88)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 89) static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 90) QualType &ToType,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 91) bool InOverloadResolution,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 92) StandardConversionSequence &SCS,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 93) bool CStyle);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 94) static OverloadingResult
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 95) IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 96) UserDefinedConversionSequence& User,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 97) OverloadCandidateSet& Conversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 98) AllowedExplicit AllowExplicit,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 99) bool AllowObjCConversionOnExplicit);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 100)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 101) static ImplicitConversionSequence::CompareKind
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 102) CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 103) const StandardConversionSequence& SCS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 104) const StandardConversionSequence& SCS2);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 105)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 106) static ImplicitConversionSequence::CompareKind
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 107) CompareQualificationConversions(Sema &S,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 108) const StandardConversionSequence& SCS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 109) const StandardConversionSequence& SCS2);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 110)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 111) static ImplicitConversionSequence::CompareKind
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 112) CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 113) const StandardConversionSequence& SCS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 114) const StandardConversionSequence& SCS2);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 115)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 116) /// GetConversionRank - Retrieve the implicit conversion rank
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 117) /// corresponding to the given implicit conversion kind.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 118) ImplicitConversionRank clang::GetConversionRank(ImplicitConversionKind Kind) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 119) static const ImplicitConversionRank
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 120) Rank[(int)ICK_Num_Conversion_Kinds] = {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 121) ICR_Exact_Match,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 122) ICR_Exact_Match,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 123) ICR_Exact_Match,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 124) ICR_Exact_Match,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 125) ICR_Exact_Match,
+40cb9ad391af6 (Douglas Gregor 2009-12-09 00:47:37 +0000 126) ICR_Exact_Match,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 127) ICR_Promotion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 128) ICR_Promotion,
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 129) ICR_Promotion,
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 130) ICR_Conversion,
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 131) ICR_Conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 132) ICR_Conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 133) ICR_Conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 134) ICR_Conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 135) ICR_Conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 136) ICR_Conversion,
+786ab2119f288 (Douglas Gregor 2008-10-29 02:00:59 +0000 137) ICR_Conversion,
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 138) ICR_Conversion,
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 139) ICR_Conversion,
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 140) ICR_Conversion,
+c217f37cb663b (Egor Churaev 2017-03-21 12:55:55 +0000 141) ICR_OCL_Scalar_Widening,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 142) ICR_Complex_Real_Conversion,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 143) ICR_Conversion,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 144) ICR_Conversion,
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 145) ICR_Writeback_Conversion,
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 146) ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 147) // it was omitted by the patch that added
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 148) // ICK_Zero_Event_Conversion
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 149) ICR_C_Conversion,
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 150) ICR_C_Conversion_Extension
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 151) };
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 152) return Rank[(int)Kind];
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 153) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 154)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 155) /// GetImplicitConversionName - Return the name of this kind of
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 156) /// implicit conversion.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 157) static const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
+cfca1f0dc1cda (Nuno Lopes 2009-12-23 17:49:57 +0000 158) static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 159) "No conversion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 160) "Lvalue-to-rvalue",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 161) "Array-to-pointer",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 162) "Function-to-pointer",
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 163) "Function pointer conversion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 164) "Qualification",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 165) "Integral promotion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 166) "Floating point promotion",
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 167) "Complex promotion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 168) "Integral conversion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 169) "Floating conversion",
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 170) "Complex conversion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 171) "Floating-integral conversion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 172) "Pointer conversion",
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 173) "Pointer-to-member conversion",
+786ab2119f288 (Douglas Gregor 2008-10-29 02:00:59 +0000 174) "Boolean conversion",
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 175) "Compatible-types conversion",
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 176) "Derived-to-base conversion",
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 177) "Vector conversion",
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 178) "SVE Vector conversion",
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 179) "Vector splat",
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 180) "Complex-real conversion",
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 181) "Block Pointer conversion",
+55635cea27f25 (Sylvestre Ledru 2014-11-17 19:41:49 +0000 182) "Transparent Union Conversion",
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 183) "Writeback conversion",
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 184) "OpenCL Zero Event Conversion",
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 185) "C specific type conversion",
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 186) "Incompatible pointer conversion"
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 187) };
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 188) return Name[Kind];
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 189) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 190)
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 191) /// StandardConversionSequence - Set the standard conversion
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 192) /// sequence to the identity conversion.
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 193) void StandardConversionSequence::setAsIdentityConversion() {
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 194) First = ICK_Identity;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 195) Second = ICK_Identity;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 196) Third = ICK_Identity;
+e489a7d3d3972 (Douglas Gregor 2010-02-28 18:30:25 +0000 197) DeprecatedStringLiteralToCharPtr = false;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 198) QualificationIncludesObjCLifetime = false;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 199) ReferenceBinding = false;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 200) DirectBinding = false;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 201) IsLvalueReference = true;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 202) BindsToFunctionLvalue = false;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 203) BindsToRvalue = false;
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 204) BindsImplicitObjectArgumentWithoutRefQualifier = false;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 205) ObjCLifetimeConversionBinding = false;
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 206) CopyConstructor = nullptr;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 207) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 208)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 209) /// getRank - Retrieve the rank of this standard conversion sequence
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 210) /// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 211) /// implicit conversions.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 212) ImplicitConversionRank StandardConversionSequence::getRank() const {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 213) ImplicitConversionRank Rank = ICR_Exact_Match;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 214) if (GetConversionRank(First) > Rank)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 215) Rank = GetConversionRank(First);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 216) if (GetConversionRank(Second) > Rank)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 217) Rank = GetConversionRank(Second);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 218) if (GetConversionRank(Third) > Rank)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 219) Rank = GetConversionRank(Third);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 220) return Rank;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 221) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 222)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 223) /// isPointerConversionToBool - Determines whether this conversion is
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 224) /// a conversion of a pointer or pointer-to-member to bool. This is
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 225) /// used as part of the ranking of standard conversion sequences
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 226) /// (C++ 13.3.3.2p4).
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 227) bool StandardConversionSequence::isPointerConversionToBool() const {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 228) // Note that FromType has not necessarily been transformed by the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 229) // array-to-pointer or function-to-pointer implicit conversions, so
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 230) // check for their presence as well as checking whether FromType is
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 231) // a pointer.
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 232) if (getToType(1)->isBooleanType() &&
+6d1116ac4967b (John McCall 2010-06-11 10:04:22 +0000 233) (getFromType()->isPointerType() ||
+2fcbe9283fb9f (Erich Keane 2018-06-12 13:59:32 +0000 234) getFromType()->isMemberPointerType() ||
+6d1116ac4967b (John McCall 2010-06-11 10:04:22 +0000 235) getFromType()->isObjCObjectPointerType() ||
+6d1116ac4967b (John McCall 2010-06-11 10:04:22 +0000 236) getFromType()->isBlockPointerType() ||
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 237) First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 238) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 239)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 240) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 241) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 242)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 243) /// isPointerConversionToVoidPointer - Determines whether this
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 244) /// conversion is a conversion of a pointer to a void pointer. This is
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 245) /// used as part of the ranking of standard conversion sequences (C++
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 246) /// 13.3.3.2p4).
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 247) bool
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 248) StandardConversionSequence::
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 249) isPointerConversionToVoidPointer(ASTContext& Context) const {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 250) QualType FromType = getFromType();
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 251) QualType ToType = getToType(1);
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 252)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 253) // Note that FromType has not necessarily been transformed by the
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 254) // array-to-pointer implicit conversion, so check for its presence
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 255) // and redo the conversion to get a pointer.
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 256) if (First == ICK_Array_To_Pointer)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 257) FromType = Context.getArrayDecayedType(FromType);
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 258)
+5d3d3fa33d44a (Douglas Gregor 2011-04-15 20:45:44 +0000 259) if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 260) if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 261) return ToPtrType->getPointeeType()->isVoidType();
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 262)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 263) return false;
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 264) }
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 265)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 266) /// Skip any implicit casts which could be either part of a narrowing conversion
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 267) /// or after one in an implicit conversion.
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 268) static const Expr *IgnoreNarrowingConversion(ASTContext &Ctx,
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 269) const Expr *Converted) {
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 270) // We can have cleanups wrapping the converted expression; these need to be
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 271) // preserved so that destructors run if necessary.
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 272) if (auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 273) Expr *Inner =
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 274) const_cast<Expr *>(IgnoreNarrowingConversion(Ctx, EWC->getSubExpr()));
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 275) return ExprWithCleanups::Create(Ctx, Inner, EWC->cleanupsHaveSideEffects(),
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 276) EWC->getObjects());
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 277) }
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 278)
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 279) while (auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 280) switch (ICE->getCastKind()) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 281) case CK_NoOp:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 282) case CK_IntegralCast:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 283) case CK_IntegralToBoolean:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 284) case CK_IntegralToFloating:
+df1ed0099ba6c (George Burgess IV 2016-01-13 01:52:39 +0000 285) case CK_BooleanToSignedIntegral:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 286) case CK_FloatingToIntegral:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 287) case CK_FloatingToBoolean:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 288) case CK_FloatingCast:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 289) Converted = ICE->getSubExpr();
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 290) continue;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 291)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 292) default:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 293) return Converted;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 294) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 295) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 296)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 297) return Converted;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 298) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 299)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 300) /// Check if this standard conversion sequence represents a narrowing
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 301) /// conversion, according to C++11 [dcl.init.list]p7.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 302) ///
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 303) /// \param Ctx The AST context.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 304) /// \param Converted The result of applying this standard conversion sequence.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 305) /// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 306) /// value of the expression prior to the narrowing conversion.
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 307) /// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 308) /// type of the expression prior to the narrowing conversion.
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 309) /// \param IgnoreFloatToIntegralConversion If true type-narrowing conversions
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 310) /// from floating point types to integral types should be ignored.
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 311) NarrowingKind StandardConversionSequence::getNarrowingKind(
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 312) ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 313) QualType &ConstantType, bool IgnoreFloatToIntegralConversion) const {
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 314) assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++");
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 315)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 316) // C++11 [dcl.init.list]p7:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 317) // A narrowing conversion is an implicit conversion ...
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 318) QualType FromType = getToType(0);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 319) QualType ToType = getToType(1);
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 320)
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 321) // A conversion to an enumeration type is narrowing if the conversion to
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 322) // the underlying type is narrowing. This only arises for expressions of
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 323) // the form 'Enum{init}'.
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 324) if (auto *ET = ToType->getAs<EnumType>())
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 325) ToType = ET->getDecl()->getIntegerType();
+ed638864d3e19 (Richard Smith 2016-03-28 06:08:37 +0000 326)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 327) switch (Second) {
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 328) // 'bool' is an integral type; dispatch to the right place to handle it.
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 329) case ICK_Boolean_Conversion:
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 330) if (FromType->isRealFloatingType())
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 331) goto FloatingIntegralConversion;
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 332) if (FromType->isIntegralOrUnscopedEnumerationType())
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 333) goto IntegralConversion;
+7ef45f45f6721 (Richard Smith 2020-02-10 07:22:51 -0800 334) // -- from a pointer type or pointer-to-member type to bool, or
+7ef45f45f6721 (Richard Smith 2020-02-10 07:22:51 -0800 335) return NK_Type_Narrowing;
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 336)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 337) // -- from a floating-point type to an integer type, or
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 338) //
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 339) // -- from an integer type or unscoped enumeration type to a floating-point
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 340) // type, except where the source is a constant expression and the actual
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 341) // value after conversion will fit into the target type and will produce
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 342) // the original value when converted back to the original type, or
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 343) case ICK_Floating_Integral:
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 344) FloatingIntegralConversion:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 345) if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 346) return NK_Type_Narrowing;
+7b1a950c4af4e (Mikhail Maltsev 2018-02-21 10:08:18 +0000 347) } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
+7b1a950c4af4e (Mikhail Maltsev 2018-02-21 10:08:18 +0000 348) ToType->isRealFloatingType()) {
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 349) if (IgnoreFloatToIntegralConversion)
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 350) return NK_Not_Narrowing;
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 351) const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
+f940987a4e21b (Simon Pilgrim 2017-06-01 18:13:02 +0000 352) assert(Initializer && "Unknown conversion expression");
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 353)
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 354) // If it's value-dependent, we can't tell whether it's narrowing.
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 355) if (Initializer->isValueDependent())
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 356) return NK_Dependent_Narrowing;
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 357)
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 358) if (Optional<llvm::APSInt> IntConstantValue =
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 359) Initializer->getIntegerConstantExpr(Ctx)) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 360) // Convert the integer to the floating type.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 361) llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 362) Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 363) llvm::APFloat::rmNearestTiesToEven);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 364) // And back.
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 365) llvm::APSInt ConvertedValue = *IntConstantValue;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 366) bool ignored;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 367) Result.convertToInteger(ConvertedValue,
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 368) llvm::APFloat::rmTowardZero, &ignored);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 369) // If the resulting value is
diff erent, this was a narrowing conversion.
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 370) if (*IntConstantValue != ConvertedValue) {
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 371) ConstantValue = APValue(*IntConstantValue);
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 372) ConstantType = Initializer->getType();
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 373) return NK_Constant_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 374) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 375) } else {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 376) // Variables are always narrowings.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 377) return NK_Variable_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 378) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 379) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 380) return NK_Not_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 381)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 382) // -- from long double to double or float, or from double to float, except
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 383) // where the source is a constant expression and the actual value after
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 384) // conversion is within the range of values that can be represented (even
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 385) // if it cannot be represented exactly), or
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 386) case ICK_Floating_Conversion:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 387) if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 388) Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 389) // FromType is larger than ToType.
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 390) const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 391)
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 392) // If it's value-dependent, we can't tell whether it's narrowing.
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 393) if (Initializer->isValueDependent())
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 394) return NK_Dependent_Narrowing;
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 395)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 396) if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 397) // Constant!
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 398) assert(ConstantValue.isFloat());
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 399) llvm::APFloat FloatVal = ConstantValue.getFloat();
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 400) // Convert the source value into the target type.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 401) bool ignored;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 402) llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 403) Ctx.getFloatTypeSemantics(ToType),
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 404) llvm::APFloat::rmNearestTiesToEven, &ignored);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 405) // If there was no overflow, the source value is within the range of
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 406) // values that can be represented.
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 407) if (ConvertStatus & llvm::APFloat::opOverflow) {
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 408) ConstantType = Initializer->getType();
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 409) return NK_Constant_Narrowing;
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 410) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 411) } else {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 412) return NK_Variable_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 413) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 414) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 415) return NK_Not_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 416)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 417) // -- from an integer type or unscoped enumeration type to an integer type
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 418) // that cannot represent all the values of the original type, except where
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 419) // the source is a constant expression and the actual value after
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 420) // conversion will fit into the target type and will produce the original
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 421) // value when converted back to the original type.
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 422) case ICK_Integral_Conversion:
+64ecacf6cb4d6 (Richard Smith 2015-02-19 00:39:05 +0000 423) IntegralConversion: {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 424) assert(FromType->isIntegralOrUnscopedEnumerationType());
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 425) assert(ToType->isIntegralOrUnscopedEnumerationType());
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 426) const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 427) const unsigned FromWidth = Ctx.getIntWidth(FromType);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 428) const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 429) const unsigned ToWidth = Ctx.getIntWidth(ToType);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 430)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 431) if (FromWidth > ToWidth ||
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 432) (FromWidth == ToWidth && FromSigned != ToSigned) ||
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 433) (FromSigned && !ToSigned)) {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 434) // Not all values of FromType can be represented in ToType.
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 435) const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 436)
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 437) // If it's value-dependent, we can't tell whether it's narrowing.
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 438) if (Initializer->isValueDependent())
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 439) return NK_Dependent_Narrowing;
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 440)
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 441) Optional<llvm::APSInt> OptInitializerValue;
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 442) if (!(OptInitializerValue = Initializer->getIntegerConstantExpr(Ctx))) {
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 443) // Such conversions on variables are always narrowing.
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 444) return NK_Variable_Narrowing;
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 445) }
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 446) llvm::APSInt &InitializerValue = *OptInitializerValue;
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 447) bool Narrowing = false;
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 448) if (FromWidth < ToWidth) {
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 449) // Negative -> unsigned is narrowing. Otherwise, more bits is never
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 450) // narrowing.
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 451) if (InitializerValue.isSigned() && InitializerValue.isNegative())
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 452) Narrowing = true;
+25a80d424bb29 (Richard Smith 2012-06-13 01:07:41 +0000 453) } else {
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 454) // Add a bit to the InitializerValue so we don't have to worry about
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 455) // signed vs. unsigned comparisons.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 456) InitializerValue = InitializerValue.extend(
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 457) InitializerValue.getBitWidth() + 1);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 458) // Convert the initializer to and from the target width and signed-ness.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 459) llvm::APSInt ConvertedValue = InitializerValue;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 460) ConvertedValue = ConvertedValue.trunc(ToWidth);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 461) ConvertedValue.setIsSigned(ToSigned);
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 462) ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 463) ConvertedValue.setIsSigned(InitializerValue.isSigned());
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 464) // If the result is
diff erent, this was a narrowing conversion.
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 465) if (ConvertedValue != InitializerValue)
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 466) Narrowing = true;
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 467) }
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 468) if (Narrowing) {
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 469) ConstantType = Initializer->getType();
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 470) ConstantValue = APValue(InitializerValue);
+72cd8ea5e5521 (Richard Smith 2012-06-19 21:28:35 +0000 471) return NK_Constant_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 472) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 473) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 474) return NK_Not_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 475) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 476)
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 477) default:
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 478) // Other kinds of conversions are not narrowings.
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 479) return NK_Not_Narrowing;
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 480) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 481) }
+66e05fe63099d (Richard Smith 2012-01-18 05:21:49 +0000 482)
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 483) /// dump - Print this standard conversion sequence to standard
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 484) /// error. Useful for debugging overloading issues.
+cdae941e0330d (Yaron Keren 2016-01-29 19:38:18 +0000 485) LLVM_DUMP_METHOD void StandardConversionSequence::dump() const {
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 486) raw_ostream &OS = llvm::errs();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 487) bool PrintedSomething = false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 488) if (First != ICK_Identity) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 489) OS << GetImplicitConversionName(First);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 490) PrintedSomething = true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 491) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 492)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 493) if (Second != ICK_Identity) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 494) if (PrintedSomething) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 495) OS << " -> ";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 496) }
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 497) OS << GetImplicitConversionName(Second);
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 498)
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 499) if (CopyConstructor) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 500) OS << " (by copy constructor)";
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 501) } else if (DirectBinding) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 502) OS << " (direct reference binding)";
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 503) } else if (ReferenceBinding) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 504) OS << " (reference binding)";
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 505) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 506) PrintedSomething = true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 507) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 508)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 509) if (Third != ICK_Identity) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 510) if (PrintedSomething) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 511) OS << " -> ";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 512) }
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 513) OS << GetImplicitConversionName(Third);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 514) PrintedSomething = true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 515) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 516)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 517) if (!PrintedSomething) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 518) OS << "No conversions required";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 519) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 520) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 521)
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 522) /// dump - Print this user-defined conversion sequence to standard
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 523) /// error. Useful for debugging overloading issues.
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 524) void UserDefinedConversionSequence::dump() const {
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 525) raw_ostream &OS = llvm::errs();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 526) if (Before.First || Before.Second || Before.Third) {
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 527) Before.dump();
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 528) OS << " -> ";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 529) }
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 530) if (ConversionFunction)
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 531) OS << '\'' << *ConversionFunction << '\'';
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 532) else
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 533) OS << "aggregate initialization";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 534) if (After.First || After.Second || After.Third) {
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 535) OS << " -> ";
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 536) After.dump();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 537) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 538) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 539)
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 540) /// dump - Print this implicit conversion sequence to standard
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 541) /// error. Useful for debugging overloading issues.
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 542) void ImplicitConversionSequence::dump() const {
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 543) raw_ostream &OS = llvm::errs();
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 544) if (isInitializerListToType())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 545) OS << "Worst list element conversion: ";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 546) switch (ConversionKind) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 547) case StandardConversion:
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 548) OS << "Standard conversion: ";
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 549) Standard.dump();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 550) break;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 551) case UserDefinedConversion:
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 552) OS << "User-defined conversion: ";
+9f2ed47133fa2 (Douglas Gregor 2013-11-08 02:16:10 +0000 553) UserDefined.dump();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 554) break;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 555) case EllipsisConversion:
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 556) OS << "Ellipsis conversion";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 557) break;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 558) case AmbiguousConversion:
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 559) OS << "Ambiguous conversion";
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 560) break;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 561) case BadConversion:
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 562) OS << "Bad conversion";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 563) break;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 564) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 565)
+42e3df065e862 (Daniel Dunbar 2010-01-22 02:04:41 +0000 566) OS << "\n";
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 567) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 568)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 569) void AmbiguousConversionSequence::construct() {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 570) new (&conversions()) ConversionSet();
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 571) }
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 572)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 573) void AmbiguousConversionSequence::destruct() {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 574) conversions().~ConversionSet();
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 575) }
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 576)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 577) void
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 578) AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 579) FromTypePtr = O.FromTypePtr;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 580) ToTypePtr = O.ToTypePtr;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 581) new (&conversions()) ConversionSet(O.conversions());
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 582) }
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 583)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 584) namespace {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 585) // Structure used by DeductionFailureInfo to store
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 586) // template argument information.
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 587) struct DFIArguments {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 588) TemplateArgument FirstArg;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 589) TemplateArgument SecondArg;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 590) };
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 591) // Structure used by DeductionFailureInfo to store
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 592) // template parameter and template argument information.
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 593) struct DFIParamWithArguments : DFIArguments {
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 594) TemplateParameter Param;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 595) };
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 596) // Structure used by DeductionFailureInfo to store template argument
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 597) // information and the index of the problematic call argument.
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 598) struct DFIDeducedMismatchArgs : DFIArguments {
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 599) TemplateArgumentList *TemplateArgs;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 600) unsigned CallArgIndex;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 601) };
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 602) // Structure used by DeductionFailureInfo to store information about
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 603) // unsatisfied constraints.
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 604) struct CNSInfo {
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 605) TemplateArgumentList *TemplateArgs;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 606) ConstraintSatisfaction Satisfaction;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 607) };
+ab9db51042d1b (Alexander Kornienko 2015-06-22 23:07:51 +0000 608) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 609)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 610) /// Convert from Sema's representation of template deduction information
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 611) /// to the form used in overload-candidate information.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 612) DeductionFailureInfo
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 613) clang::MakeDeductionFailureInfo(ASTContext &Context,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 614) Sema::TemplateDeductionResult TDK,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 615) TemplateDeductionInfo &Info) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 616) DeductionFailureInfo Result;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 617) Result.Result = static_cast<unsigned>(TDK);
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 618) Result.HasDiagnostic = false;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 619) switch (TDK) {
+c5c01a60c2e3f (Douglas Gregor 2012-09-13 21:01:57 +0000 620) case Sema::TDK_Invalid:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 621) case Sema::TDK_InstantiationDepth:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 622) case Sema::TDK_TooManyArguments:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 623) case Sema::TDK_TooFewArguments:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 624) case Sema::TDK_MiscellaneousDeductionFailure:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 625) case Sema::TDK_CUDATargetMismatch:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 626) Result.Data = nullptr;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 627) break;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 628)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 629) case Sema::TDK_Incomplete:
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 630) case Sema::TDK_InvalidExplicitArguments:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 631) Result.Data = Info.Param.getOpaqueValue();
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 632) break;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 633)
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 634) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 635) case Sema::TDK_DeducedMismatchNested: {
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 636) // FIXME: Should allocate from normal heap so that we can free this later.
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 637) auto *Saved = new (Context) DFIDeducedMismatchArgs;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 638) Saved->FirstArg = Info.FirstArg;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 639) Saved->SecondArg = Info.SecondArg;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 640) Saved->TemplateArgs = Info.take();
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 641) Saved->CallArgIndex = Info.CallArgIndex;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 642) Result.Data = Saved;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 643) break;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 644) }
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 645)
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 646) case Sema::TDK_NonDeducedMismatch: {
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 647) // FIXME: Should allocate from normal heap so that we can free this later.
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 648) DFIArguments *Saved = new (Context) DFIArguments;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 649) Saved->FirstArg = Info.FirstArg;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 650) Saved->SecondArg = Info.SecondArg;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 651) Result.Data = Saved;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 652) break;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 653) }
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 654)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 655) case Sema::TDK_IncompletePack:
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 656) // FIXME: It's slightly wasteful to allocate two TemplateArguments for this.
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 657) case Sema::TDK_Inconsistent:
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 658) case Sema::TDK_Underqualified: {
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 659) // FIXME: Should allocate from normal heap so that we can free this later.
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 660) DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 661) Saved->Param = Info.Param;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 662) Saved->FirstArg = Info.FirstArg;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 663) Saved->SecondArg = Info.SecondArg;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 664) Result.Data = Saved;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 665) break;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 666) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 667)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 668) case Sema::TDK_SubstitutionFailure:
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 669) Result.Data = Info.take();
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 670) if (Info.hasSFINAEDiagnostic()) {
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 671) PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 672) SourceLocation(), PartialDiagnostic::NullDiagnostic());
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 673) Info.takeSFINAEDiagnostic(*Diag);
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 674) Result.HasDiagnostic = true;
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 675) }
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 676) break;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 677)
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 678) case Sema::TDK_ConstraintsNotSatisfied: {
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 679) CNSInfo *Saved = new (Context) CNSInfo;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 680) Saved->TemplateArgs = Info.take();
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 681) Saved->Satisfaction = Info.AssociatedConstraintsSatisfaction;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 682) Result.Data = Saved;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 683) break;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 684) }
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 685)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 686) case Sema::TDK_Success:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 687) case Sema::TDK_NonDependentConversionFailure:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 688) llvm_unreachable("not a deduction failure");
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 689) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 690)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 691) return Result;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 692) }
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 693)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 694) void DeductionFailureInfo::Destroy() {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 695) switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 696) case Sema::TDK_Success:
+c5c01a60c2e3f (Douglas Gregor 2012-09-13 21:01:57 +0000 697) case Sema::TDK_Invalid:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 698) case Sema::TDK_InstantiationDepth:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 699) case Sema::TDK_Incomplete:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 700) case Sema::TDK_TooManyArguments:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 701) case Sema::TDK_TooFewArguments:
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 702) case Sema::TDK_InvalidExplicitArguments:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 703) case Sema::TDK_CUDATargetMismatch:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 704) case Sema::TDK_NonDependentConversionFailure:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 705) break;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 706)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 707) case Sema::TDK_IncompletePack:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 708) case Sema::TDK_Inconsistent:
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 709) case Sema::TDK_Underqualified:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 710) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 711) case Sema::TDK_DeducedMismatchNested:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 712) case Sema::TDK_NonDeducedMismatch:
+b02d6b3b94de4 (Douglas Gregor 2010-05-08 20:20:05 +0000 713) // FIXME: Destroy the data?
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 714) Data = nullptr;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 715) break;
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 716)
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 717) case Sema::TDK_SubstitutionFailure:
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 718) // FIXME: Destroy the template argument list?
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 719) Data = nullptr;
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 720) if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 721) Diag->~PartialDiagnosticAt();
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 722) HasDiagnostic = false;
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 723) }
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 724) break;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 725)
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 726) case Sema::TDK_ConstraintsNotSatisfied:
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 727) // FIXME: Destroy the template argument list?
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 728) Data = nullptr;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 729) if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 730) Diag->~PartialDiagnosticAt();
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 731) HasDiagnostic = false;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 732) }
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 733) break;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 734)
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 735) // Unhandled
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 736) case Sema::TDK_MiscellaneousDeductionFailure:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 737) break;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 738) }
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 739) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 740)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 741) PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() {
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 742) if (HasDiagnostic)
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 743) return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 744) return nullptr;
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 745) }
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 746)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 747) TemplateParameter DeductionFailureInfo::getTemplateParameter() {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 748) switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 749) case Sema::TDK_Success:
+c5c01a60c2e3f (Douglas Gregor 2012-09-13 21:01:57 +0000 750) case Sema::TDK_Invalid:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 751) case Sema::TDK_InstantiationDepth:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 752) case Sema::TDK_TooManyArguments:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 753) case Sema::TDK_TooFewArguments:
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 754) case Sema::TDK_SubstitutionFailure:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 755) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 756) case Sema::TDK_DeducedMismatchNested:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 757) case Sema::TDK_NonDeducedMismatch:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 758) case Sema::TDK_CUDATargetMismatch:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 759) case Sema::TDK_NonDependentConversionFailure:
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 760) case Sema::TDK_ConstraintsNotSatisfied:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 761) return TemplateParameter();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 762)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 763) case Sema::TDK_Incomplete:
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 764) case Sema::TDK_InvalidExplicitArguments:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 765) return TemplateParameter::getFromOpaqueValue(Data);
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 766)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 767) case Sema::TDK_IncompletePack:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 768) case Sema::TDK_Inconsistent:
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 769) case Sema::TDK_Underqualified:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 770) return static_cast<DFIParamWithArguments*>(Data)->Param;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 771)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 772) // Unhandled
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 773) case Sema::TDK_MiscellaneousDeductionFailure:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 774) break;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 775) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 776)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 777) return TemplateParameter();
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 778) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 779)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 780) TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 781) switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 782) case Sema::TDK_Success:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 783) case Sema::TDK_Invalid:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 784) case Sema::TDK_InstantiationDepth:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 785) case Sema::TDK_TooManyArguments:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 786) case Sema::TDK_TooFewArguments:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 787) case Sema::TDK_Incomplete:
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 788) case Sema::TDK_IncompletePack:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 789) case Sema::TDK_InvalidExplicitArguments:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 790) case Sema::TDK_Inconsistent:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 791) case Sema::TDK_Underqualified:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 792) case Sema::TDK_NonDeducedMismatch:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 793) case Sema::TDK_CUDATargetMismatch:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 794) case Sema::TDK_NonDependentConversionFailure:
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 795) return nullptr;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 796)
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 797) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 798) case Sema::TDK_DeducedMismatchNested:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 799) return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 800)
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 801) case Sema::TDK_SubstitutionFailure:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 802) return static_cast<TemplateArgumentList*>(Data);
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 803)
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 804) case Sema::TDK_ConstraintsNotSatisfied:
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 805) return static_cast<CNSInfo*>(Data)->TemplateArgs;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 806)
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 807) // Unhandled
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 808) case Sema::TDK_MiscellaneousDeductionFailure:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 809) break;
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 810) }
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 811)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 812) return nullptr;
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 813) }
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 814)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 815) const TemplateArgument *DeductionFailureInfo::getFirstArg() {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 816) switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 817) case Sema::TDK_Success:
+c5c01a60c2e3f (Douglas Gregor 2012-09-13 21:01:57 +0000 818) case Sema::TDK_Invalid:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 819) case Sema::TDK_InstantiationDepth:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 820) case Sema::TDK_Incomplete:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 821) case Sema::TDK_TooManyArguments:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 822) case Sema::TDK_TooFewArguments:
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 823) case Sema::TDK_InvalidExplicitArguments:
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 824) case Sema::TDK_SubstitutionFailure:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 825) case Sema::TDK_CUDATargetMismatch:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 826) case Sema::TDK_NonDependentConversionFailure:
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 827) case Sema::TDK_ConstraintsNotSatisfied:
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 828) return nullptr;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 829)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 830) case Sema::TDK_IncompletePack:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 831) case Sema::TDK_Inconsistent:
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 832) case Sema::TDK_Underqualified:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 833) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 834) case Sema::TDK_DeducedMismatchNested:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 835) case Sema::TDK_NonDeducedMismatch:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 836) return &static_cast<DFIArguments*>(Data)->FirstArg;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 837)
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 838) // Unhandled
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 839) case Sema::TDK_MiscellaneousDeductionFailure:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 840) break;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 841) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 842)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 843) return nullptr;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 844) }
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 845)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 846) const TemplateArgument *DeductionFailureInfo::getSecondArg() {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 847) switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 848) case Sema::TDK_Success:
+c5c01a60c2e3f (Douglas Gregor 2012-09-13 21:01:57 +0000 849) case Sema::TDK_Invalid:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 850) case Sema::TDK_InstantiationDepth:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 851) case Sema::TDK_Incomplete:
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 852) case Sema::TDK_IncompletePack:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 853) case Sema::TDK_TooManyArguments:
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 854) case Sema::TDK_TooFewArguments:
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 855) case Sema::TDK_InvalidExplicitArguments:
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 856) case Sema::TDK_SubstitutionFailure:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 857) case Sema::TDK_CUDATargetMismatch:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 858) case Sema::TDK_NonDependentConversionFailure:
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 859) case Sema::TDK_ConstraintsNotSatisfied:
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 860) return nullptr;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 861)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 862) case Sema::TDK_Inconsistent:
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 863) case Sema::TDK_Underqualified:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 864) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 865) case Sema::TDK_DeducedMismatchNested:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 866) case Sema::TDK_NonDeducedMismatch:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 867) return &static_cast<DFIArguments*>(Data)->SecondArg;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 868)
+461761d68f739 (Douglas Gregor 2010-05-08 18:20:53 +0000 869) // Unhandled
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 870) case Sema::TDK_MiscellaneousDeductionFailure:
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 871) break;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 872) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 873)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 874) return nullptr;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 875) }
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 876)
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 877) llvm::Optional<unsigned> DeductionFailureInfo::getCallArgIndex() {
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 878) switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 879) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 880) case Sema::TDK_DeducedMismatchNested:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 881) return static_cast<DFIDeducedMismatchArgs*>(Data)->CallArgIndex;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 882)
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 883) default:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 884) return llvm::None;
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 885) }
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 886) }
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 887)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 888) bool OverloadCandidateSet::OperatorRewriteInfo::shouldAddReversed(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 889) OverloadedOperatorKind Op) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 890) if (!AllowRewrittenCandidates)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 891) return false;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 892) return Op == OO_EqualEqual || Op == OO_Spaceship;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 893) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 894)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 895) bool OverloadCandidateSet::OperatorRewriteInfo::shouldAddReversed(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 896) ASTContext &Ctx, const FunctionDecl *FD) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 897) if (!shouldAddReversed(FD->getDeclName().getCXXOverloadedOperator()))
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 898) return false;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 899) // Don't bother adding a reversed candidate that can never be a better
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 900) // match than the non-reversed version.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 901) return FD->getNumParams() != 2 ||
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 902) !Ctx.hasSameUnqualifiedType(FD->getParamDecl(0)->getType(),
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 903) FD->getParamDecl(1)->getType()) ||
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 904) FD->hasAttr<EnableIfAttr>();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 905) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 906)
+97e5949068f77 (Benjamin Kramer 2012-10-09 15:52:25 +0000 907) void OverloadCandidateSet::destroyCandidates() {
+0bf93aa6b1429 (Richard Smith 2012-07-18 23:52:59 +0000 908) for (iterator i = begin(), e = end(); i != e; ++i) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 909) for (auto &C : i->Conversions)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 910) C.~ImplicitConversionSequence();
+0bf93aa6b1429 (Richard Smith 2012-07-18 23:52:59 +0000 911) if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
+0bf93aa6b1429 (Richard Smith 2012-07-18 23:52:59 +0000 912) i->DeductionFailure.Destroy();
+0bf93aa6b1429 (Richard Smith 2012-07-18 23:52:59 +0000 913) }
+97e5949068f77 (Benjamin Kramer 2012-10-09 15:52:25 +0000 914) }
+97e5949068f77 (Benjamin Kramer 2012-10-09 15:52:25 +0000 915)
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 916) void OverloadCandidateSet::clear(CandidateSetKind CSK) {
+97e5949068f77 (Benjamin Kramer 2012-10-09 15:52:25 +0000 917) destroyCandidates();
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 918) SlabAllocator.Reset();
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 919) NumInlineBytesUsed = 0;
+fb761ff54452f (Benjamin Kramer 2012-01-14 16:31:55 +0000 920) Candidates.clear();
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 921) Functions.clear();
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 922) Kind = CSK;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 923) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 924)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 925) namespace {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 926) class UnbridgedCastsSet {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 927) struct Entry {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 928) Expr **Addr;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 929) Expr *Saved;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 930) };
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 931) SmallVector<Entry, 2> Entries;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 932)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 933) public:
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 934) void save(Sema &S, Expr *&E) {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 935) assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast));
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 936) Entry entry = { &E, E };
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 937) Entries.push_back(entry);
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 938) E = S.stripARCUnbridgedCast(E);
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 939) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 940)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 941) void restore() {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 942) for (SmallVectorImpl<Entry>::iterator
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 943) i = Entries.begin(), e = Entries.end(); i != e; ++i)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 944) *i->Addr = i->Saved;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 945) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 946) };
+ab9db51042d1b (Alexander Kornienko 2015-06-22 23:07:51 +0000 947) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 948)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 949) /// checkPlaceholderForOverload - Do any interesting placeholder-like
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 950) /// preprocessing on the given expression.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 951) ///
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 952) /// \param unbridgedCasts a collection to which to add unbridged casts;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 953) /// without this, they will be immediately diagnosed as errors
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 954) ///
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 955) /// Return true on unrecoverable error.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 956) static bool
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 957) checkPlaceholderForOverload(Sema &S, Expr *&E,
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 958) UnbridgedCastsSet *unbridgedCasts = nullptr) {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 959) if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 960) // We can't handle overloaded expressions here because overload
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 961) // resolution might reasonably tweak them.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 962) if (placeholder->getKind() == BuiltinType::Overload) return false;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 963)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 964) // If the context potentially accepts unbridged ARC casts, strip
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 965) // the unbridged cast and add it to the collection for later restoration.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 966) if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 967) unbridgedCasts) {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 968) unbridgedCasts->save(S, E);
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 969) return false;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 970) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 971)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 972) // Go ahead and check everything else.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 973) ExprResult result = S.CheckPlaceholderExpr(E);
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 974) if (result.isInvalid())
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 975) return true;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 976)
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 977) E = result.get();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 978) return false;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 979) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 980)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 981) // Nothing to do.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 982) return false;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 983) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 984)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 985) /// checkArgPlaceholdersForOverload - Check a set of call operands for
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 986) /// placeholders.
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 987) static bool checkArgPlaceholdersForOverload(Sema &S,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 988) MultiExprArg Args,
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 989) UnbridgedCastsSet &unbridged) {
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 990) for (unsigned i = 0, e = Args.size(); i != e; ++i)
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 991) if (checkPlaceholderForOverload(S, Args[i], &unbridged))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 992) return true;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 993)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 994) return false;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 995) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 996)
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 997) /// Determine whether the given New declaration is an overload of the
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 998) /// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 999) /// New and Old cannot be overloaded, e.g., if New has the same signature as
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1000) /// some function in Old (C++ 1.3.10) or if the Old declarations aren't
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1001) /// functions (or function templates) at all. When it does return Ovl_Match or
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1002) /// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1003) /// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1004) /// declaration.
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1005) ///
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1006) /// Example: Given the following input:
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1007) ///
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1008) /// void f(int, float); // #1
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1009) /// void f(int, int); // #2
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1010) /// int f(int, int); // #3
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1011) ///
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1012) /// When we process #1, there is no previous declaration of "f", so IsOverload
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1013) /// will not be used.
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1014) ///
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1015) /// When we process #2, Old contains only the FunctionDecl for #1. By comparing
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1016) /// the parameter types, we see that #1 and #2 are overloaded (since they have
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1017) ///
diff erent signatures), so this routine returns Ovl_Overload; MatchedDecl is
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1018) /// unchanged.
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1019) ///
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1020) /// When we process #3, Old is an overload set containing #1 and #2. We compare
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1021) /// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1022) /// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1023) /// functions are not part of the signature), IsOverload returns Ovl_Match and
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1024) /// MatchedDecl will be set to point to the FunctionDecl for #2.
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1025) ///
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1026) /// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1027) /// by a using declaration. The rules for whether to hide shadow declarations
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1028) /// ignore some properties which otherwise figure into a function template's
+2d82b091d9660 (George Burgess IV 2017-04-06 00:23:31 +0000 1029) /// signature.
+daa3d6bb502a3 (John McCall 2009-12-09 03:35:25 +0000 1030) Sema::OverloadKind
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1031) Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1032) NamedDecl *&Match, bool NewIsUsingDecl) {
+3d988d9042ffc (John McCall 2009-12-02 08:47:38 +0000 1033) for (LookupResult::iterator I = Old.begin(), E = Old.end();
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1034) I != E; ++I) {
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1035) NamedDecl *OldD = *I;
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1036)
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1037) bool OldIsUsingDecl = false;
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1038) if (isa<UsingShadowDecl>(OldD)) {
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1039) OldIsUsingDecl = true;
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1040)
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1041) // We can always introduce two using declarations into the same
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1042) // context, even if they have identical signatures.
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1043) if (NewIsUsingDecl) continue;
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1044)
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1045) OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1046) }
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1047)
+f091e129dbf75 (Richard Smith 2015-09-15 01:28:55 +0000 1048) // A using-declaration does not conflict with another declaration
+f091e129dbf75 (Richard Smith 2015-09-15 01:28:55 +0000 1049) // if one of them is hidden.
+f091e129dbf75 (Richard Smith 2015-09-15 01:28:55 +0000 1050) if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
+f091e129dbf75 (Richard Smith 2015-09-15 01:28:55 +0000 1051) continue;
+f091e129dbf75 (Richard Smith 2015-09-15 01:28:55 +0000 1052)
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1053) // If either declaration was introduced by a using declaration,
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1054) // we'll need to use slightly
diff erent rules for matching.
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1055) // Essentially, these rules are the normal rules, except that
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1056) // function templates hide function templates with
diff erent
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1057) // return types or template parameter lists.
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1058) bool UseMemberUsingDeclRules =
+c70fca60dab47 (John McCall 2013-04-03 21:19:47 +0000 1059) (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
+c70fca60dab47 (John McCall 2013-04-03 21:19:47 +0000 1060) !New->getFriendObjectKind();
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1061)
+a2794f9f36336 (Alp Toker 2014-01-22 07:29:52 +0000 1062) if (FunctionDecl *OldF = OldD->getAsFunction()) {
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1063) if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1064) if (UseMemberUsingDeclRules && OldIsUsingDecl) {
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1065) HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1066) continue;
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1067) }
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1068)
+a2794f9f36336 (Alp Toker 2014-01-22 07:29:52 +0000 1069) if (!isa<FunctionTemplateDecl>(OldD) &&
+a2794f9f36336 (Alp Toker 2014-01-22 07:29:52 +0000 1070) !shouldLinkPossiblyHiddenDecl(*I, New))
+5bddd6a92a0e8 (Rafael Espindola 2013-04-15 12:49:13 +0000 1071) continue;
+5bddd6a92a0e8 (Rafael Espindola 2013-04-15 12:49:13 +0000 1072)
+daa3d6bb502a3 (John McCall 2009-12-09 03:35:25 +0000 1073) Match = *I;
+daa3d6bb502a3 (John McCall 2009-12-09 03:35:25 +0000 1074) return Ovl_Match;
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1075) }
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1076)
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1077) // Builtins that have custom typechecking or have a reference should
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1078) // not be overloadable or redeclarable.
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1079) if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1080) Match = *I;
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1081) return Ovl_NonFunction;
+41af97137572a (Erich Keane 2018-04-16 21:30:08 +0000 1082) }
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 1083) } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1084) // We can overload with these, which can show up when doing
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1085) // redeclaration checks for UsingDecls.
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1086) assert(Old.getLookupKind() == LookupUsingDeclName);
+a8987a294da6d (John McCall 2010-11-10 03:01:53 +0000 1087) } else if (isa<TagDecl>(OldD)) {
+a8987a294da6d (John McCall 2010-11-10 03:01:53 +0000 1088) // We can always overload with tags by hiding them.
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1089) } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1090) // Optimistically assume that an unresolved using decl will
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1091) // overload; if it doesn't, we'll have to diagnose during
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1092) // template instantiation.
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1093) //
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1094) // Exception: if the scope is dependent and this is not a class
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1095) // member, the using declaration can only introduce an enumerator.
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1096) if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1097) Match = *I;
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1098) return Ovl_NonFunction;
+d8a9e375582fe (Richard Smith 2016-12-18 21:39:37 +0000 1099) }
+84d8767c1582d (John McCall 2009-12-10 09:41:52 +0000 1100) } else {
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1101) // (C++ 13p1):
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1102) // Only function declarations can be overloaded; object and type
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1103) // declarations cannot be overloaded.
+daa3d6bb502a3 (John McCall 2009-12-09 03:35:25 +0000 1104) Match = *I;
+daa3d6bb502a3 (John McCall 2009-12-09 03:35:25 +0000 1105) return Ovl_NonFunction;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1106) }
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1107) }
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1108)
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1109) // C++ [temp.friend]p1:
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1110) // For a friend function declaration that is not a template declaration:
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1111) // -- if the name of the friend is a qualified or unqualified template-id,
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1112) // [...], otherwise
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1113) // -- if the name of the friend is a qualified-id and a matching
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1114) // non-template function is found in the specified class or namespace,
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1115) // the friend declaration refers to that function, otherwise,
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1116) // -- if the name of the friend is a qualified-id and a matching function
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1117) // template is found in the specified class or namespace, the friend
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1118) // declaration refers to the deduced specialization of that function
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1119) // template, otherwise
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1120) // -- the name shall be an unqualified-id [...]
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1121) // If we get here for a qualified friend declaration, we've just reached the
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1122) // third bullet. If the type of the friend is dependent, skip this lookup
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1123) // until instantiation.
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1124) if (New->getFriendObjectKind() && New->getQualifier() &&
+bac77806c5881 (Richard Smith 2019-05-02 00:49:05 +0000 1125) !New->getDescribedFunctionTemplate() &&
+64095fc07c737 (Richard Smith 2019-01-11 01:59:33 +0000 1126) !New->getDependentSpecializationInfo() &&
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1127) !New->getType()->isDependentType()) {
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1128) LookupResult TemplateSpecResult(LookupResult::Temporary, Old);
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1129) TemplateSpecResult.addAllDecls(Old);
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1130) if (CheckFunctionTemplateSpecialization(New, nullptr, TemplateSpecResult,
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1131) /*QualifiedFriend*/true)) {
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1132) New->setInvalidDecl();
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1133) return Ovl_Overload;
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1134) }
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1135)
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1136) Match = TemplateSpecResult.getAsSingle<FunctionDecl>();
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1137) return Ovl_Match;
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1138) }
+8ce732b46f557 (Richard Smith 2019-01-07 06:00:46 +0000 1139)
+daa3d6bb502a3 (John McCall 2009-12-09 03:35:25 +0000 1140) return Ovl_Overload;
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1141) }
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1142)
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1143) bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1144) bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs,
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1145) bool ConsiderRequiresClauses) {
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1146) // C++ [basic.start.main]p2: This function shall not be overloaded.
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1147) if (New->isMain())
+7cf35ef8f6a0e (Rafael Espindola 2013-01-12 01:47:40 +0000 1148) return false;
+7cf35ef8f6a0e (Rafael Espindola 2013-01-12 01:47:40 +0000 1149)
+c729b0b50669e (David Majnemer 2013-09-16 22:44:20 +0000 1150) // MSVCRT user defined entry points cannot be overloaded.
+c729b0b50669e (David Majnemer 2013-09-16 22:44:20 +0000 1151) if (New->isMSVCRTEntryPoint())
+c729b0b50669e (David Majnemer 2013-09-16 22:44:20 +0000 1152) return false;
+c729b0b50669e (David Majnemer 2013-09-16 22:44:20 +0000 1153)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1154) FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1155) FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1156)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1157) // C++ [temp.fct]p2:
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1158) // A function template can be overloaded with other function templates
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1159) // and with normal (non-template) functions.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 1160) if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1161) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1162)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1163) // Is the function New an overload of the function Old?
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1164) QualType OldQType = Context.getCanonicalType(Old->getType());
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1165) QualType NewQType = Context.getCanonicalType(New->getType());
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1166)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1167) // Compare the signatures (C++ 1.3.10) of the two functions to
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1168) // determine whether they are overloads. If we find any mismatch
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1169) // in the signature, they are overloads.
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1170)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1171) // If either of these functions is a K&R-style function (no
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1172) // prototype), then we consider them to have matching signatures.
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1173) if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1174) isa<FunctionNoProtoType>(NewQType.getTypePtr()))
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1175) return false;
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1176)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1177) const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1178) const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1179)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1180) // The signature of a function includes the types of its
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1181) // parameters (C++ 1.3.10), which includes the presence or absence
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1182) // of the ellipsis; see C++ DR 357).
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1183) if (OldQType != NewQType &&
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 1184) (OldType->getNumParams() != NewType->getNumParams() ||
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1185) OldType->isVariadic() != NewType->isVariadic() ||
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 1186) !FunctionParamTypesAreEqual(OldType, NewType)))
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1187) return true;
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1188)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1189) // C++ [temp.over.link]p4:
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1190) // The signature of a function template consists of its function
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1191) // signature, its return type and its template parameter list. The names
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1192) // of the template parameters are significant only for establishing the
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1193) // relationship between the template parameters and the rest of the
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1194) // signature.
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1195) //
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1196) // We check the return type and template parameter lists for function
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1197) // templates first; the remaining checks follow.
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1198) //
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1199) // However, we don't consider either of these when deciding whether
+e9cccd86da2fe (John McCall 2010-06-16 08:42:20 +0000 1200) // a member introduced by a shadow declaration is hidden.
+39fd529935dff (Justin Lebar 2016-03-30 20:41:05 +0000 1201) if (!UseMemberUsingDeclRules && NewTemplate &&
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1202) (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1203) OldTemplate->getTemplateParameters(),
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1204) false, TPL_TemplateMatch) ||
+4576a77b80964 (Richard Smith 2018-09-10 06:35:32 +0000 1205) !Context.hasSameType(Old->getDeclaredReturnType(),
+4576a77b80964 (Richard Smith 2018-09-10 06:35:32 +0000 1206) New->getDeclaredReturnType())))
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1207) return true;
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1208)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1209) // If the function is a class member, its signature includes the
+b2f8aa9556bf9 (Douglas Gregor 2011-01-26 17:47:49 +0000 1210) // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1211) //
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1212) // As part of this, also check whether one of the member functions
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1213) // is static, in which case they are not overloads (C++
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1214) // 13.1p2). While not part of the definition of the signature,
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1215) // this check is important to determine whether these functions
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1216) // can be overloaded.
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1217) CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1218) CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1219) if (OldMethod && NewMethod &&
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1220) !OldMethod->isStatic() && !NewMethod->isStatic()) {
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1221) if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
+39fd529935dff (Justin Lebar 2016-03-30 20:41:05 +0000 1222) if (!UseMemberUsingDeclRules &&
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1223) (OldMethod->getRefQualifier() == RQ_None ||
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1224) NewMethod->getRefQualifier() == RQ_None)) {
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1225) // C++0x [over.load]p2:
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1226) // - Member function declarations with the same name and the same
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1227) // parameter-type-list as well as member function template
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1228) // declarations with the same name, the same parameter-type-list, and
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1229) // the same template parameter lists cannot be overloaded if any of
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1230) // them, but not all, have a ref-qualifier (8.3.5).
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1231) Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1232) << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
+ac974a3c76fbe (Richard Smith 2013-06-30 09:48:50 +0000 1233) Diag(OldMethod->getLocation(), diag::note_previous_declaration);
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1234) }
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1235) return true;
+c83f9865a0dae (Douglas Gregor 2011-01-26 21:20:37 +0000 1236) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1237)
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1238) // We may not have applied the implicit const for a constexpr member
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1239) // function yet (because we haven't yet resolved whether this is a static
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1240) // or non-static member function). Add it now, on the assumption that this
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1241) // is a redeclaration of OldMethod.
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 1242) auto OldQuals = OldMethod->getMethodQualifiers();
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 1243) auto NewQuals = NewMethod->getMethodQualifiers();
+dd69ef38dba72 (Aaron Ballman 2014-08-19 15:55:55 +0000 1244) if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
+e83b1d3e7aa36 (Richard Smith 2013-06-25 18:46:26 +0000 1245) !isa<CXXConstructorDecl>(NewMethod))
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 1246) NewQuals.addConst();
+42350dfcc82c0 (David Majnemer 2013-11-03 23:51:28 +0000 1247) // We do not allow overloading based off of '__restrict'.
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 1248) OldQuals.removeRestrict();
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 1249) NewQuals.removeRestrict();
+42350dfcc82c0 (David Majnemer 2013-11-03 23:51:28 +0000 1250) if (OldQuals != NewQuals)
+574f4f6a1d861 (Richard Smith 2013-01-14 05:37:29 +0000 1251) return true;
+c83f9865a0dae (Douglas Gregor 2011-01-26 21:20:37 +0000 1252) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1253)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1254) // Though pass_object_size is placed on parameters and takes an argument, we
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1255) // consider it to be a function-level modifier for the sake of function
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1256) // identity. Either the function has one or more parameters with
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1257) // pass_object_size or it doesn't.
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1258) if (functionHasPassObjectSizeParams(New) !=
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1259) functionHasPassObjectSizeParams(Old))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1260) return true;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1261)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1262) // enable_if attributes are an order-sensitive part of the signature.
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1263) for (specific_attr_iterator<EnableIfAttr>
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1264) NewI = New->specific_attr_begin<EnableIfAttr>(),
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1265) NewE = New->specific_attr_end<EnableIfAttr>(),
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1266) OldI = Old->specific_attr_begin<EnableIfAttr>(),
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1267) OldE = Old->specific_attr_end<EnableIfAttr>();
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1268) NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1269) if (NewI == NewE || OldI == OldE)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1270) return true;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1271) llvm::FoldingSetNodeID NewID, OldID;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1272) NewI->getCond()->Profile(NewID, Context, true);
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1273) OldI->getCond()->Profile(OldID, Context, true);
+d950ae74a3619 (Nick Lewycky 2014-01-21 01:30:30 +0000 1274) if (NewID != OldID)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1275) return true;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1276) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 1277)
+ba122ab42fe54 (Justin Lebar 2016-03-30 23:30:21 +0000 1278) if (getLangOpts().CUDA && ConsiderCudaAttrs) {
+e060feb7b1a98 (Justin Lebar 2016-10-03 16:48:23 +0000 1279) // Don't allow overloading of destructors. (In theory we could, but it
+e060feb7b1a98 (Justin Lebar 2016-10-03 16:48:23 +0000 1280) // would be a giant change to clang.)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1281) if (!isa<CXXDestructorDecl>(New)) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1282) CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1283) OldTarget = IdentifyCUDATarget(Old);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1284) if (NewTarget != CFT_InvalidTarget) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1285) assert((OldTarget != CFT_InvalidTarget) &&
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1286) "Unexpected invalid target.");
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1287)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1288) // Allow overloading of functions with same signature and
diff erent CUDA
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1289) // target attributes.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1290) if (NewTarget != OldTarget)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1291) return true;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1292) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1293) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1294) }
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 1295)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1296) if (ConsiderRequiresClauses) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1297) Expr *NewRC = New->getTrailingRequiresClause(),
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1298) *OldRC = Old->getTrailingRequiresClause();
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1299) if ((NewRC != nullptr) != (OldRC != nullptr))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1300) // RC are most certainly
diff erent - these are overloads.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1301) return true;
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 1302)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1303) if (NewRC) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1304) llvm::FoldingSetNodeID NewID, OldID;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1305) NewRC->Profile(NewID, Context, /*Canonical=*/true);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1306) OldRC->Profile(OldID, Context, /*Canonical=*/true);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1307) if (NewID != OldID)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1308) // RCs are not equivalent - these are overloads.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1309) return true;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 1310) }
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 1311) }
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 1312)
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1313) // The signatures match; this is not an overload.
+1f82f2462de79 (John McCall 2009-11-18 22:49:29 +0000 1314) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1315) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1316)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 1317) /// Tries a user-defined conversion from From to ToType.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1318) ///
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1319) /// Produces an implicit conversion sequence for when a standard conversion
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1320) /// is not an option. See TryImplicitConversion for more information.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1321) static ImplicitConversionSequence
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1322) TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1323) bool SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 1324) AllowedExplicit AllowExplicit,
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1325) bool InOverloadResolution,
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1326) bool CStyle,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 1327) bool AllowObjCWritebackConversion,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 1328) bool AllowObjCConversionOnExplicit) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1329) ImplicitConversionSequence ICS;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1330)
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1331) if (SuppressUserConversions) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1332) // We're not in the case above, so there is no conversion that
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1333) // we can perform.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1334) ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1335) return ICS;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1336) }
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1337)
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1338) // Attempt user-defined conversion.
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 1339) OverloadCandidateSet Conversions(From->getExprLoc(),
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 1340) OverloadCandidateSet::CSK_Normal);
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1341) switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1342) Conversions, AllowExplicit,
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1343) AllowObjCConversionOnExplicit)) {
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1344) case OR_Success:
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1345) case OR_Deleted:
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1346) ICS.setUserDefined();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1347) // C++ [over.ics.user]p4:
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1348) // A conversion of an expression of class type to the same class
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1349) // type is given Exact Match rank, and a conversion of an
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1350) // expression of class type to a base class of that type is
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1351) // given Conversion rank, in spite of the fact that a copy
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1352) // constructor (i.e., a user-defined conversion function) is
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1353) // called for those cases.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1354) if (CXXConstructorDecl *Constructor
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1355) = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1356) QualType FromCanon
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1357) = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1358) QualType ToCanon
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1359) = S.Context.getCanonicalType(ToType).getUnqualifiedType();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1360) if (Constructor->isCopyConstructor() &&
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 1361) (FromCanon == ToCanon ||
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 1362) S.IsDerivedFrom(From->getBeginLoc(), FromCanon, ToCanon))) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1363) // Turn this into a "standard" conversion sequence, so that it
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1364) // gets ranked with standard conversion sequences.
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 1365) DeclAccessPair Found = ICS.UserDefined.FoundConversionFunction;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1366) ICS.setStandard();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1367) ICS.Standard.setAsIdentityConversion();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1368) ICS.Standard.setFromType(From->getType());
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1369) ICS.Standard.setAllToTypes(ToType);
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1370) ICS.Standard.CopyConstructor = Constructor;
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 1371) ICS.Standard.FoundCopyConstructor = Found;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1372) if (ToCanon != FromCanon)
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1373) ICS.Standard.Second = ICK_Derived_To_Base;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1374) }
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1375) }
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1376) break;
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1377)
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1378) case OR_Ambiguous:
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 1379) ICS.setAmbiguous();
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 1380) ICS.Ambiguous.setFromType(From->getType());
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 1381) ICS.Ambiguous.setToType(ToType);
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 1382) for (OverloadCandidateSet::iterator Cand = Conversions.begin();
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 1383) Cand != Conversions.end(); ++Cand)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 1384) if (Cand->Best)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 1385) ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 1386) break;
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1387)
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1388) // Fall through.
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1389) case OR_No_Viable_Function:
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1390) ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 1391) break;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1392) }
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1393)
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1394) return ICS;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1395) }
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1396)
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 1397) /// TryImplicitConversion - Attempt to perform an implicit conversion
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 1398) /// from the given expression (Expr) to the given type (ToType). This
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 1399) /// function returns an implicit conversion sequence that can be used
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 1400) /// to perform the initialization. Given
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1401) ///
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1402) /// void f(float f);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1403) /// void g(int i) { f(i); }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1404) ///
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1405) /// this routine would produce an implicit conversion sequence to
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1406) /// describe the initialization of f from i, which will be a standard
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1407) /// conversion sequence containing an lvalue-to-rvalue conversion (C++
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1408) /// 4.1) followed by a floating-integral conversion (C++ 4.9).
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1409) //
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1410) /// Note that this routine only determines how the conversion can be
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1411) /// performed; it does not actually perform the conversion. As such,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1412) /// it will not produce any diagnostics if no conversion is available,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1413) /// but will instead return an implicit conversion sequence of kind
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1414) /// "BadConversion".
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 1415) ///
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 1416) /// If @p SuppressUserConversions, then user-defined conversions are
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 1417) /// not permitted.
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 1418) /// If @p AllowExplicit, then explicit user-defined conversions are
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 1419) /// permitted.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1420) ///
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1421) /// \param AllowObjCWritebackConversion Whether we allow the Objective-C
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1422) /// writeback conversion, which allows __autoreleasing id* parameters to
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1423) /// be initialized with __strong id* or __weak id* arguments.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1424) static ImplicitConversionSequence
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1425) TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1426) bool SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 1427) AllowedExplicit AllowExplicit,
+582813596a100 (Douglas Gregor 2011-01-27 00:58:17 +0000 1428) bool InOverloadResolution,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1429) bool CStyle,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 1430) bool AllowObjCWritebackConversion,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 1431) bool AllowObjCConversionOnExplicit) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1432) ImplicitConversionSequence ICS;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1433) if (IsStandardConversion(S, From, ToType, InOverloadResolution,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1434) ICS.Standard, CStyle, AllowObjCWritebackConversion)){
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 1435) ICS.setStandard();
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 1436) return ICS;
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 1437) }
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 1438)
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 1439) if (!S.getLangOpts().CPlusPlus) {
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 1440) ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 1441) return ICS;
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 1442) }
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 1443)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1444) // C++ [over.ics.user]p4:
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1445) // A conversion of an expression of class type to the same class
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1446) // type is given Exact Match rank, and a conversion of an
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1447) // expression of class type to a base class of that type is
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1448) // given Conversion rank, in spite of the fact that a copy/move
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1449) // constructor (i.e., a user-defined conversion function) is
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1450) // called for those cases.
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1451) QualType FromType = From->getType();
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1452) if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1453) (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 1454) S.IsDerivedFrom(From->getBeginLoc(), FromType, ToType))) {
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1455) ICS.setStandard();
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1456) ICS.Standard.setAsIdentityConversion();
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1457) ICS.Standard.setFromType(FromType);
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1458) ICS.Standard.setAllToTypes(ToType);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1459)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1460) // We don't actually check at this point whether there is a valid
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1461) // copy/move constructor, since overloading just assumes that it
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1462) // exists. When we actually perform initialization, we'll find the
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1463) // appropriate constructor to copy the returned object, if needed.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 1464) ICS.Standard.CopyConstructor = nullptr;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1465)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1466) // Determine whether this is considered a derived-to-base conversion.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1467) if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 1468) ICS.Standard.Second = ICK_Derived_To_Base;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1469)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1470) return ICS;
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 1471) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1472)
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1473) return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 1474) AllowExplicit, InOverloadResolution, CStyle,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 1475) AllowObjCWritebackConversion,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 1476) AllowObjCConversionOnExplicit);
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1477) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1478)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1479) ImplicitConversionSequence
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1480) Sema::TryImplicitConversion(Expr *From, QualType ToType,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1481) bool SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 1482) AllowedExplicit AllowExplicit,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1483) bool InOverloadResolution,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1484) bool CStyle,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1485) bool AllowObjCWritebackConversion) {
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 1486) return ::TryImplicitConversion(*this, From, ToType, SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 1487) AllowExplicit, InOverloadResolution, CStyle,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 1488) AllowObjCWritebackConversion,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 1489) /*AllowObjCConversionOnExplicit=*/false);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1490) }
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1491)
+ae4b5df81751e (Douglas Gregor 2010-04-16 22:27:05 +0000 1492) /// PerformImplicitConversion - Perform an implicit conversion of the
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 1493) /// expression From to the type ToType. Returns the
+ae4b5df81751e (Douglas Gregor 2010-04-16 22:27:05 +0000 1494) /// converted expression. Flavor is the kind of conversion we're
+ae4b5df81751e (Douglas Gregor 2010-04-16 22:27:05 +0000 1495) /// performing, used in the error message. If @p AllowExplicit,
+ae4b5df81751e (Douglas Gregor 2010-04-16 22:27:05 +0000 1496) /// explicit user-defined conversions are permitted.
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1497) ExprResult Sema::PerformImplicitConversion(Expr *From, QualType ToType,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1498) AssignmentAction Action,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1499) bool AllowExplicit) {
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 1500) if (checkPlaceholderForOverload(*this, From))
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 1501) return ExprError();
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 1502)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1503) // Objective-C ARC: Determine whether we will allow the writeback conversion.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1504) bool AllowObjCWritebackConversion
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 1505) = getLangOpts().ObjCAutoRefCount &&
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1506) (Action == AA_Passing || Action == AA_Sending);
+fa98390b3c314 (Erik Pilkington 2018-10-30 20:31:30 +0000 1507) if (getLangOpts().ObjC)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 1508) CheckObjCBridgeRelatedConversions(From->getBeginLoc(), ToType,
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 1509) From->getType(), From);
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1510) ImplicitConversionSequence ICS = ::TryImplicitConversion(
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1511) *this, From, ToType,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1512) /*SuppressUserConversions=*/false,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1513) AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1514) /*InOverloadResolution=*/false,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1515) /*CStyle=*/false, AllowObjCWritebackConversion,
+052dbe226cb35 (Richard Smith 2020-09-03 15:33:07 -0700 1516) /*AllowObjCConversionOnExplicit=*/false);
+ae4b5df81751e (Douglas Gregor 2010-04-16 22:27:05 +0000 1517) return PerformImplicitConversion(From, ToType, ICS, Action);
+ae4b5df81751e (Douglas Gregor 2010-04-16 22:27:05 +0000 1518) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1519)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 1520) /// Determine whether the conversion from FromType to ToType is a valid
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1521) /// conversion that strips "noexcept" or "noreturn" off the nested function
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1522) /// type.
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1523) bool Sema::IsFunctionConversion(QualType FromType, QualType ToType,
+53e61b05cedec (Chandler Carruth 2011-06-18 01:19:03 +0000 1524) QualType &ResultTy) {
+40cb9ad391af6 (Douglas Gregor 2009-12-09 00:47:37 +0000 1525) if (Context.hasSameUnqualifiedType(FromType, ToType))
+40cb9ad391af6 (Douglas Gregor 2009-12-09 00:47:37 +0000 1526) return false;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1527)
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1528) // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1529) // or F(t noexcept) -> F(t)
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1530) // where F adds one of the following at most once:
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1531) // - a pointer
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1532) // - a member pointer
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1533) // - a block pointer
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1534) // Changes here need matching changes in FindCompositePointerType.
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1535) CanQualType CanTo = Context.getCanonicalType(ToType);
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1536) CanQualType CanFrom = Context.getCanonicalType(FromType);
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1537) Type::TypeClass TyClass = CanTo->getTypeClass();
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1538) if (TyClass != CanFrom->getTypeClass()) return false;
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1539) if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1540) if (TyClass == Type::Pointer) {
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 1541) CanTo = CanTo.castAs<PointerType>()->getPointeeType();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 1542) CanFrom = CanFrom.castAs<PointerType>()->getPointeeType();
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1543) } else if (TyClass == Type::BlockPointer) {
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 1544) CanTo = CanTo.castAs<BlockPointerType>()->getPointeeType();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 1545) CanFrom = CanFrom.castAs<BlockPointerType>()->getPointeeType();
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1546) } else if (TyClass == Type::MemberPointer) {
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 1547) auto ToMPT = CanTo.castAs<MemberPointerType>();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 1548) auto FromMPT = CanFrom.castAs<MemberPointerType>();
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1549) // A function pointer conversion cannot change the class of the function.
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1550) if (ToMPT->getClass() != FromMPT->getClass())
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1551) return false;
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1552) CanTo = ToMPT->getPointeeType();
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1553) CanFrom = FromMPT->getPointeeType();
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1554) } else {
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1555) return false;
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1556) }
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1557)
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1558) TyClass = CanTo->getTypeClass();
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1559) if (TyClass != CanFrom->getTypeClass()) return false;
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1560) if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1561) return false;
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1562) }
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1563)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1564) const auto *FromFn = cast<FunctionType>(CanFrom);
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1565) FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1566)
+6f42740707bb0 (Richard Smith 2016-10-20 00:01:36 +0000 1567) const auto *ToFn = cast<FunctionType>(CanTo);
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1568) FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1569)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1570) bool Changed = false;
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1571)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1572) // Drop 'noreturn' if not present in target type.
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1573) if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1574) FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1575) Changed = true;
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1576) }
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1577)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1578) // Drop 'noexcept' if not present in target type.
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1579) if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
+6f42740707bb0 (Richard Smith 2016-10-20 00:01:36 +0000 1580) const auto *ToFPT = cast<FunctionProtoType>(ToFn);
+eaf11ad709046 (Richard Smith 2018-05-03 03:58:32 +0000 1581) if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1582) FromFn = cast<FunctionType>(
+8c85bca5a5db8 (Stephan Bergmann 2018-01-05 07:57:12 +0000 1583) Context.getFunctionTypeWithExceptionSpec(QualType(FromFPT, 0),
+8c85bca5a5db8 (Stephan Bergmann 2018-01-05 07:57:12 +0000 1584) EST_None)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1585) .getTypePtr());
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1586) Changed = true;
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1587) }
+55ebd6cc26422 (Artem Belevich 2018-04-03 18:29:31 +0000 1588)
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1589) // Convert FromFPT's ExtParameterInfo if necessary. The conversion is valid
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1590) // only if the ExtParameterInfo lists of the two function prototypes can be
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1591) // merged and the merged list is identical to ToFPT's ExtParameterInfo list.
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1592) SmallVector<FunctionProtoType::ExtParameterInfo, 4> NewParamInfos;
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1593) bool CanUseToFPT, CanUseFromFPT;
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1594) if (Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1595) CanUseFromFPT, NewParamInfos) &&
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1596) CanUseToFPT && !CanUseFromFPT) {
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1597) FunctionProtoType::ExtProtoInfo ExtInfo = FromFPT->getExtProtoInfo();
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1598) ExtInfo.ExtParameterInfos =
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1599) NewParamInfos.empty() ? nullptr : NewParamInfos.data();
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1600) QualType QT = Context.getFunctionType(FromFPT->getReturnType(),
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1601) FromFPT->getParamTypes(), ExtInfo);
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1602) FromFn = QT->getAs<FunctionType>();
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1603) Changed = true;
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 1604) }
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1605) }
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1606)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1607) if (!Changed)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1608) return false;
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1609)
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1610) assert(QualType(FromFn, 0).isCanonical());
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1611) if (QualType(FromFn, 0) != CanTo) return false;
+40cb9ad391af6 (Douglas Gregor 2009-12-09 00:47:37 +0000 1612)
+991eb4b3191ae (John McCall 2010-12-21 00:44:39 +0000 1613) ResultTy = ToType;
+40cb9ad391af6 (Douglas Gregor 2009-12-09 00:47:37 +0000 1614) return true;
+40cb9ad391af6 (Douglas Gregor 2009-12-09 00:47:37 +0000 1615) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1616)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 1617) /// Determine whether the conversion from FromType to ToType is a valid
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1618) /// vector conversion.
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1619) ///
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1620) /// \param ICK Will be set to the vector conversion kind, if this is a vector
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1621) /// conversion.
+9b595db16d614 (John McCall 2014-02-04 23:58:19 +0000 1622) static bool IsVectorConversion(Sema &S, QualType FromType,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1623) QualType ToType, ImplicitConversionKind &ICK) {
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1624) // We need at least one of these types to be a vector type to have a vector
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1625) // conversion.
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1626) if (!ToType->isVectorType() && !FromType->isVectorType())
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1627) return false;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1628)
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1629) // Identical types require no conversions.
+9b595db16d614 (John McCall 2014-02-04 23:58:19 +0000 1630) if (S.Context.hasSameUnqualifiedType(FromType, ToType))
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1631) return false;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1632)
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1633) // There are no conversions between extended vector types, only identity.
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1634) if (ToType->isExtVectorType()) {
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1635) // There are no conversions between extended vector types other than the
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1636) // identity conversion.
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1637) if (FromType->isExtVectorType())
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1638) return false;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1639)
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1640) // Vector splat from any arithmetic type to a vector.
+a3208f9e7c5d9 (Douglas Gregor 2010-06-22 23:41:02 +0000 1641) if (FromType->isArithmeticType()) {
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1642) ICK = ICK_Vector_Splat;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1643) return true;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1644) }
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1645) }
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1646)
+23a96b84a8d98 (Joe Ellis 2020-11-17 14:34:31 +0000 1647) if (ToType->isSizelessBuiltinType() || FromType->isSizelessBuiltinType())
+23a96b84a8d98 (Joe Ellis 2020-11-17 14:34:31 +0000 1648) if (S.Context.areCompatibleSveTypes(FromType, ToType) ||
+23a96b84a8d98 (Joe Ellis 2020-11-17 14:34:31 +0000 1649) S.Context.areLaxCompatibleSveTypes(FromType, ToType)) {
+23a96b84a8d98 (Joe Ellis 2020-11-17 14:34:31 +0000 1650) ICK = ICK_SVE_Vector_Conversion;
+23a96b84a8d98 (Joe Ellis 2020-11-17 14:34:31 +0000 1651) return true;
+23a96b84a8d98 (Joe Ellis 2020-11-17 14:34:31 +0000 1652) }
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 1653)
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1654) // We can perform the conversion between vector types in the following cases:
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1655) // 1)vector types are equivalent AltiVec and GCC vector types
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1656) // 2)lax vector conversions are permitted and the vector types are of the
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1657) // same size
+ada01d1b86976 (Simon Tatham 2020-01-15 14:07:04 +0000 1658) // 3)the destination type does not have the ARM MVE strict-polymorphism
+ada01d1b86976 (Simon Tatham 2020-01-15 14:07:04 +0000 1659) // attribute, which inhibits lax vector conversion for overload resolution
+ada01d1b86976 (Simon Tatham 2020-01-15 14:07:04 +0000 1660) // only
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1661) if (ToType->isVectorType() && FromType->isVectorType()) {
+9b595db16d614 (John McCall 2014-02-04 23:58:19 +0000 1662) if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
+ada01d1b86976 (Simon Tatham 2020-01-15 14:07:04 +0000 1663) (S.isLaxVectorConversion(FromType, ToType) &&
+ada01d1b86976 (Simon Tatham 2020-01-15 14:07:04 +0000 1664) !ToType->hasAttr(attr::ArmMveStrictPolymorphism))) {
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1665) ICK = ICK_Vector_Conversion;
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1666) return true;
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1667) }
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1668) }
+59e8b3bd7bf2c (Douglas Gregor 2010-08-06 10:14:59 +0000 1669)
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1670) return false;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1671) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1672)
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1673) static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1674) bool InOverloadResolution,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1675) StandardConversionSequence &SCS,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1676) bool CStyle);
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1677)
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1678) /// IsStandardConversion - Determines whether there is a standard
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1679) /// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1680) /// expression From to the type ToType. Standard conversion sequences
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1681) /// only consider non-class types; for conversions that involve class
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1682) /// types, use TryImplicitConversion. If a conversion exists, SCS will
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1683) /// contain the standard conversion sequence required to perform this
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1684) /// conversion and this routine will return true. Otherwise, this
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1685) /// routine will return false and the value of SCS is unspecified.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1686) static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1687) bool InOverloadResolution,
+582813596a100 (Douglas Gregor 2011-01-27 00:58:17 +0000 1688) StandardConversionSequence &SCS,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1689) bool CStyle,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1690) bool AllowObjCWritebackConversion) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1691) QualType FromType = From->getType();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1692)
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1693) // Standard conversions (C++ [conv])
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 1694) SCS.setAsIdentityConversion();
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 1695) SCS.IncompatibleObjC = false;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 1696) SCS.setFromType(FromType);
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 1697) SCS.CopyConstructor = nullptr;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1698)
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1699) // There are no standard conversions for class types in C++, so
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1700) // abort early. When overloading in C, however, we do permit them.
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1701) if (S.getLangOpts().CPlusPlus &&
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1702) (FromType->isRecordType() || ToType->isRecordType()))
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1703) return false;
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1704)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1705) // The first conversion can be an lvalue-to-rvalue conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1706) // array-to-pointer conversion, or function-to-pointer conversion
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1707) // (C++ 4p1).
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1708)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1709) if (FromType == S.Context.OverloadTy) {
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1710) DeclAccessPair AccessPair;
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1711) if (FunctionDecl *Fn
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1712) = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1713) AccessPair)) {
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1714) // We were able to resolve the address of the overloaded function,
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1715) // so we can convert to the type of that function.
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1716) FromType = Fn->getType();
+c3ad3bab61919 (Ehsan Akhgari 2014-07-22 20:20:14 +0000 1717) SCS.setFromType(FromType);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1718)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1719) // we can sometimes resolve &foo<int> regardless of ToType, so check
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1720) // if the type matches (identity) or we are converting to bool
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1721) if (!S.Context.hasSameUnqualifiedType(
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1722) S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1723) QualType resultTy;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1724) // if the function type matches except for [[noreturn]], it's ok
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 1725) if (!S.IsFunctionConversion(FromType,
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 1726) S.ExtractUnqualifiedFunctionType(ToType), resultTy))
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 1727) // otherwise, only a boolean conversion is standard
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 1728) if (!ToType->isBooleanType())
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 1729) return false;
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1730) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1731)
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1732) // Check if the "from" expression is taking the address of an overloaded
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1733) // function and recompute the FromType accordingly. Take advantage of the
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1734) // fact that non-static member functions *must* have such an address-of
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 1735) // expression.
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1736) CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1737) if (Method && !Method->isStatic()) {
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1738) assert(isa<UnaryOperator>(From->IgnoreParens()) &&
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1739) "Non-unary operator on non-static member address");
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1740) assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1741) == UO_AddrOf &&
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1742) "Non-address-of operator on non-static member address");
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1743) const Type *ClassType
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1744) = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1745) FromType = S.Context.getMemberPointerType(FromType, ClassType);
+7750f7694c26a (Chandler Carruth 2011-03-29 18:38:10 +0000 1746) } else if (isa<UnaryOperator>(From->IgnoreParens())) {
+7750f7694c26a (Chandler Carruth 2011-03-29 18:38:10 +0000 1747) assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==
+7750f7694c26a (Chandler Carruth 2011-03-29 18:38:10 +0000 1748) UO_AddrOf &&
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1749) "Non-address-of operator for overloaded function expression");
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1750) FromType = S.Context.getPointerType(FromType);
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1751) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1752)
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1753) // Check that we've computed the proper type after overload resolution.
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 1754) // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 1755) // be calling it from within an NDEBUG block.
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1756) assert(S.Context.hasSameType(
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1757) FromType,
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 1758) S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1759) } else {
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1760) return false;
+980fb16f9a05f (Douglas Gregor 2010-04-29 18:24:40 +0000 1761) }
+ba37e1eb49c41 (Anders Carlsson 2010-11-04 05:28:09 +0000 1762) }
+154a2fd3cb187 (John McCall 2011-08-30 00:57:29 +0000 1763) // Lvalue-to-rvalue conversion (C++11 4.1):
+154a2fd3cb187 (John McCall 2011-08-30 00:57:29 +0000 1764) // A glvalue (3.10) of a non-function, non-array type T can
+154a2fd3cb187 (John McCall 2011-08-30 00:57:29 +0000 1765) // be converted to a prvalue.
+154a2fd3cb187 (John McCall 2011-08-30 00:57:29 +0000 1766) bool argIsLValue = From->isGLValue();
+086a464e24de0 (John McCall 2010-11-24 05:12:34 +0000 1767) if (argIsLValue &&
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 1768) !FromType->isFunctionType() && !FromType->isArrayType() &&
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1769) S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1770) SCS.First = ICK_Lvalue_To_Rvalue;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1771)
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1772) // C11 6.3.2.1p2:
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 1773) // ... if the lvalue has atomic type, the value has the non-atomic version
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1774) // of the type of the lvalue ...
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1775) if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1776) FromType = Atomic->getValueType();
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1777)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1778) // If T is a non-class type, the type of the rvalue is the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1779) // cv-unqualified version of T. Otherwise, the type of the rvalue
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1780) // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1781) // just strip the qualifiers because they don't matter.
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1782) FromType = FromType.getUnqualifiedType();
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1783) } else if (FromType->isArrayType()) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1784) // Array-to-pointer conversion (C++ 4.2)
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1785) SCS.First = ICK_Array_To_Pointer;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1786)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1787) // An lvalue or rvalue of type "array of N T" or "array of unknown
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1788) // bound of T" can be converted to an rvalue of type "pointer to
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1789) // T" (C++ 4.2p1).
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1790) FromType = S.Context.getArrayDecayedType(FromType);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1791)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1792) if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 1793) // This conversion is deprecated in C++03 (D.4)
+e489a7d3d3972 (Douglas Gregor 2010-02-28 18:30:25 +0000 1794) SCS.DeprecatedStringLiteralToCharPtr = true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1795)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1796) // For the purpose of ranking in overload resolution
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1797) // (13.3.3.1.1), this conversion is considered an
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1798) // array-to-pointer conversion followed by a qualification
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1799) // conversion (4.4). (C++ 4.2p2)
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1800) SCS.Second = ICK_Identity;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1801) SCS.Third = ICK_Qualification;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1802) SCS.QualificationIncludesObjCLifetime = false;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 1803) SCS.setAllToTypes(FromType);
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1804) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1805) }
+086a464e24de0 (John McCall 2010-11-24 05:12:34 +0000 1806) } else if (FromType->isFunctionType() && argIsLValue) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1807) // Function-to-pointer conversion (C++ 4.3).
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1808) SCS.First = ICK_Function_To_Pointer;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1809)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1810) if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1811) if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1812) if (!S.checkAddressOfFunctionIsAvailable(FD))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1813) return false;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 1814)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1815) // An lvalue of function type T can be converted to an rvalue of
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1816) // type "pointer to T." The result is a pointer to the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1817) // function. (C++ 4.3p1).
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1818) FromType = S.Context.getPointerType(FromType);
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1819) } else {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1820) // We don't require any conversions for the first step.
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1821) SCS.First = ICK_Identity;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1822) }
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 1823) SCS.setToType(0, FromType);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1824)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1825) // The second conversion can be an integral promotion, floating
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1826) // point promotion, integral conversion, floating point conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1827) // floating-integral conversion, pointer conversion,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1828) // pointer-to-member conversion, or boolean conversion (C++ 4p1).
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1829) // For overloading in C, this can also be a "compatible-type"
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1830) // conversion.
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 1831) bool IncompatibleObjC = false;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1832) ImplicitConversionKind SecondICK = ICK_Identity;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1833) if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1834) // The unqualified versions of the types are the same: there's no
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1835) // conversion to do.
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1836) SCS.Second = ICK_Identity;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1837) } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 1838) // Integral promotion (C++ 4.5).
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1839) SCS.Second = ICK_Integral_Promotion;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1840) FromType = ToType.getUnqualifiedType();
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1841) } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1842) // Floating point promotion (C++ 4.6).
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1843) SCS.Second = ICK_Floating_Promotion;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1844) FromType = ToType.getUnqualifiedType();
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1845) } else if (S.IsComplexPromotion(FromType, ToType)) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1846) // Complex promotion (Clang extension)
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 1847) SCS.Second = ICK_Complex_Promotion;
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 1848) FromType = ToType.getUnqualifiedType();
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1849) } else if (ToType->isBooleanType() &&
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1850) (FromType->isArithmeticType() ||
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1851) FromType->isAnyPointerType() ||
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1852) FromType->isBlockPointerType() ||
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 1853) FromType->isMemberPointerType())) {
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1854) // Boolean conversions (C++ 4.12).
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1855) SCS.Second = ICK_Boolean_Conversion;
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1856) FromType = S.Context.BoolTy;
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 1857) } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1858) ToType->isIntegralType(S.Context)) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1859) // Integral conversions (C++ 4.7).
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1860) SCS.Second = ICK_Integral_Conversion;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1861) FromType = ToType.getUnqualifiedType();
+b8a98241fce39 (Richard Smith 2013-05-10 20:29:50 +0000 1862) } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1863) // Complex conversions (C99 6.3.1.6)
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 1864) SCS.Second = ICK_Complex_Conversion;
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 1865) FromType = ToType.getUnqualifiedType();
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1866) } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1867) (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
+8fa1e7eec4d0a (Chandler Carruth 2010-02-25 07:20:54 +0000 1868) // Complex-real conversions (C99 6.3.1.7)
+8fa1e7eec4d0a (Chandler Carruth 2010-02-25 07:20:54 +0000 1869) SCS.Second = ICK_Complex_Real;
+8fa1e7eec4d0a (Chandler Carruth 2010-02-25 07:20:54 +0000 1870) FromType = ToType.getUnqualifiedType();
+49b4d73451955 (Douglas Gregor 2010-06-22 23:07:26 +0000 1871) } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1872) // FIXME: disable conversions between long double and __float128 if
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1873) // their representation is
diff erent until there is back end support
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1874) // We of course allow this conversion if long double is really double.
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1875)
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1876) // Conversions between bfloat and other floats are not permitted.
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1877) if (FromType == S.Context.BFloat16Ty || ToType == S.Context.BFloat16Ty)
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1878) return false;
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1879) if (&S.Context.getFloatTypeSemantics(FromType) !=
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1880) &S.Context.getFloatTypeSemantics(ToType)) {
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1881) bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1882) ToType == S.Context.LongDoubleTy) ||
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1883) (FromType == S.Context.LongDoubleTy &&
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1884) ToType == S.Context.Float128Ty));
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1885) if (Float128AndLongDouble &&
+980579504ae2d (Benjamin Kramer 2018-01-17 22:56:57 +0000 1886) (&S.Context.getFloatTypeSemantics(S.Context.LongDoubleTy) ==
+980579504ae2d (Benjamin Kramer 2018-01-17 22:56:57 +0000 1887) &llvm::APFloat::PPCDoubleDouble()))
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1888) return false;
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 1889) }
+8fa1e7eec4d0a (Chandler Carruth 2010-02-25 07:20:54 +0000 1890) // Floating point conversions (C++ 4.8).
+8fa1e7eec4d0a (Chandler Carruth 2010-02-25 07:20:54 +0000 1891) SCS.Second = ICK_Floating_Conversion;
+8fa1e7eec4d0a (Chandler Carruth 2010-02-25 07:20:54 +0000 1892) FromType = ToType.getUnqualifiedType();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1893) } else if ((FromType->isRealFloatingType() &&
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 1894) ToType->isIntegralType(S.Context)) ||
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 1895) (FromType->isIntegralOrUnscopedEnumerationType() &&
+49b4d73451955 (Douglas Gregor 2010-06-22 23:07:26 +0000 1896) ToType->isRealFloatingType())) {
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1897) // Conversions between bfloat and int are not permitted.
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1898) if (FromType->isBFloat16Type() || ToType->isBFloat16Type())
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1899) return false;
+ecd682bbf5e69 (Ties Stuij 2020-06-05 00:20:02 +0100 1900)
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1901) // Floating-integral conversions (C++ 4.9).
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1902) SCS.Second = ICK_Floating_Integral;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1903) FromType = ToType.getUnqualifiedType();
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 1904) } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1905) SCS.Second = ICK_Block_Pointer_Conversion;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1906) } else if (AllowObjCWritebackConversion &&
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1907) S.isObjCWritebackConversion(FromType, ToType, FromType)) {
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1908) SCS.Second = ICK_Writeback_Conversion;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1909) } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1910) FromType, IncompatibleObjC)) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1911) // Pointer conversions (C++ 4.10).
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1912) SCS.Second = ICK_Pointer_Conversion;
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 1913) SCS.IncompatibleObjC = IncompatibleObjC;
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 1914) FromType = FromType.getUnqualifiedType();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 1915) } else if (S.IsMemberPointerConversion(From, FromType, ToType,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1916) InOverloadResolution, FromType)) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1917) // Pointer to member conversions (4.11).
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 1918) SCS.Second = ICK_Pointer_Member;
+9b595db16d614 (John McCall 2014-02-04 23:58:19 +0000 1919) } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1920) SCS.Second = SecondICK;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1921) FromType = ToType.getUnqualifiedType();
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 1922) } else if (!S.getLangOpts().CPlusPlus &&
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 1923) S.Context.typesAreCompatible(ToType, FromType)) {
+12b8ce168d4e3 (Mike Stump 2009-08-04 21:02:39 +0000 1924) // Compatible conversions (Clang extension for C function overloading)
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 1925) SCS.Second = ICK_Compatible_Conversion;
+4618868a7d0de (Douglas Gregor 2010-05-18 22:42:18 +0000 1926) FromType = ToType.getUnqualifiedType();
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 1927) } else if (IsTransparentUnionStandardConversion(S, From, ToType,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 1928) InOverloadResolution,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 1929) SCS, CStyle)) {
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 1930) SCS.Second = ICK_TransparentUnionConversion;
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 1931) FromType = ToType;
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1932) } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1933) CStyle)) {
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 1934) // tryAtomicConversion has updated the standard conversion sequence
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1935) // appropriately.
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 1936) return true;
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1937) } else if (ToType->isEventT() &&
+259f9f4531e5c (Guy Benyei 2013-02-07 16:05:33 +0000 1938) From->isIntegerConstantExpr(S.getASTContext()) &&
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1939) From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
+259f9f4531e5c (Guy Benyei 2013-02-07 16:05:33 +0000 1940) SCS.Second = ICK_Zero_Event_Conversion;
+259f9f4531e5c (Guy Benyei 2013-02-07 16:05:33 +0000 1941) FromType = ToType;
+89831421af27b (Egor Churaev 2016-12-23 14:55:49 +0000 1942) } else if (ToType->isQueueT() &&
+89831421af27b (Egor Churaev 2016-12-23 14:55:49 +0000 1943) From->isIntegerConstantExpr(S.getASTContext()) &&
+89831421af27b (Egor Churaev 2016-12-23 14:55:49 +0000 1944) (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
+89831421af27b (Egor Churaev 2016-12-23 14:55:49 +0000 1945) SCS.Second = ICK_Zero_Queue_Conversion;
+89831421af27b (Egor Churaev 2016-12-23 14:55:49 +0000 1946) FromType = ToType;
+8ece3b6719948 (Neil Hickey 2019-07-16 14:57:32 +0000 1947) } else if (ToType->isSamplerT() &&
+8ece3b6719948 (Neil Hickey 2019-07-16 14:57:32 +0000 1948) From->isIntegerConstantExpr(S.getASTContext())) {
+8ece3b6719948 (Neil Hickey 2019-07-16 14:57:32 +0000 1949) SCS.Second = ICK_Compatible_Conversion;
+8ece3b6719948 (Neil Hickey 2019-07-16 14:57:32 +0000 1950) FromType = ToType;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1951) } else {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1952) // No second conversion required.
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1953) SCS.Second = ICK_Identity;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1954) }
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 1955) SCS.setToType(1, FromType);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1956)
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1957) // The third conversion can be a function pointer conversion or a
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1958) // qualification conversion (C++ [conv.fctptr], [conv.qual]).
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1959) bool ObjCLifetimeConversion;
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1960) if (S.IsFunctionConversion(FromType, ToType, FromType)) {
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1961) // Function pointer conversions (removing 'noexcept') including removal of
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1962) // 'noreturn' (Clang extension).
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1963) SCS.Third = ICK_Function_Conversion;
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1964) } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1965) ObjCLifetimeConversion)) {
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1966) SCS.Third = ICK_Qualification;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 1967) SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1968) FromType = ToType;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1969) } else {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1970) // No conversion required
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1971) SCS.Third = ICK_Identity;
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1972) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 1973)
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1974) // C++ [over.best.ics]p6:
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1975) // [...] Any
diff erence in top-level cv-qualification is
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1976) // subsumed by the initialization itself and does not constitute
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1977) // a conversion. [...]
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1978) QualType CanonFrom = S.Context.getCanonicalType(FromType);
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1979) QualType CanonTo = S.Context.getCanonicalType(ToType);
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1980) if (CanonFrom.getLocalUnqualifiedType()
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1981) == CanonTo.getLocalUnqualifiedType() &&
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1982) CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1983) FromType = ToType;
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1984) CanonFrom = CanonTo;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1985) }
+eb7ef2e1cae45 (Richard Smith 2016-10-20 21:53:09 +0000 1986)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 1987) SCS.setToType(2, FromType);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1988)
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1989) if (CanonFrom == CanonTo)
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1990) return true;
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1991)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 1992) // If we have not converted the argument type to the parameter type,
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1993) // this is a bad conversion sequence, unless we're resolving an overload in C.
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1994) if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1995) return false;
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1996)
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 1997) ExprResult ER = ExprResult{From};
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 1998) Sema::AssignConvertType Conv =
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 1999) S.CheckSingleAssignmentConstraints(ToType, ER,
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2000) /*Diagnose=*/false,
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2001) /*DiagnoseCFAudited=*/false,
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2002) /*ConvertRHS=*/false);
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2003) ImplicitConversionKind SecondConv;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2004) switch (Conv) {
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2005) case Sema::Compatible:
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2006) SecondConv = ICK_C_Only_Conversion;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2007) break;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2008) // For our purposes, discarding qualifiers is just as bad as using an
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2009) // incompatible pointer. Note that an IncompatiblePointer conversion can drop
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2010) // qualifiers, as well.
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2011) case Sema::CompatiblePointerDiscardsQualifiers:
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2012) case Sema::IncompatiblePointer:
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2013) case Sema::IncompatiblePointerSign:
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2014) SecondConv = ICK_Incompatible_Pointer_Conversion;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2015) break;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2016) default:
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 2017) return false;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2018) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2019)
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2020) // First can only be an lvalue conversion, so we pretend that this was the
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2021) // second conversion. First should already be valid from earlier in the
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2022) // function.
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2023) SCS.Second = SecondConv;
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2024) SCS.setToType(1, ToType);
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2025)
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2026) // Third is Identity, because Second should rank us worse than any other
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2027) // conversion. This could also be ICK_Qualification, but it's simpler to just
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2028) // lump everything in with the second conversion, and we don't gain anything
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2029) // from making this ICK_Qualification.
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2030) SCS.Third = ICK_Identity;
+6098fd1989f6b (George Burgess IV 2016-09-03 00:28:25 +0000 2031) SCS.setToType(2, ToType);
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 2032) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2033) }
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 2034)
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2035) static bool
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2036) IsTransparentUnionStandardConversion(Sema &S, Expr* From,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2037) QualType &ToType,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2038) bool InOverloadResolution,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2039) StandardConversionSequence &SCS,
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2040) bool CStyle) {
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2041)
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2042) const RecordType *UT = ToType->getAsUnionType();
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2043) if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2044) return false;
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2045) // The field to initialize within the transparent union.
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2046) RecordDecl *UD = UT->getDecl();
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2047) // It's compatible if the expression matches any of the fields.
+e8a8baef44c4d (Aaron Ballman 2014-03-08 20:12:42 +0000 2048) for (const auto *it : UD->fields()) {
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2049) if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 2050) CStyle, /*AllowObjCWritebackConversion=*/false)) {
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2051) ToType = it->getType();
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2052) return true;
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2053) }
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2054) }
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2055) return false;
+16f92ce539d49 (Fariborz Jahanian 2011-03-23 19:50:54 +0000 2056) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2057)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2058) /// IsIntegralPromotion - Determines whether the conversion from the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2059) /// expression From (whose potentially-adjusted type is FromType) to
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2060) /// ToType is an integral promotion (C++ 4.5). If so, returns true and
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2061) /// sets PromotedType to the promoted type.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2062) bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2063) const BuiltinType *To = ToType->getAs<BuiltinType>();
+ee54797234ec4 (Sebastian Redl 2008-11-04 15:59:10 +0000 2064) // All integers are built-in.
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2065) if (!To) {
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2066) return false;
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2067) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2068)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2069) // An rvalue of type char, signed char, unsigned char, short int, or
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2070) // unsigned short int can be converted to an rvalue of type int if
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2071) // int can represent all the values of the source type; otherwise,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2072) // the source rvalue can be converted to an rvalue of type unsigned
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2073) // int (C++ 4.5p1).
+a71cc1536167f (Douglas Gregor 2010-02-02 20:10:50 +0000 2074) if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
+a71cc1536167f (Douglas Gregor 2010-02-02 20:10:50 +0000 2075) !FromType->isEnumeralType()) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2076) if (// We can promote any signed, promotable integer type to an int
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2077) (FromType->isSignedIntegerType() ||
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2078) // We can promote any unsigned integer type whose size is
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2079) // less than int to an int.
+5ff6747e04021 (Benjamin Kramer 2016-04-11 08:26:13 +0000 2080) Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2081) return To->getKind() == BuiltinType::Int;
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2082) }
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2083)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2084) return To->getKind() == BuiltinType::UInt;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2085) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2086)
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2087) // C++11 [conv.prom]p3:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2088) // A prvalue of an unscoped enumeration type whose underlying type is not
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2089) // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2090) // following types that can represent all the values of the enumeration
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2091) // (i.e., the values in the range bmin to bmax as described in 7.2): int,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2092) // unsigned int, long int, unsigned long int, long long int, or unsigned
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2093) // long long int. If none of the types in that list can represent all the
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2094) // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2095) // type can be converted to an rvalue a prvalue of the extended integer type
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2096) // with lowest integer conversion rank (4.13) greater than the rank of long
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2097) // long in which all the values of the enumeration can be represented. If
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2098) // there are two such extended types, the signed one is chosen.
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2099) // C++11 [conv.prom]p4:
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2100) // A prvalue of an unscoped enumeration type whose underlying type is fixed
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2101) // can be converted to a prvalue of its underlying type. Moreover, if
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2102) // integral promotion can be applied to its underlying type, a prvalue of an
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2103) // unscoped enumeration type whose underlying type is fixed can also be
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2104) // converted to a prvalue of the promoted underlying type.
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2105) if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2106) // C++0x 7.2p9: Note that this implicit enum to int conversion is not
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2107) // provided for a scoped enumeration.
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2108) if (FromEnumType->getDecl()->isScoped())
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2109) return false;
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2110)
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2111) // We can perform an integral promotion to the underlying type of the enum,
+ac8c17533f5dd (Richard Smith 2015-03-28 00:31:40 +0000 2112) // even if that's not the promoted type. Note that the check for promoting
+ac8c17533f5dd (Richard Smith 2015-03-28 00:31:40 +0000 2113) // the underlying type is based on the type alone, and does not consider
+ac8c17533f5dd (Richard Smith 2015-03-28 00:31:40 +0000 2114) // the bitfield-ness of the actual source expression.
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2115) if (FromEnumType->getDecl()->isFixed()) {
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2116) QualType Underlying = FromEnumType->getDecl()->getIntegerType();
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2117) return Context.hasSameUnqualifiedType(Underlying, ToType) ||
+ac8c17533f5dd (Richard Smith 2015-03-28 00:31:40 +0000 2118) IsIntegralPromotion(nullptr, Underlying, ToType);
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2119) }
+b9c5a60045681 (Richard Smith 2012-09-13 21:18:54 +0000 2120)
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2121) // We have already pre-calculated the promotion type, so this is trivial.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2122) if (ToType->isIntegerType() &&
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 2123) isCompleteType(From->getBeginLoc(), FromType))
+88f4bba21e9ea (Richard Smith 2015-03-26 00:16:07 +0000 2124) return Context.hasSameUnqualifiedType(
+88f4bba21e9ea (Richard Smith 2015-03-26 00:16:07 +0000 2125) ToType, FromEnumType->getDecl()->getPromotionType());
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2126)
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2127) // C++ [conv.prom]p5:
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2128) // If the bit-field has an enumerated type, it is treated as any other
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2129) // value of that type for promotion purposes.
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2130) //
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2131) // ... so do not fall through into the bit-field checks below in C++.
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2132) if (getLangOpts().CPlusPlus)
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2133) return false;
+0bf3140424a0a (Douglas Gregor 2010-10-08 23:50:27 +0000 2134) }
+5677499fbffe3 (John McCall 2009-12-09 09:09:27 +0000 2135)
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2136) // C++0x [conv.prom]p2:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2137) // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2138) // to an rvalue a prvalue of the first of the following types that can
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2139) // represent all the values of its underlying type: int, unsigned int,
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2140) // long int, unsigned long int, long long int, or unsigned long long int.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2141) // If none of the types in that list can represent all the values of its
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2142) // underlying type, an rvalue a prvalue of type char16_t, char32_t,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2143) // or wchar_t can be converted to an rvalue a prvalue of its underlying
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2144) // type.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2145) if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
+cd1d0b4f98805 (Douglas Gregor 2010-10-21 18:04:08 +0000 2146) ToType->isIntegerType()) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2147) // Determine whether the type we're converting from is signed or
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2148) // unsigned.
+fa01a583e7106 (David Majnemer 2011-07-22 21:09:04 +0000 2149) bool FromIsSigned = FromType->isSignedIntegerType();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2150) uint64_t FromSize = Context.getTypeSize(FromType);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2151)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2152) // The types we'll try to promote to, in the appropriate
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2153) // order. Try each of these types.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2154) QualType PromoteTypes[6] = {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2155) Context.IntTy, Context.UnsignedIntTy,
+1d248c53ab1c5 (Douglas Gregor 2008-12-12 02:00:36 +0000 2156) Context.LongTy, Context.UnsignedLongTy ,
+1d248c53ab1c5 (Douglas Gregor 2008-12-12 02:00:36 +0000 2157) Context.LongLongTy, Context.UnsignedLongLongTy
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2158) };
+1d248c53ab1c5 (Douglas Gregor 2008-12-12 02:00:36 +0000 2159) for (int Idx = 0; Idx < 6; ++Idx) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2160) uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2161) if (FromSize < ToSize ||
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2162) (FromSize == ToSize &&
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2163) FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2164) // We found the type that we can promote to. If this is the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2165) // type we wanted, we have a promotion. Otherwise, no
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2166) // promotion.
+1b8fe5b716b8b (Douglas Gregor 2009-11-16 21:35:15 +0000 2167) return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2168) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2169) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2170) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2171)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2172) // An rvalue for an integral bit-field (9.6) can be converted to an
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2173) // rvalue of type int if int can represent all the values of the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2174) // bit-field; otherwise, it can be converted to unsigned int if
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2175) // unsigned int can represent all the values of the bit-field. If
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2176) // the bit-field is larger yet, no integral promotion applies to
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2177) // it. If the bit-field has an enumerated type, it is treated as any
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2178) // other value of that type for promotion purposes (C++ 4.5p3).
+87c57acfb760e (Mike Stump 2009-05-16 07:39:55 +0000 2179) // FIXME: We should delay checking of bit-fields until we actually perform the
+87c57acfb760e (Mike Stump 2009-05-16 07:39:55 +0000 2180) // conversion.
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2181) //
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2182) // FIXME: In C, only bit-fields of types _Bool, int, or unsigned int may be
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2183) // promoted, per C11 6.3.1.1/2. We promote all bit-fields (including enum
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2184) // bit-fields and those whose underlying type is larger than int) for GCC
+aadb254a79558 (Richard Smith 2018-06-28 21:17:55 +0000 2185) // compatibility.
+88f4bba21e9ea (Richard Smith 2015-03-26 00:16:07 +0000 2186) if (From) {
+d25db7ed0f8ec (John McCall 2013-05-06 21:39:12 +0000 2187) if (FieldDecl *MemberDecl = From->getSourceBitField()) {
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2188) Optional<llvm::APSInt> BitWidth;
+6972a62c8feda (Douglas Gregor 2010-06-16 00:35:25 +0000 2189) if (FromType->isIntegralType(Context) &&
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2190) (BitWidth =
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2191) MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2192) llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
+71235ecb7fa32 (Douglas Gregor 2009-05-02 02:18:30 +0000 2193) ToSize = Context.getTypeSize(ToType);
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2194)
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2195) // Are we promoting to an int from a bitfield that fits in an int?
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2196) if (*BitWidth < ToSize ||
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2197) (FromType->isSignedIntegerType() && *BitWidth <= ToSize)) {
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2198) return To->getKind() == BuiltinType::Int;
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2199) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2200)
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2201) // Are we promoting to an unsigned int from an unsigned bitfield
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2202) // that fits into an unsigned int?
+36036aa70ec1d (David Blaikie 2020-07-12 20:31:08 -0700 2203) if (FromType->isUnsignedIntegerType() && *BitWidth <= ToSize) {
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2204) return To->getKind() == BuiltinType::UInt;
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2205) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2206)
+2eedc3aa1ce4a (Douglas Gregor 2008-12-20 23:49:58 +0000 2207) return false;
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2208) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2209) }
+88f4bba21e9ea (Richard Smith 2015-03-26 00:16:07 +0000 2210) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2211)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2212) // An rvalue of type bool can be converted to an rvalue of type int,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2213) // with false becoming zero and true becoming one (C++ 4.5p4).
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2214) if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2215) return true;
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2216) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2217)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2218) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2219) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2220)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2221) /// IsFloatingPointPromotion - Determines whether the conversion from
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2222) /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2223) /// returns true and sets PromotedType to the promoted type.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2224) bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2225) if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2226) if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
+f0c267e6e05c2 (Anton Korobeynikov 2011-10-14 23:23:15 +0000 2227) /// An rvalue of type float can be converted to an rvalue of type
+f0c267e6e05c2 (Anton Korobeynikov 2011-10-14 23:23:15 +0000 2228) /// double. (C++ 4.6p1).
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2229) if (FromBuiltin->getKind() == BuiltinType::Float &&
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2230) ToBuiltin->getKind() == BuiltinType::Double)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2231) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2232)
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2233) // C99 6.3.1.5p1:
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2234) // When a float is promoted to double or long double, or a
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2235) // double is promoted to long double [...].
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 2236) if (!getLangOpts().CPlusPlus &&
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2237) (FromBuiltin->getKind() == BuiltinType::Float ||
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2238) FromBuiltin->getKind() == BuiltinType::Double) &&
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 2239) (ToBuiltin->getKind() == BuiltinType::LongDouble ||
+bb1ea2d6139a7 (Nemanja Ivanovic 2016-05-09 08:52:33 +0000 2240) ToBuiltin->getKind() == BuiltinType::Float128))
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2241) return true;
+f0c267e6e05c2 (Anton Korobeynikov 2011-10-14 23:23:15 +0000 2242)
+f0c267e6e05c2 (Anton Korobeynikov 2011-10-14 23:23:15 +0000 2243) // Half can be promoted to float.
+dd7f4566b1a8b (Joey Gouly 2013-01-23 11:56:20 +0000 2244) if (!getLangOpts().NativeHalfType &&
+dd7f4566b1a8b (Joey Gouly 2013-01-23 11:56:20 +0000 2245) FromBuiltin->getKind() == BuiltinType::Half &&
+f0c267e6e05c2 (Anton Korobeynikov 2011-10-14 23:23:15 +0000 2246) ToBuiltin->getKind() == BuiltinType::Float)
+f0c267e6e05c2 (Anton Korobeynikov 2011-10-14 23:23:15 +0000 2247) return true;
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2248) }
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2249)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2250) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2251) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2252)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 2253) /// Determine if a conversion is a complex promotion.
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2254) ///
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2255) /// A complex promotion is defined as a complex -> complex conversion
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2256) /// where the conversion between the underlying real types is a
+6752502b81367 (Douglas Gregor 2009-02-12 00:26:06 +0000 2257) /// floating-point or integral promotion.
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2258) bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2259) const ComplexType *FromComplex = FromType->getAs<ComplexType>();
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2260) if (!FromComplex)
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2261) return false;
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2262)
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2263) const ComplexType *ToComplex = ToType->getAs<ComplexType>();
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2264) if (!ToComplex)
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2265) return false;
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2266)
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2267) return IsFloatingPointPromotion(FromComplex->getElementType(),
+6752502b81367 (Douglas Gregor 2009-02-12 00:26:06 +0000 2268) ToComplex->getElementType()) ||
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 2269) IsIntegralPromotion(nullptr, FromComplex->getElementType(),
+6752502b81367 (Douglas Gregor 2009-02-12 00:26:06 +0000 2270) ToComplex->getElementType());
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2271) }
+78ca74d81d935 (Douglas Gregor 2009-02-12 00:15:05 +0000 2272)
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2273) /// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2274) /// the pointer type FromPtr to a pointer to type ToPointee, with the
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2275) /// same type qualifiers as FromPtr has on its pointee type. ToType,
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2276) /// if non-empty, will be a pointer to ToType that may or may not have
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2277) /// the right set of qualifiers on its pointee.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2278) ///
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2279) static QualType
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2280) BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2281) QualType ToPointee, QualType ToType,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2282) ASTContext &Context,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2283) bool StripObjCLifetime = false) {
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2284) assert((FromPtr->getTypeClass() == Type::Pointer ||
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2285) FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2286) "Invalid similarly-qualified pointer type");
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2287)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2288) /// Conversions to 'id' subsume cv-qualifier conversions.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2289) if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
+c6bd1d32bf20b (Douglas Gregor 2010-12-06 22:09:19 +0000 2290) return ToType.getUnqualifiedType();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2291)
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2292) QualType CanonFromPointee
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2293) = Context.getCanonicalType(FromPtr->getPointeeType());
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2294) QualType CanonToPointee = Context.getCanonicalType(ToPointee);
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 2295) Qualifiers Quals = CanonFromPointee.getQualifiers();
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2296)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2297) if (StripObjCLifetime)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2298) Quals.removeObjCLifetime();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2299)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2300) // Exact qualifier match -> return the pointer type we're converting to.
+1b8fe5b716b8b (Douglas Gregor 2009-11-16 21:35:15 +0000 2301) if (CanonToPointee.getLocalQualifiers() == Quals) {
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2302) // ToType is exactly what we need. Return it.
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 2303) if (!ToType.isNull())
+b9f907bafc77c (Douglas Gregor 2010-05-25 15:31:05 +0000 2304) return ToType.getUnqualifiedType();
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2305)
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2306) // Build a pointer to ToPointee. It has the right qualifiers
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2307) // already.
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2308) if (isa<ObjCObjectPointerType>(ToType))
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2309) return Context.getObjCObjectPointerType(ToPointee);
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2310) return Context.getPointerType(ToPointee);
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2311) }
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2312)
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2313) // Just build a canonical type that has the right qualifiers.
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2314) QualType QualifiedCanonToPointee
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2315) = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2316)
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2317) if (isa<ObjCObjectPointerType>(ToType))
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2318) return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2319) return Context.getPointerType(QualifiedCanonToPointee);
+01cbe441b31f3 (Fariborz Jahanian 2009-12-16 23:13:33 +0000 2320) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2321)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2322) static bool isNullPointerConstantForConversion(Expr *Expr,
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2323) bool InOverloadResolution,
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2324) ASTContext &Context) {
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2325) // Handle value-dependent integral null pointer constants correctly.
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2326) // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2327) if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
+b90df60b3b0f7 (Douglas Gregor 2010-06-16 00:17:44 +0000 2328) Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2329) return !InOverloadResolution;
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2330)
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 2331) return Expr->isNullPointerConstant(Context,
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 2332) InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 2333) : Expr::NPC_ValueDependentIsNull);
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2334) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2335)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2336) /// IsPointerConversion - Determines whether the conversion of the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2337) /// expression From, which has the (possibly adjusted) type FromType,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2338) /// can be converted to the type ToType via a pointer conversion (C++
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2339) /// 4.10). If so, returns true and places the converted type (that
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2340) /// might
diff er from ToType in its cv-qualifiers at some level) into
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2341) /// ConvertedType.
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2342) ///
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 2343) /// This routine also supports conversions to and from block pointers
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 2344) /// and conversions with Objective-C's 'id', 'id<protocols...>', and
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 2345) /// pointers to interfaces. FIXME: Once we've determined the
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 2346) /// appropriate overloading rules for Objective-C, we may want to
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 2347) /// split the Objective-C checks into a
diff erent routine; however,
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 2348) /// GCC seems to consider all of these conversions to be pointer
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 2349) /// conversions, so for now they live here. IncompatibleObjC will be
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 2350) /// set if the conversion is an allowed Objective-C conversion that
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 2351) /// should result in a warning.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2352) bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
+228eea36a3598 (Anders Carlsson 2009-08-28 15:33:32 +0000 2353) bool InOverloadResolution,
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 2354) QualType& ConvertedType,
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2355) bool &IncompatibleObjC) {
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 2356) IncompatibleObjC = false;
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 2357) if (isObjCPointerConversion(FromType, ToType, ConvertedType,
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 2358) IncompatibleObjC))
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2359) return true;
+47d3f2742a3b6 (Douglas Gregor 2008-12-19 17:40:08 +0000 2360)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2361) // Conversion from a null pointer constant to any Objective-C pointer type.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2362) if (ToType->isObjCObjectPointerType() &&
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2363) isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
+79a6b01802bdb (Douglas Gregor 2008-12-22 20:51:52 +0000 2364) ConvertedType = ToType;
+79a6b01802bdb (Douglas Gregor 2008-12-22 20:51:52 +0000 2365) return true;
+79a6b01802bdb (Douglas Gregor 2008-12-22 20:51:52 +0000 2366) }
+79a6b01802bdb (Douglas Gregor 2008-12-22 20:51:52 +0000 2367)
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2368) // Blocks: Block pointers can be converted to void*.
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2369) if (FromType->isBlockPointerType() && ToType->isPointerType() &&
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 2370) ToType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2371) ConvertedType = ToType;
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2372) return true;
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2373) }
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2374) // Blocks: A null pointer constant can be converted to a block
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2375) // pointer type.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2376) if (ToType->isBlockPointerType() &&
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2377) isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2378) ConvertedType = ToType;
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2379) return true;
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2380) }
+231d1c6f8f4e4 (Douglas Gregor 2008-11-27 00:15:41 +0000 2381)
+576fd424dfe20 (Sebastian Redl 2009-05-10 18:38:11 +0000 2382) // If the left-hand-side is nullptr_t, the right side can be a null
+576fd424dfe20 (Sebastian Redl 2009-05-10 18:38:11 +0000 2383) // pointer constant.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2384) if (ToType->isNullPtrType() &&
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2385) isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
+576fd424dfe20 (Sebastian Redl 2009-05-10 18:38:11 +0000 2386) ConvertedType = ToType;
+576fd424dfe20 (Sebastian Redl 2009-05-10 18:38:11 +0000 2387) return true;
+576fd424dfe20 (Sebastian Redl 2009-05-10 18:38:11 +0000 2388) }
+576fd424dfe20 (Sebastian Redl 2009-05-10 18:38:11 +0000 2389)
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 2390) const PointerType* ToTypePtr = ToType->getAs<PointerType>();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2391) if (!ToTypePtr)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2392) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2393)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2394) // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
+759b78951e44e (Anders Carlsson 2009-08-28 15:55:56 +0000 2395) if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2396) ConvertedType = ToType;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2397) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2398) }
+72b8aef613170 (Sebastian Redl 2008-10-31 14:43:28 +0000 2399)
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2400) // Beyond this point, both types need to be pointers
+01cbe441b31f3 (Fariborz Jahanian 2009-12-16 23:13:33 +0000 2401) // , including objective-c pointers.
+01cbe441b31f3 (Fariborz Jahanian 2009-12-16 23:13:33 +0000 2402) QualType ToPointeeType = ToTypePtr->getPointeeType();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2403) if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 2404) !getLangOpts().ObjCAutoRefCount) {
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2405) ConvertedType = BuildSimilarlyQualifiedPointerType(
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2406) FromType->getAs<ObjCObjectPointerType>(),
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2407) ToPointeeType,
+01cbe441b31f3 (Fariborz Jahanian 2009-12-16 23:13:33 +0000 2408) ToType, Context);
+01cbe441b31f3 (Fariborz Jahanian 2009-12-16 23:13:33 +0000 2409) return true;
+01cbe441b31f3 (Fariborz Jahanian 2009-12-16 23:13:33 +0000 2410) }
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 2411) const PointerType *FromTypePtr = FromType->getAs<PointerType>();
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2412) if (!FromTypePtr)
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2413) return false;
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2414)
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2415) QualType FromPointeeType = FromTypePtr->getPointeeType();
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2416)
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2417) // If the unqualified pointee types are the same, this can't be a
+fb640869ed14e (Douglas Gregor 2010-08-18 21:25:30 +0000 2418) // pointer conversion, so don't do all of the work below.
+fb640869ed14e (Douglas Gregor 2010-08-18 21:25:30 +0000 2419) if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
+fb640869ed14e (Douglas Gregor 2010-08-18 21:25:30 +0000 2420) return false;
+fb640869ed14e (Douglas Gregor 2010-08-18 21:25:30 +0000 2421)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2422) // An rvalue of type "pointer to cv T," where T is an object type,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2423) // can be converted to an rvalue of type "pointer to cv void" (C++
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2424) // 4.10p2).
+a170cd62575d8 (Eli Friedman 2010-08-05 02:49:48 +0000 2425) if (FromPointeeType->isIncompleteOrObjectType() &&
+a170cd62575d8 (Eli Friedman 2010-08-05 02:49:48 +0000 2426) ToPointeeType->isVoidType()) {
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2427) ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2428) ToPointeeType,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2429) ToType, Context,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2430) /*StripObjCLifetime=*/true);
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2431) return true;
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2432) }
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2433)
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2434) // MSVC allows implicit function to void* type conversion.
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 2435) if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
+bc6ebb5b76827 (Francois Pichet 2011-05-08 22:52:41 +0000 2436) ToPointeeType->isVoidType()) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2437) ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
+bb9bf88fa4a0d (Douglas Gregor 2008-11-27 00:52:49 +0000 2438) ToPointeeType,
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2439) ToType, Context);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2440) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2441) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2442)
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2443) // When we're overloading in C, we allow a special kind of pointer
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2444) // conversion for compatible-but-not-identical pointee types.
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 2445) if (!getLangOpts().CPlusPlus &&
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2446) Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2447) ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2448) ToPointeeType,
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2449) ToType, Context);
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2450) return true;
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2451) }
+4e5cbdcbed0b0 (Douglas Gregor 2009-02-11 23:02:49 +0000 2452)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2453) // C++ [conv.ptr]p3:
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2454) //
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2455) // An rvalue of type "pointer to cv D," where D is a class type,
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2456) // can be converted to an rvalue of type "pointer to cv B," where
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2457) // B is a base class (clause 10) of D. If B is an inaccessible
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2458) // (clause 11) or ambiguous (10.2) base class of D, a program that
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2459) // necessitates this conversion is ill-formed. The result of the
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2460) // conversion is a pointer to the base class sub-object of the
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2461) // derived class object. The null pointer value is converted to
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2462) // the null pointer value of the destination type.
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 2463) //
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2464) // Note that we do not check for ambiguity or inaccessibility
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2465) // here. That is handled by CheckPointerConversion.
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 2466) if (getLangOpts().CPlusPlus && FromPointeeType->isRecordType() &&
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 2467) ToPointeeType->isRecordType() &&
+d28f0412e4061 (Douglas Gregor 2010-02-22 17:06:41 +0000 2468) !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 2469) IsDerivedFrom(From->getBeginLoc(), FromPointeeType, ToPointeeType)) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2470) ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
+bb9bf88fa4a0d (Douglas Gregor 2008-11-27 00:52:49 +0000 2471) ToPointeeType,
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2472) ToType, Context);
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2473) return true;
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2474) }
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 2475)
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2476) if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2477) Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2478) ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2479) ToPointeeType,
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2480) ToType, Context);
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2481) return true;
+bc2ee9382c82d (Fariborz Jahanian 2011-04-14 20:33:36 +0000 2482) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2483)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2484) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2485) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2486)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 2487) /// Adopt the given qualifiers for the given type.
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2488) static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2489) Qualifiers TQs = T.getQualifiers();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2490)
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2491) // Check whether qualifiers already match.
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2492) if (TQs == Qs)
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2493) return T;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2494)
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2495) if (Qs.compatiblyIncludes(TQs))
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2496) return Context.getQualifiedType(T, Qs);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2497)
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2498) return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2499) }
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2500)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2501) /// isObjCPointerConversion - Determines whether this is an
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2502) /// Objective-C pointer conversion. Subroutine of IsPointerConversion,
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2503) /// with the same arguments and return values.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2504) bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2505) QualType& ConvertedType,
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2506) bool &IncompatibleObjC) {
+fa98390b3c314 (Erik Pilkington 2018-10-30 20:31:30 +0000 2507) if (!getLangOpts().ObjC)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2508) return false;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2509)
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2510) // The set of qualifiers on the type we're converting from.
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2511) Qualifiers FromQualifiers = FromType.getQualifiers();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2512)
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2513) // First, we handle all conversions on ObjC object pointer types.
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 2514) const ObjCObjectPointerType* ToObjCPtr =
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 2515) ToType->getAs<ObjCObjectPointerType>();
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2516) const ObjCObjectPointerType *FromObjCPtr =
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2517) FromType->getAs<ObjCObjectPointerType>();
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2518)
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2519) if (ToObjCPtr && FromObjCPtr) {
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2520) // If the pointee types are the same (ignoring qualifications),
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2521) // then this is not a pointer conversion.
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2522) if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2523) FromObjCPtr->getPointeeType()))
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2524) return false;
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2525)
+ab209d83be5da (Douglas Gregor 2015-07-07 03:58:42 +0000 2526) // Conversion between Objective-C pointers.
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2527) if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
+b397e43dea379 (Fariborz Jahanian 2010-03-15 18:36:00 +0000 2528) const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
+b397e43dea379 (Fariborz Jahanian 2010-03-15 18:36:00 +0000 2529) const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 2530) if (getLangOpts().CPlusPlus && LHS && RHS &&
+b397e43dea379 (Fariborz Jahanian 2010-03-15 18:36:00 +0000 2531) !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
+b397e43dea379 (Fariborz Jahanian 2010-03-15 18:36:00 +0000 2532) FromObjCPtr->getPointeeType()))
+b397e43dea379 (Fariborz Jahanian 2010-03-15 18:36:00 +0000 2533) return false;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2534) ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2535) ToObjCPtr->getPointeeType(),
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2536) ToType, Context);
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2537) ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2538) return true;
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2539) }
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2540)
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2541) if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2542) // Okay: this is some kind of implicit downcast of Objective-C
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2543) // interfaces, which is permitted. However, we're going to
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2544) // complain about it.
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2545) IncompatibleObjC = true;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2546) ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2547) ToObjCPtr->getPointeeType(),
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2548) ToType, Context);
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2549) ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2550) return true;
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2551) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2552) }
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2553) // Beyond this point, both types need to be C pointers or block pointers.
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2554) QualType ToPointeeType;
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 2555) if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2556) ToPointeeType = ToCPtr->getPointeeType();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2557) else if (const BlockPointerType *ToBlockPtr =
+4efdec067731b (Fariborz Jahanian 2010-01-20 22:54:38 +0000 2558) ToType->getAs<BlockPointerType>()) {
+879cc735fc670 (Fariborz Jahanian 2010-01-21 00:08:17 +0000 2559) // Objective C++: We're able to convert from a pointer to any object
+4efdec067731b (Fariborz Jahanian 2010-01-20 22:54:38 +0000 2560) // to a block pointer type.
+4efdec067731b (Fariborz Jahanian 2010-01-20 22:54:38 +0000 2561) if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2562) ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
+4efdec067731b (Fariborz Jahanian 2010-01-20 22:54:38 +0000 2563) return true;
+4efdec067731b (Fariborz Jahanian 2010-01-20 22:54:38 +0000 2564) }
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2565) ToPointeeType = ToBlockPtr->getPointeeType();
+4efdec067731b (Fariborz Jahanian 2010-01-20 22:54:38 +0000 2566) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2567) else if (FromType->getAs<BlockPointerType>() &&
+e4951fdc4b958 (Fariborz Jahanian 2010-01-21 00:05:09 +0000 2568) ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2569) // Objective C++: We're able to convert from a block pointer type to a
+879cc735fc670 (Fariborz Jahanian 2010-01-21 00:08:17 +0000 2570) // pointer to any object.
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2571) ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
+e4951fdc4b958 (Fariborz Jahanian 2010-01-21 00:05:09 +0000 2572) return true;
+e4951fdc4b958 (Fariborz Jahanian 2010-01-21 00:05:09 +0000 2573) }
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2574) else
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2575) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2576)
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2577) QualType FromPointeeType;
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 2578) if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 2579) FromPointeeType = FromCPtr->getPointeeType();
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 2580) else if (const BlockPointerType *FromBlockPtr =
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 2581) FromType->getAs<BlockPointerType>())
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2582) FromPointeeType = FromBlockPtr->getPointeeType();
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2583) else
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2584) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2585)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2586) // If we have pointers to pointers, recursively check whether this
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2587) // is an Objective-C conversion.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2588) if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2589) isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2590) IncompatibleObjC)) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2591) // We always complain about this conversion.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2592) IncompatibleObjC = true;
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2593) ConvertedType = Context.getPointerType(ConvertedType);
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2594) ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2595) return true;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2596) }
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2597) // Allow conversion of pointee being objective-c pointer to another one;
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2598) // as in I* to id.
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2599) if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2600) ToPointeeType->getAs<ObjCObjectPointerType>() &&
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2601) isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2602) IncompatibleObjC)) {
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2603)
+8d6d06761fcb7 (Douglas Gregor 2010-12-01 21:43:58 +0000 2604) ConvertedType = Context.getPointerType(ConvertedType);
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2605) ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2606) return true;
+42ffdb32fb546 (Fariborz Jahanian 2010-01-18 22:59:22 +0000 2607) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2608)
+033f56d5335ab (Douglas Gregor 2008-12-23 00:53:59 +0000 2609) // If we have pointers to functions or blocks, check whether the only
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2610) //
diff erences in the argument and result types are in Objective-C
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2611) // pointer conversions. If so, we permit the conversion (but
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2612) // complain about it).
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2613) const FunctionProtoType *FromFunctionType
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2614) = FromPointeeType->getAs<FunctionProtoType>();
+deaad8cc34239 (Douglas Gregor 2009-02-26 23:50:07 +0000 2615) const FunctionProtoType *ToFunctionType
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 2616) = ToPointeeType->getAs<FunctionProtoType>();
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2617) if (FromFunctionType && ToFunctionType) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2618) // If the function types are exactly the same, this isn't an
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2619) // Objective-C pointer conversion.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2620) if (Context.getCanonicalType(FromPointeeType)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2621) == Context.getCanonicalType(ToPointeeType))
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2622) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2623)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2624) // Perform the quick checks that will tell us whether these
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2625) // function types are obviously
diff erent.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2626) if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2627) FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 2628) FromFunctionType->getMethodQuals() != ToFunctionType->getMethodQuals())
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2629) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2630)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2631) bool HasObjCConversion = false;
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2632) if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2633) Context.getCanonicalType(ToFunctionType->getReturnType())) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2634) // Okay, the types match exactly. Nothing to do.
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2635) } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2636) ToFunctionType->getReturnType(),
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2637) ConvertedType, IncompatibleObjC)) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2638) // Okay, we have an Objective-C pointer conversion.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2639) HasObjCConversion = true;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2640) } else {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2641) // Function types are too
diff erent. Abort.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2642) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2643) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 2644)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2645) // Check argument types.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2646) for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2647) ArgIdx != NumArgs; ++ArgIdx) {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2648) QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2649) QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2650) if (Context.getCanonicalType(FromArgType)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2651) == Context.getCanonicalType(ToArgType)) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2652) // Okay, the types match exactly. Nothing to do.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2653) } else if (isObjCPointerConversion(FromArgType, ToArgType,
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2654) ConvertedType, IncompatibleObjC)) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2655) // Okay, we have an Objective-C pointer conversion.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2656) HasObjCConversion = true;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2657) } else {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2658) // Argument types are too
diff erent. Abort.
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2659) return false;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2660) }
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2661) }
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2662)
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2663) if (HasObjCConversion) {
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2664) // We had an Objective-C conversion. Allow this pointer
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2665) // conversion, but complain about it.
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 2666) ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2667) IncompatibleObjC = true;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2668) return true;
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2669) }
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2670) }
+a119f10482c3f (Douglas Gregor 2008-12-19 19:13:09 +0000 2671)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 2672) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2673) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 2674)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 2675) /// Determine whether this is an Objective-C writeback conversion,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2676) /// used for parameter passing when performing automatic reference counting.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2677) ///
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2678) /// \param FromType The type we're converting form.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2679) ///
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2680) /// \param ToType The type we're converting to.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2681) ///
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2682) /// \param ConvertedType The type that will be produced after applying
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2683) /// this conversion.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2684) bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2685) QualType &ConvertedType) {
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2686) if (!getLangOpts().ObjCAutoRefCount ||
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2687) Context.hasSameUnqualifiedType(FromType, ToType))
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2688) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2689)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2690) // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2691) QualType ToPointee;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2692) if (const PointerType *ToPointer = ToType->getAs<PointerType>())
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2693) ToPointee = ToPointer->getPointeeType();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2694) else
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2695) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2696)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2697) Qualifiers ToQuals = ToPointee.getQualifiers();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2698) if (!ToPointee->isObjCLifetimeType() ||
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2699) ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing ||
+18ce25e1ec096 (John McCall 2012-02-08 00:46:36 +0000 2700) !ToQuals.withoutObjCLifetime().empty())
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2701) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2702)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2703) // Argument must be a pointer to __strong to __weak.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2704) QualType FromPointee;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2705) if (const PointerType *FromPointer = FromType->getAs<PointerType>())
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2706) FromPointee = FromPointer->getPointeeType();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2707) else
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2708) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2709)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2710) Qualifiers FromQuals = FromPointee.getQualifiers();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2711) if (!FromPointee->isObjCLifetimeType() ||
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2712) (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2713) FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2714) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2715)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2716) // Make sure that we have compatible qualifiers.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2717) FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2718) if (!ToQuals.compatiblyIncludes(FromQuals))
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2719) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2720)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2721) // Remove qualifiers from the pointee type we're converting from; they
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2722) // aren't used in the compatibility check belong, and we'll be adding back
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2723) // qualifiers (with __autoreleasing) if the compatibility check succeeds.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2724) FromPointee = FromPointee.getUnqualifiedType();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2725)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2726) // The unqualified form of the pointee types must be compatible.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2727) ToPointee = ToPointee.getUnqualifiedType();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2728) bool IncompatibleObjC;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2729) if (Context.typesAreCompatible(FromPointee, ToPointee))
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2730) FromPointee = ToPointee;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2731) else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2732) IncompatibleObjC))
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2733) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2734)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 2735) /// Construct the type we're converting to, which is a pointer to
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2736) /// __autoreleasing pointee.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2737) FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2738) ConvertedType = Context.getPointerType(FromPointee);
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2739) return true;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2740) }
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 2741)
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2742) bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2743) QualType& ConvertedType) {
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2744) QualType ToPointeeType;
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2745) if (const BlockPointerType *ToBlockPtr =
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2746) ToType->getAs<BlockPointerType>())
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2747) ToPointeeType = ToBlockPtr->getPointeeType();
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2748) else
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2749) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2750)
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2751) QualType FromPointeeType;
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2752) if (const BlockPointerType *FromBlockPtr =
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2753) FromType->getAs<BlockPointerType>())
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2754) FromPointeeType = FromBlockPtr->getPointeeType();
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2755) else
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2756) return false;
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2757) // We have pointer to blocks, check whether the only
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2758) //
diff erences in the argument and result types are in Objective-C
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2759) // pointer conversions. If so, we permit the conversion.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2760)
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2761) const FunctionProtoType *FromFunctionType
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2762) = FromPointeeType->getAs<FunctionProtoType>();
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2763) const FunctionProtoType *ToFunctionType
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2764) = ToPointeeType->getAs<FunctionProtoType>();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2765)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2766) if (!FromFunctionType || !ToFunctionType)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2767) return false;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2768)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2769) if (Context.hasSameType(FromPointeeType, ToPointeeType))
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2770) return true;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2771)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2772) // Perform the quick checks that will tell us whether these
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2773) // function types are obviously
diff erent.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2774) if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2775) FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2776) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2777)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2778) FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2779) FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2780) if (FromEInfo != ToEInfo)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2781) return false;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2782)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2783) bool IncompatibleObjC = false;
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2784) if (Context.hasSameType(FromFunctionType->getReturnType(),
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2785) ToFunctionType->getReturnType())) {
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2786) // Okay, the types match exactly. Nothing to do.
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2787) } else {
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2788) QualType RHS = FromFunctionType->getReturnType();
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2789) QualType LHS = ToFunctionType->getReturnType();
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 2790) if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2791) !RHS.hasQualifiers() && LHS.hasQualifiers())
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2792) LHS = LHS.getUnqualifiedType();
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2793)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2794) if (Context.hasSameType(RHS,LHS)) {
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2795) // OK exact match.
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2796) } else if (isObjCPointerConversion(RHS, LHS,
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2797) ConvertedType, IncompatibleObjC)) {
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2798) if (IncompatibleObjC)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2799) return false;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2800) // Okay, we have an Objective-C pointer conversion.
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2801) }
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2802) else
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2803) return false;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2804) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2805)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2806) // Check argument types.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2807) for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2808) ArgIdx != NumArgs; ++ArgIdx) {
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2809) IncompatibleObjC = false;
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2810) QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2811) QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2812) if (Context.hasSameType(FromArgType, ToArgType)) {
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2813) // Okay, the types match exactly. Nothing to do.
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2814) } else if (isObjCPointerConversion(ToArgType, FromArgType,
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2815) ConvertedType, IncompatibleObjC)) {
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2816) if (IncompatibleObjC)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2817) return false;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2818) // Okay, we have an Objective-C pointer conversion.
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2819) } else
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2820) // Argument types are too
diff erent. Abort.
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2821) return false;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2822) }
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 2823)
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 2824) SmallVector<FunctionProtoType::ExtParameterInfo, 4> NewParamInfos;
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 2825) bool CanUseToFPT, CanUseFromFPT;
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 2826) if (!Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 2827) CanUseToFPT, CanUseFromFPT,
+98a49337be3fd (Akira Hatanaka 2017-09-22 00:41:05 +0000 2828) NewParamInfos))
+97676979a7eed (Fariborz Jahanian 2011-09-28 21:52:05 +0000 2829) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 2830)
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2831) ConvertedType = ToType;
+4de45dc6a7701 (Fariborz Jahanian 2011-02-13 20:01:48 +0000 2832) return true;
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2833) }
+42455ea935b04 (Fariborz Jahanian 2011-02-12 19:07:46 +0000 2834)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2835) enum {
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2836) ft_default,
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2837) ft_
diff erent_class,
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2838) ft_parameter_arity,
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2839) ft_parameter_mismatch,
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2840) ft_return_type,
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2841) ft_qualifer_mismatch,
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2842) ft_noexcept
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2843) };
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2844)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2845) /// Attempts to get the FunctionProtoType from a Type. Handles
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2846) /// MemberFunctionPointers properly.
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2847) static const FunctionProtoType *tryGetFunctionProtoType(QualType FromType) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2848) if (auto *FPT = FromType->getAs<FunctionProtoType>())
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2849) return FPT;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2850)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2851) if (auto *MPT = FromType->getAs<MemberPointerType>())
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2852) return MPT->getPointeeType()->getAs<FunctionProtoType>();
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2853)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2854) return nullptr;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2855) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2856)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2857) /// HandleFunctionTypeMismatch - Gives diagnostic information for
diff ereing
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2858) /// function types. Catches
diff erent number of parameter, mismatch in
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2859) /// parameter types, and
diff erent return types.
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2860) void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2861) QualType FromType, QualType ToType) {
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2862) // If either type is not valid, include no extra info.
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2863) if (FromType.isNull() || ToType.isNull()) {
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2864) PDiag << ft_default;
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2865) return;
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2866) }
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2867)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2868) // Get the function type from the pointers.
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2869) if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 2870) const auto *FromMember = FromType->castAs<MemberPointerType>(),
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 2871) *ToMember = ToType->castAs<MemberPointerType>();
+9098c9f1a8220 (Richard Trieu 2014-05-22 01:39:16 +0000 2872) if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2873) PDiag << ft_
diff erent_class << QualType(ToMember->getClass(), 0)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2874) << QualType(FromMember->getClass(), 0);
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2875) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2876) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2877) FromType = FromMember->getPointeeType();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2878) ToType = ToMember->getPointeeType();
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2879) }
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2880)
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2881) if (FromType->isPointerType())
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2882) FromType = FromType->getPointeeType();
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2883) if (ToType->isPointerType())
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2884) ToType = ToType->getPointeeType();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2885)
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2886) // Remove references.
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2887) FromType = FromType.getNonReferenceType();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2888) ToType = ToType.getNonReferenceType();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2889)
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2890) // Don't print extra info for non-specialized template functions.
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2891) if (FromType->isInstantiationDependentType() &&
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2892) !FromType->getAs<TemplateSpecializationType>()) {
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2893) PDiag << ft_default;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2894) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2895) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2896)
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2897) // No extra info for same types.
+96ed5b6b47666 (Richard Trieu 2011-12-13 23:19:45 +0000 2898) if (Context.hasSameType(FromType, ToType)) {
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2899) PDiag << ft_default;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2900) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2901) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2902)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2903) const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 2904) *ToFunction = tryGetFunctionProtoType(ToType);
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2905)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2906) // Both types need to be function types.
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2907) if (!FromFunction || !ToFunction) {
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2908) PDiag << ft_default;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2909) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2910) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2911)
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2912) if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2913) PDiag << ft_parameter_arity << ToFunction->getNumParams()
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2914) << FromFunction->getNumParams();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2915) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2916) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2917)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2918) // Handle
diff erent parameter types.
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2919) unsigned ArgPos;
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2920) if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2921) PDiag << ft_parameter_mismatch << ArgPos + 1
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2922) << ToFunction->getParamType(ArgPos)
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2923) << FromFunction->getParamType(ArgPos);
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2924) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2925) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2926)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2927) // Handle
diff erent return type.
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2928) if (!Context.hasSameType(FromFunction->getReturnType(),
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2929) ToFunction->getReturnType())) {
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2930) PDiag << ft_return_type << ToFunction->getReturnType()
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 2931) << FromFunction->getReturnType();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2932) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2933) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2934)
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 2935) if (FromFunction->getMethodQuals() != ToFunction->getMethodQuals()) {
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 2936) PDiag << ft_qualifer_mismatch << ToFunction->getMethodQuals()
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 2937) << FromFunction->getMethodQuals();
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2938) return;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2939) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2940)
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2941) // Handle exception specification
diff erences on canonical type (in C++17
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2942) // onwards).
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2943) if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
+eaf11ad709046 (Richard Smith 2018-05-03 03:58:32 +0000 2944) ->isNothrow() !=
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2945) cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
+eaf11ad709046 (Richard Smith 2018-05-03 03:58:32 +0000 2946) ->isNothrow()) {
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2947) PDiag << ft_noexcept;
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2948) return;
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2949) }
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 2950)
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2951) // Unable to find a
diff erence, so add no extra info.
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2952) PDiag << ft_default;
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2953) }
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 2954)
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2955) /// FunctionParamTypesAreEqual - This routine checks two function proto types
+2039ca061f07f (Douglas Gregor 2011-12-15 17:15:07 +0000 2956) /// for equality of their argument types. Caller has already checked that
+5f508953bc478 (Eli Friedman 2013-06-18 22:41:37 +0000 2957) /// they have same number of arguments. If the parameters are
diff erent,
+5f508953bc478 (Eli Friedman 2013-06-18 22:41:37 +0000 2958) /// ArgPos will have the parameter index of the first
diff erent parameter.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2959) bool Sema::FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2960) const FunctionProtoType *NewType,
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2961) unsigned *ArgPos) {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2962) for (FunctionProtoType::param_type_iterator O = OldType->param_type_begin(),
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2963) N = NewType->param_type_begin(),
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2964) E = OldType->param_type_end();
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2965) O && (O != E); ++O, ++N) {
+a85f5efd9597d (Amy Huang 2019-10-24 16:34:25 -0700 2966) // Ignore address spaces in pointee type. This is to disallow overloading
+a85f5efd9597d (Amy Huang 2019-10-24 16:34:25 -0700 2967) // on __ptr32/__ptr64 address spaces.
+a85f5efd9597d (Amy Huang 2019-10-24 16:34:25 -0700 2968) QualType Old = Context.removePtrSizeAddrSpace(O->getUnqualifiedType());
+a85f5efd9597d (Amy Huang 2019-10-24 16:34:25 -0700 2969) QualType New = Context.removePtrSizeAddrSpace(N->getUnqualifiedType());
+a85f5efd9597d (Amy Huang 2019-10-24 16:34:25 -0700 2970)
+a85f5efd9597d (Amy Huang 2019-10-24 16:34:25 -0700 2971) if (!Context.hasSameType(Old, New)) {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2972) if (ArgPos)
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 2973) *ArgPos = O - OldType->param_type_begin();
+4154f46c5a9aa (Larisse Voufo 2013-08-06 03:57:41 +0000 2974) return false;
+5e5998f014a2d (Fariborz Jahanian 2010-05-03 21:06:18 +0000 2975) }
+5e5998f014a2d (Fariborz Jahanian 2010-05-03 21:06:18 +0000 2976) }
+5e5998f014a2d (Fariborz Jahanian 2010-05-03 21:06:18 +0000 2977) return true;
+5e5998f014a2d (Fariborz Jahanian 2010-05-03 21:06:18 +0000 2978) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 2979)
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2980) /// CheckPointerConversion - Check the pointer conversion from the
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2981) /// expression From to the type ToType. This routine checks for
+9f831dbbcdfab (Sebastian Redl 2009-07-25 15:41:38 +0000 2982) /// ambiguous or inaccessible derived-to-base pointer
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2983) /// conversions for which IsPointerConversion has already returned
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2984) /// true. It returns true and produces a diagnostic if there was an
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2985) /// error, or returns false otherwise.
+7ec8ccde01d1a (Anders Carlsson 2009-09-12 04:46:44 +0000 2986) bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 2987) CastKind &Kind,
+cf1421650953d (John McCall 2010-08-07 06:22:56 +0000 2988) CXXCastPath& BasePath,
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 2989) bool IgnoreBaseAccess,
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 2990) bool Diagnose) {
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2991) QualType FromType = From->getType();
+d6ea6bd2a3f54 (Argyrios Kyrtzidis 2010-09-28 14:54:11 +0000 2992) bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 2993)
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 2994) Kind = CK_BitCast;
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 2995)
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 2996) if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
+3e3305dabaa26 (Argyrios Kyrtzidis 2014-02-02 05:26:43 +0000 2997) From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 2998) Expr::NPCK_ZeroExpression) {
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 2999) if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3000) DiagRuntimeBehavior(From->getExprLoc(), From,
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3001) PDiag(diag::warn_impcast_bool_to_null_pointer)
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3002) << ToType << From->getSourceRange());
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3003) else if (!isUnevaluatedContext())
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3004) Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3005) << ToType << From->getSourceRange();
+1c7c8f763769d (David Blaikie 2012-08-08 17:33:31 +0000 3006) }
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3007) if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3008) if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3009) QualType FromPointeeType = FromPtrType->getPointeeType(),
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3010) ToPointeeType = ToPtrType->getPointeeType();
+1e57a3fb46808 (Douglas Gregor 2008-12-18 23:43:31 +0000 3011)
+cc3f325fa69e7 (Douglas Gregor 2010-03-03 23:55:11 +0000 3012) if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
+cc3f325fa69e7 (Douglas Gregor 2010-03-03 23:55:11 +0000 3013) !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3014) // We must have a derived-to-base conversion. Check an
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3015) // ambiguous or inaccessible conversion.
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3016) unsigned InaccessibleID = 0;
+68b30bc02b3a7 (Casey Carter 2020-04-28 14:50:52 -0700 3017) unsigned AmbiguousID = 0;
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3018) if (Diagnose) {
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3019) InaccessibleID = diag::err_upcast_to_inaccessible_base;
+68b30bc02b3a7 (Casey Carter 2020-04-28 14:50:52 -0700 3020) AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3021) }
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3022) if (CheckDerivedToBaseConversion(
+68b30bc02b3a7 (Casey Carter 2020-04-28 14:50:52 -0700 3023) FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3024) From->getExprLoc(), From->getSourceRange(), DeclarationName(),
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3025) &BasePath, IgnoreBaseAccess))
+7ec8ccde01d1a (Anders Carlsson 2009-09-12 04:46:44 +0000 3026) return true;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3027)
+7ec8ccde01d1a (Anders Carlsson 2009-09-12 04:46:44 +0000 3028) // The conversion was successful.
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 3029) Kind = CK_DerivedToBase;
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3030) }
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 3031)
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3032) if (Diagnose && !IsCStyleOrFunctionalCast &&
+60bc9725755e1 (George Burgess IV 2016-01-13 23:36:34 +0000 3033) FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 3034) assert(getLangOpts().MSVCCompat &&
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 3035) "this should only be possible with MSVCCompat!");
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 3036) Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 3037) << From->getSourceRange();
+6bf02820bced5 (David Majnemer 2015-10-31 08:42:14 +0000 3038) }
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3039) }
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3040) } else if (const ObjCObjectPointerType *ToPtrType =
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3041) ToType->getAs<ObjCObjectPointerType>()) {
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3042) if (const ObjCObjectPointerType *FromPtrType =
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3043) FromType->getAs<ObjCObjectPointerType>()) {
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 3044) // Objective-C++ conversions are always okay.
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 3045) // FIXME: We should have a
diff erent class of conversions for the
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 3046) // Objective-C++ implicit conversions.
+1329fa0ed9162 (Steve Naroff 2009-07-15 18:40:39 +0000 3047) if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 3048) return false;
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3049) } else if (FromType->isBlockPointerType()) {
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3050) Kind = CK_BlockPointerToObjCPointerCast;
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3051) } else {
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3052) Kind = CK_CPointerToObjCPointerCast;
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3053) }
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3054) } else if (ToType->isBlockPointerType()) {
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3055) if (!FromType->isBlockPointerType())
+9320b87cff21e (John McCall 2011-09-09 05:25:32 +0000 3056) Kind = CK_AnyPointerToBlockPointerCast;
+7cae42b07a3aa (Steve Naroff 2009-07-10 23:34:53 +0000 3057) }
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3058)
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3059) // We shouldn't fall into this case unless it's valid for other
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3060) // reasons.
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3061) if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3062) Kind = CK_NullToPointer;
+8cb679e4e1e20 (John McCall 2010-11-15 09:13:47 +0000 3063)
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3064) return false;
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3065) }
+39c16d445e8e3 (Douglas Gregor 2008-10-24 04:54:22 +0000 3066)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3067) /// IsMemberPointerConversion - Determines whether the conversion of the
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3068) /// expression From, which has the (possibly adjusted) type FromType, can be
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3069) /// converted to the type ToType via a member pointer conversion (C++ 4.11).
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3070) /// If so, returns true and places the converted type (that might
diff er from
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3071) /// ToType in its cv-qualifiers at some level) into ConvertedType.
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3072) bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3073) QualType ToType,
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 3074) bool InOverloadResolution,
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 3075) QualType &ConvertedType) {
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 3076) const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3077) if (!ToTypePtr)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3078) return false;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3079)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3080) // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 3081) if (From->isNullPointerConstant(Context,
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 3082) InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 3083) : Expr::NPC_ValueDependentIsNull)) {
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3084) ConvertedType = ToType;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3085) return true;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3086) }
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3087)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3088) // Otherwise, both types have to be member pointers.
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 3089) const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3090) if (!FromTypePtr)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3091) return false;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3092)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3093) // A pointer to member of B can be converted to a pointer to member of D,
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3094) // where D is derived from B (C++ 4.11p2).
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3095) QualType FromClass(FromTypePtr->getClass(), 0);
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3096) QualType ToClass(ToTypePtr->getClass(), 0);
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3097)
+7f6ae6958cbc2 (Douglas Gregor 2010-12-21 21:40:41 +0000 3098) if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3099) IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass)) {
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3100) ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3101) ToClass.getTypePtr());
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3102) return true;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3103) }
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3104)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3105) return false;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3106) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3107)
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3108) /// CheckMemberPointerConversion - Check the member pointer conversion from the
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3109) /// expression From to the type ToType. This routine checks for ambiguous or
+5b0829a321d56 (John McCall 2010-02-10 09:31:12 +0000 3110) /// virtual or inaccessible base-to-derived member pointer conversions
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3111) /// for which IsMemberPointerConversion has already returned true. It returns
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3112) /// true and produces a diagnostic if there was an error, or returns false
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3113) /// otherwise.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 3114) bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 3115) CastKind &Kind,
+cf1421650953d (John McCall 2010-08-07 06:22:56 +0000 3116) CXXCastPath &BasePath,
+7c353685bcb7f (Sebastian Redl 2009-11-14 21:15:49 +0000 3117) bool IgnoreBaseAccess) {
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3118) QualType FromType = From->getType();
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 3119) const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
+d7923c6ed7ad6 (Anders Carlsson 2009-08-22 23:33:40 +0000 3120) if (!FromPtrType) {
+d7923c6ed7ad6 (Anders Carlsson 2009-08-22 23:33:40 +0000 3121) // This must be a null pointer to member pointer conversion
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3122) assert(From->isNullPointerConstant(Context,
+56751b5981c3b (Douglas Gregor 2009-09-25 04:25:58 +0000 3123) Expr::NPC_ValueDependentIsNull) &&
+d7923c6ed7ad6 (Anders Carlsson 2009-08-22 23:33:40 +0000 3124) "Expr must be null pointer constant!");
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 3125) Kind = CK_NullToMemberPointer;
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3126) return false;
+d7923c6ed7ad6 (Anders Carlsson 2009-08-22 23:33:40 +0000 3127) }
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3128)
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 3129) const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3130) assert(ToPtrType && "No member pointer cast has a target type "
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3131) "that is not a member pointer.");
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3132)
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3133) QualType FromClass = QualType(FromPtrType->getClass(), 0);
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3134) QualType ToClass = QualType(ToPtrType->getClass(), 0);
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3135)
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3136) // FIXME: What about dependent types?
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3137) assert(FromClass->isRecordType() && "Pointer into non-class.");
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3138) assert(ToClass->isRecordType() && "Pointer into non-class.");
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3139)
+7d3360f123182 (Anders Carlsson 2010-04-24 19:36:51 +0000 3140) CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
+36d1b14ddedb3 (Douglas Gregor 2009-10-06 17:59:45 +0000 3141) /*DetectVirtual=*/true);
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 3142) bool DerivationOkay =
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3143) IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass, Paths);
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3144) assert(DerivationOkay &&
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3145) "Should not have been called if derivation isn't OK.");
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3146) (void)DerivationOkay;
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3147)
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3148) if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3149) getUnqualifiedType())) {
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3150) std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3151) Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3152) << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3153) return true;
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3154) }
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3155)
+89ee6822d8a6a (Douglas Gregor 2009-02-28 01:32:25 +0000 3156) if (const RecordType *VBase = Paths.getDetectedVirtual()) {
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3157) Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3158) << FromClass << ToClass << QualType(VBase, 0)
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3159) << From->getSourceRange();
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3160) return true;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3161) }
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3162)
+5b0829a321d56 (John McCall 2010-02-10 09:31:12 +0000 3163) if (!IgnoreBaseAccess)
+1064d7ef29922 (John McCall 2010-03-16 05:22:47 +0000 3164) CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
+1064d7ef29922 (John McCall 2010-03-16 05:22:47 +0000 3165) Paths.front(),
+1064d7ef29922 (John McCall 2010-03-16 05:22:47 +0000 3166) diag::err_downcast_from_inaccessible_base);
+5b0829a321d56 (John McCall 2010-02-10 09:31:12 +0000 3167)
+d7923c6ed7ad6 (Anders Carlsson 2009-08-22 23:33:40 +0000 3168) // Must be a base to derived member conversion.
+7d3360f123182 (Anders Carlsson 2010-04-24 19:36:51 +0000 3169) BuildBasePathArray(Paths, BasePath);
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 3170) Kind = CK_BaseToDerivedMemberPointer;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3171) return false;
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3172) }
+72b597d6b6ae7 (Sebastian Redl 2009-01-25 19:43:20 +0000 3173)
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3174) /// Determine whether the lifetime conversion between the two given
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3175) /// qualifiers sets is nontrivial.
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3176) static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals,
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3177) Qualifiers ToQuals) {
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3178) // Converting anything to const __unsafe_unretained is trivial.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3179) if (ToQuals.hasConst() &&
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3180) ToQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3181) return false;
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3182)
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3183) return true;
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3184) }
+c9f019ab0f95e (Douglas Gregor 2013-11-08 02:04:24 +0000 3185)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3186) /// Perform a single iteration of the loop for checking if a qualification
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3187) /// conversion is valid.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3188) ///
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3189) /// Specifically, check whether any change between the qualifiers of \p
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3190) /// FromType and \p ToType is permissible, given knowledge about whether every
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3191) /// outer layer is const-qualified.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3192) static bool isQualificationConversionStep(QualType FromType, QualType ToType,
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3193) bool CStyle, bool IsTopLevel,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3194) bool &PreviousToQualsIncludeConst,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3195) bool &ObjCLifetimeConversion) {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3196) Qualifiers FromQuals = FromType.getQualifiers();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3197) Qualifiers ToQuals = ToType.getQualifiers();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3198)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3199) // Ignore __unaligned qualifier if this type is void.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3200) if (ToType.getUnqualifiedType()->isVoidType())
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3201) FromQuals.removeUnaligned();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3202)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3203) // Objective-C ARC:
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3204) // Check Objective-C lifetime conversions.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3205) if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime()) {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3206) if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3207) if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3208) ObjCLifetimeConversion = true;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3209) FromQuals.removeObjCLifetime();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3210) ToQuals.removeObjCLifetime();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3211) } else {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3212) // Qualification conversions cannot cast between
diff erent
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3213) // Objective-C lifetime qualifiers.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3214) return false;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3215) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3216) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3217)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3218) // Allow addition/removal of GC attributes but not changing GC attributes.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3219) if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3220) (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3221) FromQuals.removeObjCGCAttr();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3222) ToQuals.removeObjCGCAttr();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3223) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3224)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3225) // -- for every j > 0, if const is in cv 1,j then const is in cv
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3226) // 2,j, and similarly for volatile.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3227) if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3228) return false;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3229)
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3230) // If address spaces mismatch:
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3231) // - in top level it is only valid to convert to addr space that is a
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3232) // superset in all cases apart from C-style casts where we allow
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3233) // conversions between overlapping address spaces.
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3234) // - in non-top levels it is not a valid conversion.
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3235) if (ToQuals.getAddressSpace() != FromQuals.getAddressSpace() &&
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3236) (!IsTopLevel ||
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3237) !(ToQuals.isAddressSpaceSupersetOf(FromQuals) ||
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3238) (CStyle && FromQuals.isAddressSpaceSupersetOf(ToQuals)))))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3239) return false;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3240)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3241) // -- if the cv 1,j and cv 2,j are
diff erent, then const is in
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3242) // every cv for 0 < k < j.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3243) if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() &&
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3244) !PreviousToQualsIncludeConst)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3245) return false;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3246)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3247) // Keep track of whether all prior cv-qualifiers in the "to" type
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3248) // include const.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3249) PreviousToQualsIncludeConst =
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3250) PreviousToQualsIncludeConst && ToQuals.hasConst();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3251) return true;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3252) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3253)
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3254) /// IsQualificationConversion - Determines whether the conversion from
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3255) /// an rvalue of type FromType to ToType is a qualification conversion
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3256) /// (C++ 4.4).
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 3257) ///
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 3258) /// \param ObjCLifetimeConversion Output parameter that will be set to indicate
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 3259) /// when the qualification conversion involves a change in the Objective-C
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 3260) /// object lifetime.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 3261) bool
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3262) Sema::IsQualificationConversion(QualType FromType, QualType ToType,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 3263) bool CStyle, bool &ObjCLifetimeConversion) {
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3264) FromType = Context.getCanonicalType(FromType);
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3265) ToType = Context.getCanonicalType(ToType);
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 3266) ObjCLifetimeConversion = false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3267)
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3268) // If FromType and ToType are the same type, this is not a
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3269) // qualification conversion.
+cbdffb15856e4 (Sebastian Redl 2010-02-03 19:36:07 +0000 3270) if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3271) return false;
+ed8f2003185cc (Sebastian Redl 2009-01-28 18:33:18 +0000 3272)
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3273) // (C++ 4.4p4):
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3274) // A conversion can add cv-qualifiers at levels other than the first
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3275) // in multi-level pointers, subject to the following rules: [...]
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3276) bool PreviousToQualsIncludeConst = true;
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3277) bool UnwrappedAnyPointer = false;
+a3405ffcecc6a (Richard Smith 2018-07-11 00:19:19 +0000 3278) while (Context.UnwrapSimilarTypes(FromType, ToType)) {
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3279) if (!isQualificationConversionStep(
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3280) FromType, ToType, CStyle, !UnwrappedAnyPointer,
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 3281) PreviousToQualsIncludeConst, ObjCLifetimeConversion))
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 3282) return false;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3283) UnwrappedAnyPointer = true;
+99a9f75948598 (Yaxun Liu 2018-07-20 11:32:51 +0000 3284) }
+99a9f75948598 (Yaxun Liu 2018-07-20 11:32:51 +0000 3285)
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3286) // We are left with FromType and ToType being the pointee types
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3287) // after unwrapping the original FromType and ToType the same number
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 3288) // of times. If we unwrapped any pointers, and if FromType and
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3289) // ToType have the same unqualified type (since we checked
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3290) // qualifiers above), then this is a qualification conversion.
+1b8fe5b716b8b (Douglas Gregor 2009-11-16 21:35:15 +0000 3291) return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3292) }
+9a6579340fabd (Douglas Gregor 2008-10-21 23:43:52 +0000 3293)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 3294) /// - Determine whether this is a conversion from a scalar type to an
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3295) /// atomic type.
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3296) ///
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3297) /// If successful, updates \c SCS's second and third steps in the conversion
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3298) /// sequence to finish the conversion.
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 3299) static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 3300) bool InOverloadResolution,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 3301) StandardConversionSequence &SCS,
+f9e36cccb5910 (Douglas Gregor 2012-04-12 20:48:09 +0000 3302) bool CStyle) {
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3303) const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3304) if (!ToAtomic)
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3305) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3306)
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3307) StandardConversionSequence InnerSCS;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3308) if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3309) InOverloadResolution, InnerSCS,
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3310) CStyle, /*AllowObjCWritebackConversion=*/false))
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3311) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3312)
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3313) SCS.Second = InnerSCS.Second;
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3314) SCS.setToType(1, InnerSCS.getToType(1));
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3315) SCS.Third = InnerSCS.Third;
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3316) SCS.QualificationIncludesObjCLifetime
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3317) = InnerSCS.QualificationIncludesObjCLifetime;
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3318) SCS.setToType(2, InnerSCS.getToType(2));
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3319) return true;
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3320) }
+c79862f017e37 (Douglas Gregor 2012-04-12 17:51:55 +0000 3321)
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3322) static bool isFirstArgumentCompatibleWithType(ASTContext &Context,
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3323) CXXConstructorDecl *Constructor,
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3324) QualType Type) {
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 3325) const auto *CtorType = Constructor->getType()->castAs<FunctionProtoType>();
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 3326) if (CtorType->getNumParams() > 0) {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 3327) QualType FirstArg = CtorType->getParamType(0);
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3328) if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3329) return true;
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3330) }
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3331) return false;
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3332) }
+e541716286fe6 (Sebastian Redl 2012-03-27 18:33:03 +0000 3333)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3334) static OverloadingResult
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3335) IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3336) CXXRecordDecl *To,
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3337) UserDefinedConversionSequence &User,
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3338) OverloadCandidateSet &CandidateSet,
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3339) bool AllowExplicit) {
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 3340) CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3341) for (auto *D : S.LookupConstructors(To)) {
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3342) auto Info = getConstructorInfo(D);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 3343) if (!Info)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3344) continue;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3345)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3346) bool Usable = !Info.Constructor->isInvalidDecl() &&
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3347) S.isInitListConstructor(Info.Constructor);
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3348) if (Usable) {
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3349) bool SuppressUserConversions = false;
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3350) if (Info.ConstructorTmpl)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3351) S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3352) /*ExplicitArgs*/ nullptr, From,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3353) CandidateSet, SuppressUserConversions,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3354) /*PartialOverloading*/ false,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3355) AllowExplicit);
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3356) else
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3357) S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3358) CandidateSet, SuppressUserConversions,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3359) /*PartialOverloading*/ false, AllowExplicit);
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3360) }
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3361) }
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3362)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3363) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3364)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3365) OverloadCandidateSet::iterator Best;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3366) switch (auto Result =
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3367) CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
+dcf06f42324a3 (Fariborz Jahanian 2015-04-14 17:21:58 +0000 3368) case OR_Deleted:
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3369) case OR_Success: {
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3370) // Record the standard conversion we used and the conversion function.
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3371) CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
+5488ab4ddd47a (Brian Gesiak 2019-01-11 01:54:53 +0000 3372) QualType ThisType = Constructor->getThisType();
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3373) // Initializer lists don't have conversions as such.
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3374) User.Before.setAsIdentityConversion();
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3375) User.HadMultipleCandidates = HadMultipleCandidates;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3376) User.ConversionFunction = Constructor;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3377) User.FoundConversionFunction = Best->FoundDecl;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3378) User.After.setAsIdentityConversion();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 3379) User.After.setFromType(ThisType->castAs<PointerType>()->getPointeeType());
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3380) User.After.setAllToTypes(ToType);
+dcf06f42324a3 (Fariborz Jahanian 2015-04-14 17:21:58 +0000 3381) return Result;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3382) }
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3383)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3384) case OR_No_Viable_Function:
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3385) return OR_No_Viable_Function;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3386) case OR_Ambiguous:
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3387) return OR_Ambiguous;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3388) }
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3389)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3390) llvm_unreachable("Invalid OverloadResult!");
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3391) }
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3392)
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3393) /// Determines whether there is a user-defined conversion sequence
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3394) /// (C++ [over.ics.user]) that converts expression From to the type
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3395) /// ToType. If such a conversion exists, User will contain the
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3396) /// user-defined conversion sequence that performs such a conversion
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3397) /// and this routine will return true. Otherwise, this routine returns
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3398) /// false and User is unspecified.
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3399) ///
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3400) /// \param AllowExplicit true if the conversion should consider C++0x
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3401) /// "explicit" conversion functions as well as non-explicit conversion
+576e98cc1e513 (Douglas Gregor 2009-01-30 23:27:23 +0000 3402) /// functions (C++0x [class.conv.fct]p2).
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 3403) ///
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 3404) /// \param AllowObjCConversionOnExplicit true if the conversion should
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 3405) /// allow an extra Objective-C pointer conversion on uses of explicit
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 3406) /// constructors. Requires \c AllowExplicit to also be set.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3407) static OverloadingResult
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3408) IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3409) UserDefinedConversionSequence &User,
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3410) OverloadCandidateSet &CandidateSet,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3411) AllowedExplicit AllowExplicit,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 3412) bool AllowObjCConversionOnExplicit) {
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3413) assert(AllowExplicit != AllowedExplicit::None ||
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3414) !AllowObjCConversionOnExplicit);
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 3415) CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 3416)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3417) // Whether we will only visit constructors.
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3418) bool ConstructorsOnly = false;
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3419)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3420) // If the type we are conversion to is a class type, enumerate its
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3421) // constructors.
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 3422) if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3423) // C++ [over.match.ctor]p1:
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3424) // When objects of class type are direct-initialized (8.5), or
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3425) // copy-initialized from an expression of the same or a
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3426) // derived class type (8.5), overload resolution selects the
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3427) // constructor. [...] For copy-initialization, the candidate
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3428) // functions are all the converting constructors (12.3.1) of
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3429) // that class. The argument list is the expression-list within
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3430) // the parentheses of the initializer.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3431) if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3432) (From->getType()->getAs<RecordType>() &&
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3433) S.IsDerivedFrom(From->getBeginLoc(), From->getType(), ToType)))
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3434) ConstructorsOnly = true;
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3435)
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 3436) if (!S.isCompleteType(From->getExprLoc(), ToType)) {
+3ec1bf240d4ab (Douglas Gregor 2009-11-05 13:06:35 +0000 3437) // We're not going to find any constructors.
+3ec1bf240d4ab (Douglas Gregor 2009-11-05 13:06:35 +0000 3438) } else if (CXXRecordDecl *ToRecordDecl
+3ec1bf240d4ab (Douglas Gregor 2009-11-05 13:06:35 +0000 3439) = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3440)
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3441) Expr **Args = &From;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3442) unsigned NumArgs = 1;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3443) bool ListInitializing = false;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3444) if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
+60509af49add1 (Benjamin Kramer 2013-09-09 14:48:42 +0000 3445) // But first, see if there is an init-list-constructor that will work.
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3446) OverloadingResult Result = IsInitializerListConstructorConversion(
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3447) S, From, ToType, ToRecordDecl, User, CandidateSet,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3448) AllowExplicit == AllowedExplicit::All);
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3449) if (Result != OR_No_Viable_Function)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3450) return Result;
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3451) // Never mind.
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 3452) CandidateSet.clear(
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 3453) OverloadCandidateSet::CSK_InitByUserDefinedConversion);
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3454)
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3455) // If we're list-initializing, we pass the individual elements as
+82ace98d5505e (Sebastian Redl 2012-02-11 23:51:08 +0000 3456) // arguments, not the entire list.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3457) Args = InitList->getInits();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3458) NumArgs = InitList->getNumInits();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3459) ListInitializing = true;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3460) }
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3461)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3462) for (auto *D : S.LookupConstructors(ToRecordDecl)) {
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3463) auto Info = getConstructorInfo(D);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 3464) if (!Info)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3465) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3466)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3467) bool Usable = !Info.Constructor->isInvalidDecl();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3468) if (!ListInitializing)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3469) Usable = Usable && Info.Constructor->isConvertingConstructor(
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3470) /*AllowExplicit*/ true);
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3471) if (Usable) {
+d9170b09e6726 (Sebastian Redl 2012-03-20 21:24:14 +0000 3472) bool SuppressUserConversions = !ConstructorsOnly;
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3473) // C++20 [over.best.ics.general]/4.5:
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3474) // if the target is the first parameter of a constructor [of class
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3475) // X] and the constructor [...] is a candidate by [...] the second
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3476) // phase of [over.match.list] when the initializer list has exactly
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3477) // one element that is itself an initializer list, [...] and the
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3478) // conversion is to X or reference to cv X, user-defined conversion
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3479) // sequences are not cnosidered.
+d9170b09e6726 (Sebastian Redl 2012-03-20 21:24:14 +0000 3480) if (SuppressUserConversions && ListInitializing) {
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3481) SuppressUserConversions =
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3482) NumArgs == 1 && isa<InitListExpr>(Args[0]) &&
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3483) isFirstArgumentCompatibleWithType(S.Context, Info.Constructor,
+40beb1f84a3d7 (Richard Smith 2021-04-22 16:48:34 -0700 3484) ToType);
+d9170b09e6726 (Sebastian Redl 2012-03-20 21:24:14 +0000 3485) }
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3486) if (Info.ConstructorTmpl)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3487) S.AddTemplateOverloadCandidate(
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3488) Info.ConstructorTmpl, Info.FoundDecl,
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3489) /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3490) CandidateSet, SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3491) /*PartialOverloading*/ false,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3492) AllowExplicit == AllowedExplicit::All);
+5ed5ae476e5c7 (Douglas Gregor 2009-08-21 18:42:58 +0000 3493) else
+b3c44f9ee9e66 (Fariborz Jahanian 2009-10-01 20:39:51 +0000 3494) // Allow one user-defined conversion when user specifies a
+b3c44f9ee9e66 (Fariborz Jahanian 2009-10-01 20:39:51 +0000 3495) // From->ToType conversion via an static cast (c-style, etc).
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 3496) S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 3497) llvm::makeArrayRef(Args, NumArgs),
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 3498) CandidateSet, SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3499) /*PartialOverloading*/ false,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3500) AllowExplicit == AllowedExplicit::All);
+5ed5ae476e5c7 (Douglas Gregor 2009-08-21 18:42:58 +0000 3501) }
+89ee6822d8a6a (Douglas Gregor 2009-02-28 01:32:25 +0000 3502) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3503) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3504) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3505)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3506) // Enumerate conversion functions, if we're allowed to.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3507) if (ConstructorsOnly || isa<InitListExpr>(From)) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3508) } else if (!S.isCompleteType(From->getBeginLoc(), From->getType())) {
+8a2e601917708 (Douglas Gregor 2009-08-24 15:23:48 +0000 3509) // No conversion functions from incomplete types.
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3510) } else if (const RecordType *FromRecordType =
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3511) From->getType()->getAs<RecordType>()) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 3512) if (CXXRecordDecl *FromRecordDecl
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3513) = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3514) // Add all of the conversion functions as candidates.
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 3515) const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 3516) for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 3517) DeclAccessPair FoundDecl = I.getPair();
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 3518) NamedDecl *D = FoundDecl.getDecl();
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 3519) CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 3520) if (isa<UsingShadowDecl>(D))
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 3521) D = cast<UsingShadowDecl>(D)->getTargetDecl();
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 3522)
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3523) CXXConversionDecl *Conv;
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3524) FunctionTemplateDecl *ConvTemplate;
+da4458e98f54c (John McCall 2010-03-31 01:36:47 +0000 3525) if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
+da4458e98f54c (John McCall 2010-03-31 01:36:47 +0000 3526) Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3527) else
+da4458e98f54c (John McCall 2010-03-31 01:36:47 +0000 3528) Conv = cast<CXXConversionDecl>(D);
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3529)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3530) if (ConvTemplate)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3531) S.AddTemplateConversionCandidate(
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3532) ConvTemplate, FoundDecl, ActingContext, From, ToType,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3533) CandidateSet, AllowObjCConversionOnExplicit,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3534) AllowExplicit != AllowedExplicit::None);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 3535) else
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3536) S.AddConversionCandidate(Conv, FoundDecl, ActingContext, From, ToType,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3537) CandidateSet, AllowObjCConversionOnExplicit,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3538) AllowExplicit != AllowedExplicit::None);
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3539) }
+f9012a3e9d9e7 (Fariborz Jahanian 2009-09-11 18:46:22 +0000 3540) }
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 3541) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3542)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 3543) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 3544)
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3545) OverloadCandidateSet::iterator Best;
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3546) switch (auto Result =
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3547) CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3548) case OR_Success:
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 3549) case OR_Deleted:
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3550) // Record the standard conversion we used and the conversion function.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3551) if (CXXConstructorDecl *Constructor
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3552) = dyn_cast<CXXConstructorDecl>(Best->Function)) {
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3553) // C++ [over.ics.user]p1:
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3554) // If the user-defined conversion is specified by a
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3555) // constructor (12.3.1), the initial standard conversion
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3556) // sequence converts the source type to the type required by
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3557) // the argument of the constructor.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3558) //
+5488ab4ddd47a (Brian Gesiak 2019-01-11 01:54:53 +0000 3559) QualType ThisType = Constructor->getThisType();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3560) if (isa<InitListExpr>(From)) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3561) // Initializer lists don't have conversions as such.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3562) User.Before.setAsIdentityConversion();
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3563) } else {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3564) if (Best->Conversions[0].isEllipsis())
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3565) User.EllipsisConversion = true;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3566) else {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3567) User.Before = Best->Conversions[0].Standard;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3568) User.EllipsisConversion = false;
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 3569) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3570) }
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 3571) User.HadMultipleCandidates = HadMultipleCandidates;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3572) User.ConversionFunction = Constructor;
+30909031a7f76 (John McCall 2011-09-21 08:36:56 +0000 3573) User.FoundConversionFunction = Best->FoundDecl;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3574) User.After.setAsIdentityConversion();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 3575) User.After.setFromType(ThisType->castAs<PointerType>()->getPointeeType());
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3576) User.After.setAllToTypes(ToType);
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 3577) return Result;
+8a40f700e62b8 (David Blaikie 2012-01-17 06:56:22 +0000 3578) }
+8a40f700e62b8 (David Blaikie 2012-01-17 06:56:22 +0000 3579) if (CXXConversionDecl *Conversion
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3580) = dyn_cast<CXXConversionDecl>(Best->Function)) {
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3581) // C++ [over.ics.user]p1:
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3582) //
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3583) // [...] If the user-defined conversion is specified by a
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3584) // conversion function (12.3.2), the initial standard
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3585) // conversion sequence converts the source type to the
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3586) // implicit object parameter of the conversion function.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3587) User.Before = Best->Conversions[0].Standard;
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 3588) User.HadMultipleCandidates = HadMultipleCandidates;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3589) User.ConversionFunction = Conversion;
+30909031a7f76 (John McCall 2011-09-21 08:36:56 +0000 3590) User.FoundConversionFunction = Best->FoundDecl;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3591) User.EllipsisConversion = false;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3592)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3593) // C++ [over.ics.user]p2:
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3594) // The second standard conversion sequence converts the
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3595) // result of the user-defined conversion to the target type
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3596) // for the sequence. Since an implicit conversion sequence
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3597) // is an initialization, the special rules for
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3598) // initialization by user-defined conversion apply when
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3599) // selecting the best user-defined conversion for a
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3600) // user-defined conversion sequence (see 13.3.3 and
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3601) // 13.3.3.1).
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3602) User.After = Best->FinalConversion;
+48372b68fefb9 (Richard Smith 2015-01-27 03:30:40 +0000 3603) return Result;
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3604) }
+8a40f700e62b8 (David Blaikie 2012-01-17 06:56:22 +0000 3605) llvm_unreachable("Not a constructor or conversion function?");
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3606)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3607) case OR_No_Viable_Function:
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3608) return OR_No_Viable_Function;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3609)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3610) case OR_Ambiguous:
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3611) return OR_Ambiguous;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3612) }
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3613)
+8a40f700e62b8 (David Blaikie 2012-01-17 06:56:22 +0000 3614) llvm_unreachable("Invalid OverloadResult!");
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3615) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3616)
+f0647a5fbcebf (Fariborz Jahanian 2009-09-22 20:24:30 +0000 3617) bool
+76197416ac15c (Fariborz Jahanian 2009-11-18 18:26:29 +0000 3618) Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
+f0647a5fbcebf (Fariborz Jahanian 2009-09-22 20:24:30 +0000 3619) ImplicitConversionSequence ICS;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 3620) OverloadCandidateSet CandidateSet(From->getExprLoc(),
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 3621) OverloadCandidateSet::CSK_Normal);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3622) OverloadingResult OvResult =
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3623) IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 3624) CandidateSet, AllowedExplicit::None, false);
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3625)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3626) if (!(OvResult == OR_Ambiguous ||
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3627) (OvResult == OR_No_Viable_Function && !CandidateSet.empty())))
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3628) return false;
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3629)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 3630) auto Cands = CandidateSet.CompleteCandidates(
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 3631) *this,
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 3632) OvResult == OR_Ambiguous ? OCD_AmbiguousCandidates : OCD_AllCandidates,
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 3633) From);
+76197416ac15c (Fariborz Jahanian 2009-11-18 18:26:29 +0000 3634) if (OvResult == OR_Ambiguous)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3635) Diag(From->getBeginLoc(), diag::err_typecheck_ambiguous_condition)
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3636) << From->getType() << ToType << From->getSourceRange();
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3637) else { // OR_No_Viable_Function && !CandidateSet.empty()
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3638) if (!RequireCompleteType(From->getBeginLoc(), ToType,
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3639) diag::err_typecheck_nonviable_condition_incomplete,
+64cf3efd47bc7 (Larisse Voufo 2013-06-27 01:50:25 +0000 3640) From->getType(), From->getSourceRange()))
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 3641) Diag(From->getBeginLoc(), diag::err_typecheck_nonviable_condition)
+08426e2098aaa (Nick Lewycky 2015-08-25 22:18:46 +0000 3642) << false << From->getType() << From->getSourceRange() << ToType;
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3643) }
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3644)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3645) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 3646) *this, From, Cands);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3647) return true;
+f0647a5fbcebf (Fariborz Jahanian 2009-09-22 20:24:30 +0000 3648) }
+26bee0b326227 (Douglas Gregor 2008-10-31 16:23:19 +0000 3649)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3650) // Helper for compareConversionFunctions that gets the FunctionType that the
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3651) // conversion-operator return value 'points' to, or nullptr.
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3652) static const FunctionType *
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3653) getConversionOpReturnTyAsFunction(CXXConversionDecl *Conv) {
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3654) const FunctionType *ConvFuncTy = Conv->getType()->castAs<FunctionType>();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3655) const PointerType *RetPtrTy =
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3656) ConvFuncTy->getReturnType()->getAs<PointerType>();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3657)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3658) if (!RetPtrTy)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3659) return nullptr;
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3660)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3661) return RetPtrTy->getPointeeType()->getAs<FunctionType>();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3662) }
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3663)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 3664) /// Compare the user-defined conversion functions or constructors
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3665) /// of two user-defined conversion sequences to determine whether any ordering
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3666) /// is possible.
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3667) static ImplicitConversionSequence::CompareKind
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3668) compareConversionFunctions(Sema &S, FunctionDecl *Function1,
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3669) FunctionDecl *Function2) {
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3670) CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3671) CXXConversionDecl *Conv2 = dyn_cast_or_null<CXXConversionDecl>(Function2);
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3672) if (!Conv1 || !Conv2)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3673) return ImplicitConversionSequence::Indistinguishable;
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3674)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3675) if (!Conv1->getParent()->isLambda() || !Conv2->getParent()->isLambda())
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3676) return ImplicitConversionSequence::Indistinguishable;
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3677)
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3678) // Objective-C++:
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3679) // If both conversion functions are implicitly-declared conversions from
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3680) // a lambda closure type to a function pointer and a block pointer,
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3681) // respectively, always prefer the conversion to a function pointer,
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3682) // because the function pointer is more lightweight and is more likely
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3683) // to keep code working.
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3684) if (S.getLangOpts().ObjC && S.getLangOpts().CPlusPlus11) {
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3685) bool Block1 = Conv1->getConversionType()->isBlockPointerType();
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3686) bool Block2 = Conv2->getConversionType()->isBlockPointerType();
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3687) if (Block1 != Block2)
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3688) return Block1 ? ImplicitConversionSequence::Worse
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3689) : ImplicitConversionSequence::Better;
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3690) }
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3691)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3692) // In order to support multiple calling conventions for the lambda conversion
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3693) // operator (such as when the free and member function calling convention is
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3694) //
diff erent), prefer the 'free' mechanism, followed by the calling-convention
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3695) // of operator(). The latter is in place to support the MSVC-like solution of
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3696) // defining ALL of the possible conversions in regards to calling-convention.
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3697) const FunctionType *Conv1FuncRet = getConversionOpReturnTyAsFunction(Conv1);
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3698) const FunctionType *Conv2FuncRet = getConversionOpReturnTyAsFunction(Conv2);
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3699)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3700) if (Conv1FuncRet && Conv2FuncRet &&
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3701) Conv1FuncRet->getCallConv() != Conv2FuncRet->getCallConv()) {
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3702) CallingConv Conv1CC = Conv1FuncRet->getCallConv();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3703) CallingConv Conv2CC = Conv2FuncRet->getCallConv();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3704)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3705) CXXMethodDecl *CallOp = Conv2->getParent()->getLambdaCallOperator();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3706) const FunctionProtoType *CallOpProto =
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3707) CallOp->getType()->getAs<FunctionProtoType>();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3708)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3709) CallingConv CallOpCC =
+2901dc7575873 (Simon Pilgrim 2021-04-06 12:04:01 +0100 3710) CallOp->getType()->castAs<FunctionType>()->getCallConv();
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3711) CallingConv DefaultFree = S.Context.getDefaultCallingConvention(
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3712) CallOpProto->isVariadic(), /*IsCXXMethod=*/false);
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3713) CallingConv DefaultMember = S.Context.getDefaultCallingConvention(
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3714) CallOpProto->isVariadic(), /*IsCXXMethod=*/true);
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3715)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3716) CallingConv PrefOrder[] = {DefaultFree, DefaultMember, CallOpCC};
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3717) for (CallingConv CC : PrefOrder) {
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3718) if (Conv1CC == CC)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3719) return ImplicitConversionSequence::Better;
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3720) if (Conv2CC == CC)
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3721) return ImplicitConversionSequence::Worse;
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3722) }
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3723) }
+ec809e4cfe0be (Erich Keane 2020-10-16 09:09:09 -0700 3724)
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3725) return ImplicitConversionSequence::Indistinguishable;
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3726) }
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3727)
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3728) static bool hasDeprecatedStringLiteralToCharPtrConversion(
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3729) const ImplicitConversionSequence &ICS) {
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3730) return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3731) (ICS.isUserDefined() &&
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3732) ICS.UserDefined.Before.DeprecatedStringLiteralToCharPtr);
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3733) }
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3734)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3735) /// CompareImplicitConversionSequences - Compare two implicit
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3736) /// conversion sequences to determine whether one is better than the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3737) /// other or if they are indistinguishable (C++ 13.3.3.2).
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3738) static ImplicitConversionSequence::CompareKind
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 3739) CompareImplicitConversionSequences(Sema &S, SourceLocation Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3740) const ImplicitConversionSequence& ICS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3741) const ImplicitConversionSequence& ICS2)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3742) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3743) // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3744) // conversion sequences (as defined in 13.3.3.1)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3745) // -- a standard conversion sequence (13.3.3.1.1) is a better
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3746) // conversion sequence than a user-defined conversion sequence or
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3747) // an ellipsis conversion sequence, and
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3748) // -- a user-defined conversion sequence (13.3.3.1.2) is a better
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3749) // conversion sequence than an ellipsis conversion sequence
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3750) // (13.3.3.1.3).
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 3751) //
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3752) // C++0x [over.best.ics]p10:
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3753) // For the purpose of ranking implicit conversion sequences as
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3754) // described in 13.3.3.2, the ambiguous conversion sequence is
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3755) // treated as a user-defined sequence that is indistinguishable
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3756) // from any other user-defined conversion sequence.
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3757)
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3758) // String literal to 'char *' conversion has been deprecated in C++03. It has
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3759) // been removed from C++11. We still accept this conversion, if it happens at
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3760) // the best viable function. Otherwise, this conversion is considered worse
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3761) // than ellipsis conversion. Consider this as an extension; this is not in the
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3762) // standard. For example:
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3763) //
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3764) // int &f(...); // #1
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3765) // void f(char*); // #2
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3766) // void g() { int &r = f("foo"); }
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3767) //
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3768) // In C++03, we pick #2 as the best viable function.
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3769) // In C++11, we pick #1 as the best viable function, because ellipsis
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3770) // conversion is better than string-literal to char* conversion (since there
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3771) // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3772) // convert arguments, #2 would be the best viable function in C++11.
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3773) // If the best viable function has this conversion, a warning will be issued
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3774) // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3775)
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3776) if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3777) hasDeprecatedStringLiteralToCharPtrConversion(ICS1) !=
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3778) hasDeprecatedStringLiteralToCharPtrConversion(ICS2))
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3779) return hasDeprecatedStringLiteralToCharPtrConversion(ICS1)
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3780) ? ImplicitConversionSequence::Worse
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3781) : ImplicitConversionSequence::Better;
+1121de36c26b9 (Ismail Pazarbasi 2014-01-17 21:08:52 +0000 3782)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3783) if (ICS1.getKindRank() < ICS2.getKindRank())
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3784) return ImplicitConversionSequence::Better;
+8a40f700e62b8 (David Blaikie 2012-01-17 06:56:22 +0000 3785) if (ICS2.getKindRank() < ICS1.getKindRank())
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 3786) return ImplicitConversionSequence::Worse;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3787)
+98ff7f873089b (Benjamin Kramer 2010-04-18 12:05:54 +0000 3788) // The following checks require both conversion sequences to be of
+98ff7f873089b (Benjamin Kramer 2010-04-18 12:05:54 +0000 3789) // the same kind.
+98ff7f873089b (Benjamin Kramer 2010-04-18 12:05:54 +0000 3790) if (ICS1.getKind() != ICS2.getKind())
+98ff7f873089b (Benjamin Kramer 2010-04-18 12:05:54 +0000 3791) return ImplicitConversionSequence::Indistinguishable;
+98ff7f873089b (Benjamin Kramer 2010-04-18 12:05:54 +0000 3792)
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3793) ImplicitConversionSequence::CompareKind Result =
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3794) ImplicitConversionSequence::Indistinguishable;
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3795)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3796) // Two implicit conversion sequences of the same form are
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3797) // indistinguishable conversion sequences unless one of the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3798) // following rules apply: (C++ 13.3.3.2p3):
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3799)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3800) // List-initialization sequence L1 is a better conversion sequence than
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3801) // list-initialization sequence L2 if:
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3802) // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3803) // if not that,
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3804) // — L1 and L2 convert to arrays of the same element type, and either the
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3805) // number of elements n_1 initialized by L1 is less than the number of
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3806) // elements n_2 initialized by L2, or (unimplemented:C++20) n_1 = n_2 and L2
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3807) // converts to an array of unknown bound and L1 does not,
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3808) // even if one of the other rules in this paragraph would otherwise apply.
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3809) if (!ICS1.isBad()) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3810) bool StdInit1 = false, StdInit2 = false;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3811)
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3812) if (ICS1.isInitializerListToType())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3813) StdInit1 =
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3814) S.isStdInitializerList(ICS1.getInitializerListToType(), nullptr);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3815) if (ICS2.isInitializerListToType())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3816) StdInit2 =
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3817) S.isStdInitializerList(ICS2.getInitializerListToType(), nullptr);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3818)
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3819) if (StdInit1 && !StdInit2)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3820) return ImplicitConversionSequence::Better;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3821) if (!StdInit1 && StdInit2)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3822) return ImplicitConversionSequence::Worse;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3823)
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3824) if (ICS1.isInitializerListToType() && ICS2.isInitializerListToType()) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3825) if (auto *AT1 =
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3826) S.Context.getAsArrayType(ICS1.getInitializerListToType())) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3827) if (auto *AT2 =
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3828) S.Context.getAsArrayType(ICS2.getInitializerListToType())) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3829) if (AT1->getElementType() == AT2->getElementType()) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3830) if (auto CAT1 = dyn_cast<ConstantArrayType>(AT1)) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3831) if (auto CAT2 = dyn_cast<ConstantArrayType>(AT2)) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3832) if (CAT1->getSize() != CAT2->getSize())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3833) return CAT1->getSize().ult(CAT2->getSize())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3834) ? ImplicitConversionSequence::Better
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3835) : ImplicitConversionSequence::Worse;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3836) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3837) llvm_unreachable("C++20 incomplete array init?");
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3838) } else if (isa<ConstantArrayType>(AT2))
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3839) llvm_unreachable("C++20 incomplete array init?");
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3840) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3841) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3842) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 3843) }
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3844) }
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3845)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3846) if (ICS1.isStandard())
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3847) // Standard conversion sequence S1 is a better conversion sequence than
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 3848) // standard conversion sequence S2 if [...]
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 3849) Result = CompareStandardConversionSequences(S, Loc,
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3850) ICS1.Standard, ICS2.Standard);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 3851) else if (ICS1.isUserDefined()) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3852) // User-defined conversion sequence U1 is a better conversion
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3853) // sequence than another user-defined conversion sequence U2 if
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3854) // they contain the same user-defined conversion function or
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3855) // constructor and if the second standard conversion sequence of
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3856) // U1 is better than the second standard conversion sequence of
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3857) // U2 (C++ 13.3.3.2p3).
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 3858) if (ICS1.UserDefined.ConversionFunction ==
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3859) ICS2.UserDefined.ConversionFunction)
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 3860) Result = CompareStandardConversionSequences(S, Loc,
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3861) ICS1.UserDefined.After,
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3862) ICS2.UserDefined.After);
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3863) else
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 3864) Result = compareConversionFunctions(S,
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3865) ICS1.UserDefined.ConversionFunction,
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 3866) ICS2.UserDefined.ConversionFunction);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3867) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3868)
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 3869) return Result;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3870) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3871)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3872) // Per 13.3.3.2p3, compare the given standard conversion sequences to
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3873) // determine if one is a proper subset of the other.
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3874) static ImplicitConversionSequence::CompareKind
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3875) compareStandardConversionSubsets(ASTContext &Context,
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3876) const StandardConversionSequence& SCS1,
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3877) const StandardConversionSequence& SCS2) {
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3878) ImplicitConversionSequence::CompareKind Result
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3879) = ImplicitConversionSequence::Indistinguishable;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3880)
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3881) // the identity conversion sequence is considered to be a subsequence of
+e87561aa2efec (Douglas Gregor 2010-05-23 22:10:15 +0000 3882) // any non-identity conversion sequence
+377c109f21e01 (Douglas Gregor 2011-06-05 06:15:20 +0000 3883) if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
+377c109f21e01 (Douglas Gregor 2011-06-05 06:15:20 +0000 3884) return ImplicitConversionSequence::Better;
+377c109f21e01 (Douglas Gregor 2011-06-05 06:15:20 +0000 3885) else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
+377c109f21e01 (Douglas Gregor 2011-06-05 06:15:20 +0000 3886) return ImplicitConversionSequence::Worse;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3887)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3888) if (SCS1.Second != SCS2.Second) {
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3889) if (SCS1.Second == ICK_Identity)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3890) Result = ImplicitConversionSequence::Better;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3891) else if (SCS2.Second == ICK_Identity)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3892) Result = ImplicitConversionSequence::Worse;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3893) else
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3894) return ImplicitConversionSequence::Indistinguishable;
+a3405ffcecc6a (Richard Smith 2018-07-11 00:19:19 +0000 3895) } else if (!Context.hasSimilarType(SCS1.getToType(1), SCS2.getToType(1)))
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3896) return ImplicitConversionSequence::Indistinguishable;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3897)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3898) if (SCS1.Third == SCS2.Third) {
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3899) return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3900) : ImplicitConversionSequence::Indistinguishable;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3901) }
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3902)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3903) if (SCS1.Third == ICK_Identity)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3904) return Result == ImplicitConversionSequence::Worse
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3905) ? ImplicitConversionSequence::Indistinguishable
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3906) : ImplicitConversionSequence::Better;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3907)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3908) if (SCS2.Third == ICK_Identity)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3909) return Result == ImplicitConversionSequence::Better
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3910) ? ImplicitConversionSequence::Indistinguishable
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3911) : ImplicitConversionSequence::Worse;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3912)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3913) return ImplicitConversionSequence::Indistinguishable;
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3914) }
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3915)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 3916) /// Determine whether one of the given reference bindings is better
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3917) /// than the other based on what kind of bindings they are.
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 3918) static bool
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 3919) isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 3920) const StandardConversionSequence &SCS2) {
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3921) // C++0x [over.ics.rank]p3b4:
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3922) // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3923) // implicit object parameter of a non-static member function declared
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3924) // without a ref-qualifier, and *either* S1 binds an rvalue reference
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3925) // to an rvalue and S2 binds an lvalue reference *or S1 binds an
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3926) // lvalue reference to a function lvalue and S2 binds an rvalue
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3927) // reference*.
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3928) //
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3929) // FIXME: Rvalue references. We're going rogue with the above edits,
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3930) // because the semantics in the current C++0x working paper (N3225 at the
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3931) // time of this writing) break the standard definition of std::forward
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3932) // and std::reference_wrapper when dealing with references to functions.
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3933) // Proposed wording changes submitted to CWG for consideration.
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 3934) if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 3935) SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 3936) return false;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3937)
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3938) return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3939) SCS2.IsLvalueReference) ||
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3940) (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 3941) !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue);
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 3942) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 3943)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3944) enum class FixedEnumPromotion {
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3945) None,
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3946) ToUnderlyingType,
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3947) ToPromotedUnderlyingType
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3948) };
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3949)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3950) /// Returns kind of fixed enum promotion the \a SCS uses.
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3951) static FixedEnumPromotion
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3952) getFixedEnumPromtion(Sema &S, const StandardConversionSequence &SCS) {
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3953)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3954) if (SCS.Second != ICK_Integral_Promotion)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3955) return FixedEnumPromotion::None;
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3956)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3957) QualType FromType = SCS.getFromType();
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3958) if (!FromType->isEnumeralType())
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3959) return FixedEnumPromotion::None;
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3960)
+2901dc7575873 (Simon Pilgrim 2021-04-06 12:04:01 +0100 3961) EnumDecl *Enum = FromType->castAs<EnumType>()->getDecl();
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3962) if (!Enum->isFixed())
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3963) return FixedEnumPromotion::None;
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3964)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3965) QualType UnderlyingType = Enum->getIntegerType();
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3966) if (S.Context.hasSameType(SCS.getToType(1), UnderlyingType))
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3967) return FixedEnumPromotion::ToUnderlyingType;
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3968)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3969) return FixedEnumPromotion::ToPromotedUnderlyingType;
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3970) }
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 3971)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3972) /// CompareStandardConversionSequences - Compare two standard
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3973) /// conversion sequences to determine whether one is better than the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3974) /// other or if they are indistinguishable (C++ 13.3.3.2p3).
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3975) static ImplicitConversionSequence::CompareKind
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 3976) CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3977) const StandardConversionSequence& SCS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3978) const StandardConversionSequence& SCS2)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3979) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3980) // Standard conversion sequence S1 is a better conversion sequence
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3981) // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3982)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3983) // -- S1 is a proper subsequence of S2 (comparing the conversion
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3984) // sequences in the canonical form defined by 13.3.3.1.1,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3985) // excluding any Lvalue Transformation; the identity conversion
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3986) // sequence is considered to be a subsequence of any
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3987) // non-identity conversion sequence) or, if not that,
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3988) if (ImplicitConversionSequence::CompareKind CK
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 3989) = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 3990) return CK;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3991)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3992) // -- the rank of S1 is better than the rank of S2 (by the rules
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3993) // defined below), or, if not that,
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3994) ImplicitConversionRank Rank1 = SCS1.getRank();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3995) ImplicitConversionRank Rank2 = SCS2.getRank();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3996) if (Rank1 < Rank2)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3997) return ImplicitConversionSequence::Better;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3998) else if (Rank2 < Rank1)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 3999) return ImplicitConversionSequence::Worse;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 4000)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4001) // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4002) // are indistinguishable unless one of the following rules
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4003) // applies:
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4004)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4005) // A conversion that is not a conversion of a pointer, or
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4006) // pointer to member, to bool is better than another conversion
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4007) // that is such a conversion.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4008) if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4009) return SCS2.isPointerConversionToBool()
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4010) ? ImplicitConversionSequence::Better
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4011) : ImplicitConversionSequence::Worse;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4012)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4013) // C++14 [over.ics.rank]p4b2:
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4014) // This is retroactively applied to C++11 by CWG 1601.
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4015) //
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4016) // A conversion that promotes an enumeration whose underlying type is fixed
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4017) // to its underlying type is better than one that promotes to the promoted
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4018) // underlying type, if the two are
diff erent.
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4019) FixedEnumPromotion FEP1 = getFixedEnumPromtion(S, SCS1);
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4020) FixedEnumPromotion FEP2 = getFixedEnumPromtion(S, SCS2);
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4021) if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4022) FEP1 != FEP2)
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4023) return FEP1 == FixedEnumPromotion::ToUnderlyingType
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4024) ? ImplicitConversionSequence::Better
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4025) : ImplicitConversionSequence::Worse;
+344df110e56fa (Richard Smith 2019-10-06 18:50:40 +0000 4026)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4027) // C++ [over.ics.rank]p4b2:
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4028) //
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4029) // If class B is derived directly or indirectly from class A,
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4030) // conversion of B* to A* is better than conversion of B* to
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4031) // void*, and conversion of A* to void* is better than conversion
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4032) // of B* to void*.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4033) bool SCS1ConvertsToVoid
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4034) = SCS1.isPointerConversionToVoidPointer(S.Context);
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4035) bool SCS2ConvertsToVoid
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4036) = SCS2.isPointerConversionToVoidPointer(S.Context);
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4037) if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4038) // Exactly one of the conversion sequences is a conversion to
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4039) // a void pointer; it's the worse conversion.
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4040) return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4041) : ImplicitConversionSequence::Worse;
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4042) } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4043) // Neither conversion sequence converts to a void pointer; compare
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4044) // their derived-to-base conversions.
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4045) if (ImplicitConversionSequence::CompareKind DerivedCK
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4046) = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4047) return DerivedCK;
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4048) } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4049) !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4050) // Both conversion sequences are conversions to void
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4051) // pointers. Compare the source types to determine if there's an
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4052) // inheritance relationship in their sources.
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 4053) QualType FromType1 = SCS1.getFromType();
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 4054) QualType FromType2 = SCS2.getFromType();
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4055)
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4056) // Adjust the types we're converting from via the array-to-pointer
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4057) // conversion, if we need to.
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4058) if (SCS1.First == ICK_Array_To_Pointer)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4059) FromType1 = S.Context.getArrayDecayedType(FromType1);
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4060) if (SCS2.First == ICK_Array_To_Pointer)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4061) FromType2 = S.Context.getArrayDecayedType(FromType2);
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4062)
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4063) QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4064) QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4065)
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4066) if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4067) return ImplicitConversionSequence::Better;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4068) else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4069) return ImplicitConversionSequence::Worse;
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4070)
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4071) // Objective-C++: If one interface is more specific than the
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4072) // other, it is the better one.
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4073) const ObjCObjectPointerType* FromObjCPtr1
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4074) = FromType1->getAs<ObjCObjectPointerType>();
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4075) const ObjCObjectPointerType* FromObjCPtr2
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4076) = FromType2->getAs<ObjCObjectPointerType>();
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4077) if (FromObjCPtr1 && FromObjCPtr2) {
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4078) bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4079) FromObjCPtr2);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4080) bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4081) FromObjCPtr1);
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4082) if (AssignLeft != AssignRight) {
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4083) return AssignLeft? ImplicitConversionSequence::Better
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4084) : ImplicitConversionSequence::Worse;
+30ee16f5ddbdf (Douglas Gregor 2011-04-27 00:01:52 +0000 4085) }
+1aa450a07872e (Douglas Gregor 2009-12-13 21:37:05 +0000 4086) }
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4087) }
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4088)
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4089) if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4090) // Check for a better reference binding based on the kind of bindings.
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4091) if (isBetterReferenceBindingKind(SCS1, SCS2))
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4092) return ImplicitConversionSequence::Better;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4093) else if (isBetterReferenceBindingKind(SCS2, SCS1))
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4094) return ImplicitConversionSequence::Worse;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4095) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4096)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4097) // Compare based on qualification conversions (C++ 13.3.3.2p3,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4098) // bullet 3).
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4099) if (ImplicitConversionSequence::CompareKind QualCK
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4100) = CompareQualificationConversions(S, SCS1, SCS2))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4101) return QualCK;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4102)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4103) if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
+b28b40712121c (Sebastian Redl 2009-03-22 23:49:27 +0000 4104) // C++ [over.ics.rank]p3b4:
+b28b40712121c (Sebastian Redl 2009-03-22 23:49:27 +0000 4105) // -- S1 and S2 are reference bindings (8.5.3), and the types to
+b28b40712121c (Sebastian Redl 2009-03-22 23:49:27 +0000 4106) // which the references refer are the same type except for
+b28b40712121c (Sebastian Redl 2009-03-22 23:49:27 +0000 4107) // top-level cv-qualifiers, and the type to which the reference
+b28b40712121c (Sebastian Redl 2009-03-22 23:49:27 +0000 4108) // initialized by S2 refers is more cv-qualified than the type
+b28b40712121c (Sebastian Redl 2009-03-22 23:49:27 +0000 4109) // to which the reference initialized by S1 refers.
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 4110) QualType T1 = SCS1.getToType(2);
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 4111) QualType T2 = SCS2.getToType(2);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4112) T1 = S.Context.getCanonicalType(T1);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4113) T2 = S.Context.getCanonicalType(T2);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4114) Qualifiers T1Quals, T2Quals;
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4115) QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4116) QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4117) if (UnqualT1 == UnqualT2) {
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4118) // Objective-C++ ARC: If the references refer to objects with
diff erent
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4119) // lifetimes, prefer bindings that don't change lifetime.
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4120) if (SCS1.ObjCLifetimeConversionBinding !=
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4121) SCS2.ObjCLifetimeConversionBinding) {
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4122) return SCS1.ObjCLifetimeConversionBinding
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4123) ? ImplicitConversionSequence::Worse
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4124) : ImplicitConversionSequence::Better;
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4125) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4126)
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4127) // If the type is an array type, promote the element qualifiers to the
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4128) // type for comparison.
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4129) if (isa<ArrayType>(T1) && T1Quals)
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4130) T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4131) if (isa<ArrayType>(T2) && T2Quals)
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4132) T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
+d8018233d1ea4 (David Blaikie 2019-12-27 12:17:01 -0800 4133) if (T2.isMoreQualifiedThan(T1))
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4134) return ImplicitConversionSequence::Better;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4135) if (T1.isMoreQualifiedThan(T2))
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4136) return ImplicitConversionSequence::Worse;
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4137) }
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4138) }
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4139)
+2ec7f639c49fd (Marek Kurdej 2021-04-02 08:57:42 +0200 4140) // In Microsoft mode (below 19.28), prefer an integral conversion to a
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4141) // floating-to-integral conversion if the integral conversion
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4142) // is between types of the same size.
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4143) // For example:
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4144) // void f(float);
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4145) // void f(int);
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4146) // int main {
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4147) // long a;
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4148) // f(a);
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4149) // }
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4150) // Here, MSVC will call f(int) instead of generating a compile error
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4151) // as clang will do in standard mode.
+2ec7f639c49fd (Marek Kurdej 2021-04-02 08:57:42 +0200 4152) if (S.getLangOpts().MSVCCompat &&
+2ec7f639c49fd (Marek Kurdej 2021-04-02 08:57:42 +0200 4153) !S.getLangOpts().isCompatibleWithMSVC(LangOptions::MSVC2019_8) &&
+2ec7f639c49fd (Marek Kurdej 2021-04-02 08:57:42 +0200 4154) SCS1.Second == ICK_Integral_Conversion &&
+bfa3934f27e72 (Alp Toker 2014-01-14 12:51:41 +0000 4155) SCS2.Second == ICK_Floating_Integral &&
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4156) S.Context.getTypeSize(SCS1.getFromType()) ==
+bfa3934f27e72 (Alp Toker 2014-01-14 12:51:41 +0000 4157) S.Context.getTypeSize(SCS1.getToType(2)))
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4158) return ImplicitConversionSequence::Better;
+08d2fa0a78216 (Francois Pichet 2011-09-18 21:37:37 +0000 4159)
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4160) // Prefer a compatible vector conversion over a lax vector conversion
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4161) // For example:
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4162) //
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4163) // typedef float __v4sf __attribute__((__vector_size__(16)));
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4164) // void f(vector float);
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4165) // void f(vector signed int);
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4166) // int main() {
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4167) // __v4sf a;
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4168) // f(a);
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4169) // }
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4170) // Here, we'd like to choose f(vector float) and not
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4171) // report an ambiguous call error
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4172) if (SCS1.Second == ICK_Vector_Conversion &&
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4173) SCS2.Second == ICK_Vector_Conversion) {
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4174) bool SCS1IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4175) SCS1.getFromType(), SCS1.getToType(2));
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4176) bool SCS2IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4177) SCS2.getFromType(), SCS2.getToType(2));
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4178)
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4179) if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4180) return SCS1IsCompatibleVectorConversion
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4181) ? ImplicitConversionSequence::Better
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4182) : ImplicitConversionSequence::Worse;
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4183) }
+64d85a29edd8d (Zi Xuan Wu 2018-11-16 03:00:00 +0000 4184)
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4185) if (SCS1.Second == ICK_SVE_Vector_Conversion &&
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4186) SCS2.Second == ICK_SVE_Vector_Conversion) {
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4187) bool SCS1IsCompatibleSVEVectorConversion =
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4188) S.Context.areCompatibleSveTypes(SCS1.getFromType(), SCS1.getToType(2));
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4189) bool SCS2IsCompatibleSVEVectorConversion =
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4190) S.Context.areCompatibleSveTypes(SCS2.getFromType(), SCS2.getToType(2));
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4191)
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4192) if (SCS1IsCompatibleSVEVectorConversion !=
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4193) SCS2IsCompatibleSVEVectorConversion)
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4194) return SCS1IsCompatibleSVEVectorConversion
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4195) ? ImplicitConversionSequence::Better
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4196) : ImplicitConversionSequence::Worse;
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4197) }
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 4198)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 4199) return ImplicitConversionSequence::Indistinguishable;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 4200) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 4201)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4202) /// CompareQualificationConversions - Compares two standard conversion
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4203) /// sequences to determine whether they can be ranked based on their
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4204) /// qualification conversions (C++ 13.3.3.2p3 bullet 3).
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 4205) static ImplicitConversionSequence::CompareKind
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4206) CompareQualificationConversions(Sema &S,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4207) const StandardConversionSequence& SCS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4208) const StandardConversionSequence& SCS2) {
+4b62ec6353164 (Douglas Gregor 2008-10-22 15:04:37 +0000 4209) // C++ 13.3.3.2p3:
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4210) // -- S1 and S2
diff er only in their qualification conversion and
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4211) // yield similar types T1 and T2 (C++ 4.4), respectively, and the
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4212) // cv-qualification signature of type T1 is a proper subset of
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4213) // the cv-qualification signature of type T2, and S1 is not the
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4214) // deprecated string literal array-to-pointer conversion (4.2).
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4215) if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4216) SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4217) return ImplicitConversionSequence::Indistinguishable;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4218)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4219) // FIXME: the example in the standard doesn't use a qualification
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4220) // conversion (!)
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 4221) QualType T1 = SCS1.getToType(2);
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 4222) QualType T2 = SCS2.getToType(2);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4223) T1 = S.Context.getCanonicalType(T1);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4224) T2 = S.Context.getCanonicalType(T2);
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4225) assert(!T1->isReferenceType() && !T2->isReferenceType());
+607f38e05fac3 (Chandler Carruth 2009-12-29 07:16:59 +0000 4226) Qualifiers T1Quals, T2Quals;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4227) QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4228) QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4229)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4230) // If the types are the same, we won't learn anything by unwrapping
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4231) // them.
+607f38e05fac3 (Chandler Carruth 2009-12-29 07:16:59 +0000 4232) if (UnqualT1 == UnqualT2)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4233) return ImplicitConversionSequence::Indistinguishable;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4234)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4235) ImplicitConversionSequence::CompareKind Result
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4236) = ImplicitConversionSequence::Indistinguishable;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4237)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4238) // Objective-C++ ARC:
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4239) // Prefer qualification conversions not involving a change in lifetime
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4240) // to qualification conversions that do not change lifetime.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4241) if (SCS1.QualificationIncludesObjCLifetime !=
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4242) SCS2.QualificationIncludesObjCLifetime) {
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4243) Result = SCS1.QualificationIncludesObjCLifetime
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4244) ? ImplicitConversionSequence::Worse
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4245) : ImplicitConversionSequence::Better;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4246) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4247)
+a3405ffcecc6a (Richard Smith 2018-07-11 00:19:19 +0000 4248) while (S.Context.UnwrapSimilarTypes(T1, T2)) {
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4249) // Within each iteration of the loop, we check the qualifiers to
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4250) // determine if this still looks like a qualification
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4251) // conversion. Then, if all is well, we unwrap one more level of
+29a9247ec2515 (Douglas Gregor 2008-10-22 17:49:05 +0000 4252) // pointers or pointers-to-members and do it all again
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4253) // until there are no more pointers or pointers-to-members left
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4254) // to unwrap. This essentially mimics what
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4255) // IsQualificationConversion does, but here we're checking for a
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4256) // strict subset of qualifiers.
+ef19af19428b3 (Anastasia Stulova 2019-01-18 11:38:16 +0000 4257) if (T1.getQualifiers().withoutObjCLifetime() ==
+ef19af19428b3 (Anastasia Stulova 2019-01-18 11:38:16 +0000 4258) T2.getQualifiers().withoutObjCLifetime())
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4259) // The qualifiers are the same, so this doesn't tell us anything
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4260) // about how the sequences rank.
+ef19af19428b3 (Anastasia Stulova 2019-01-18 11:38:16 +0000 4261) // ObjC ownership quals are omitted above as they interfere with
+ef19af19428b3 (Anastasia Stulova 2019-01-18 11:38:16 +0000 4262) // the ARC overload rule.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4263) ;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4264) else if (T2.isMoreQualifiedThan(T1)) {
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4265) // T1 has fewer qualifiers, so it could be the better sequence.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4266) if (Result == ImplicitConversionSequence::Worse)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4267) // Neither has qualifiers that are a subset of the other's
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4268) // qualifiers.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4269) return ImplicitConversionSequence::Indistinguishable;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4270)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4271) Result = ImplicitConversionSequence::Better;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4272) } else if (T1.isMoreQualifiedThan(T2)) {
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4273) // T2 has fewer qualifiers, so it could be the better sequence.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4274) if (Result == ImplicitConversionSequence::Better)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4275) // Neither has qualifiers that are a subset of the other's
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4276) // qualifiers.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4277) return ImplicitConversionSequence::Indistinguishable;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4278)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4279) Result = ImplicitConversionSequence::Worse;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4280) } else {
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4281) // Qualifiers are disjoint.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4282) return ImplicitConversionSequence::Indistinguishable;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4283) }
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4284)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4285) // If the types after this point are equivalent, we're done.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4286) if (S.Context.hasSameUnqualifiedType(T1, T2))
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4287) break;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4288) }
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4289)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4290) // Check that the winning standard conversion sequence isn't using
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4291) // the deprecated string literal array to pointer conversion.
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4292) switch (Result) {
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4293) case ImplicitConversionSequence::Better:
+e489a7d3d3972 (Douglas Gregor 2010-02-28 18:30:25 +0000 4294) if (SCS1.DeprecatedStringLiteralToCharPtr)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4295) Result = ImplicitConversionSequence::Indistinguishable;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4296) break;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4297)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4298) case ImplicitConversionSequence::Indistinguishable:
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4299) break;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4300)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4301) case ImplicitConversionSequence::Worse:
+e489a7d3d3972 (Douglas Gregor 2010-02-28 18:30:25 +0000 4302) if (SCS2.DeprecatedStringLiteralToCharPtr)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4303) Result = ImplicitConversionSequence::Indistinguishable;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4304) break;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4305) }
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4306)
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4307) return Result;
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4308) }
+e1eb9d8cc4c12 (Douglas Gregor 2008-10-22 14:17:15 +0000 4309)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4310) /// CompareDerivedToBaseConversions - Compares two standard conversion
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4311) /// sequences to determine whether they can be ranked based on their
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 4312) /// various kinds of derived-to-base conversions (C++
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 4313) /// [over.ics.rank]p4b3). As part of these checks, we also look at
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 4314) /// conversions between Objective-C interface types.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 4315) static ImplicitConversionSequence::CompareKind
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4316) CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4317) const StandardConversionSequence& SCS1,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4318) const StandardConversionSequence& SCS2) {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 4319) QualType FromType1 = SCS1.getFromType();
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 4320) QualType ToType1 = SCS1.getToType(1);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 4321) QualType FromType2 = SCS2.getFromType();
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 4322) QualType ToType2 = SCS2.getToType(1);
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4323)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4324) // Adjust the types we're converting from via the array-to-pointer
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4325) // conversion, if we need to.
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4326) if (SCS1.First == ICK_Array_To_Pointer)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4327) FromType1 = S.Context.getArrayDecayedType(FromType1);
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4328) if (SCS2.First == ICK_Array_To_Pointer)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4329) FromType2 = S.Context.getArrayDecayedType(FromType2);
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4330)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4331) // Canonicalize all of the types.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4332) FromType1 = S.Context.getCanonicalType(FromType1);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4333) ToType1 = S.Context.getCanonicalType(ToType1);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4334) FromType2 = S.Context.getCanonicalType(FromType2);
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4335) ToType2 = S.Context.getCanonicalType(ToType2);
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4336)
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4337) // C++ [over.ics.rank]p4b3:
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4338) //
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4339) // If class B is derived directly or indirectly from class A and
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4340) // class C is derived directly or indirectly from B,
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 4341) //
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4342) // Compare based on pointer conversions.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4343) if (SCS1.Second == ICK_Pointer_Conversion &&
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 4344) SCS2.Second == ICK_Pointer_Conversion &&
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 4345) /*FIXME: Remove if Objective-C id conversions get their own rank*/
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 4346) FromType1->isPointerType() && FromType2->isPointerType() &&
+a29dc05eafe20 (Douglas Gregor 2008-11-27 01:19:21 +0000 4347) ToType1->isPointerType() && ToType2->isPointerType()) {
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4348) QualType FromPointee1 =
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4349) FromType1->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4350) QualType ToPointee1 =
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4351) ToType1->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4352) QualType FromPointee2 =
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4353) FromType2->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4354) QualType ToPointee2 =
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4355) ToType2->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
+237f96c40f6bf (Douglas Gregor 2008-11-26 23:31:11 +0000 4356)
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4357) // -- conversion of C* to B* is better than conversion of C* to A*,
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4358) if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4359) if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4360) return ImplicitConversionSequence::Better;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4361) else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4362) return ImplicitConversionSequence::Worse;
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4363) }
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4364)
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4365) // -- conversion of B* to A* is better than conversion of C* to A*,
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4366) if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4367) if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4368) return ImplicitConversionSequence::Better;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4369) else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4370) return ImplicitConversionSequence::Worse;
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4371) }
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4372) } else if (SCS1.Second == ICK_Pointer_Conversion &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4373) SCS2.Second == ICK_Pointer_Conversion) {
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4374) const ObjCObjectPointerType *FromPtr1
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4375) = FromType1->getAs<ObjCObjectPointerType>();
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4376) const ObjCObjectPointerType *FromPtr2
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4377) = FromType2->getAs<ObjCObjectPointerType>();
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4378) const ObjCObjectPointerType *ToPtr1
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4379) = ToType1->getAs<ObjCObjectPointerType>();
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4380) const ObjCObjectPointerType *ToPtr2
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4381) = ToType2->getAs<ObjCObjectPointerType>();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4382)
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4383) if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4384) // Apply the same conversion ranking rules for Objective-C pointer types
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4385) // that we do for C++ pointers to class types. However, we employ the
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4386) // Objective-C pseudo-subtyping relationship used for assignment of
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4387) // Objective-C pointer types.
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4388) bool FromAssignLeft
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4389) = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4390) bool FromAssignRight
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4391) = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4392) bool ToAssignLeft
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4393) = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4394) bool ToAssignRight
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4395) = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4396)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4397) // A conversion to an a non-id object pointer type or qualified 'id'
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4398) // type is better than a conversion to 'id'.
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4399) if (ToPtr1->isObjCIdType() &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4400) (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4401) return ImplicitConversionSequence::Worse;
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4402) if (ToPtr2->isObjCIdType() &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4403) (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4404) return ImplicitConversionSequence::Better;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4405)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4406) // A conversion to a non-id object pointer type is better than a
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4407) // conversion to a qualified 'id' type
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4408) if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4409) return ImplicitConversionSequence::Worse;
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4410) if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4411) return ImplicitConversionSequence::Better;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4412)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4413) // A conversion to an a non-Class object pointer type or qualified 'Class'
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4414) // type is better than a conversion to 'Class'.
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4415) if (ToPtr1->isObjCClassType() &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4416) (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4417) return ImplicitConversionSequence::Worse;
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4418) if (ToPtr2->isObjCClassType() &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4419) (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4420) return ImplicitConversionSequence::Better;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4421)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4422) // A conversion to a non-Class object pointer type is better than a
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4423) // conversion to a qualified 'Class' type.
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4424) if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4425) return ImplicitConversionSequence::Worse;
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4426) if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4427) return ImplicitConversionSequence::Better;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 4428)
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4429) // -- "conversion of C* to B* is better than conversion of C* to A*,"
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4430) if (S.Context.hasSameType(FromType1, FromType2) &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4431) !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4432) (ToAssignLeft != ToAssignRight)) {
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4433) if (FromPtr1->isSpecialized()) {
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4434) // "conversion of B<A> * to B * is better than conversion of B * to
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4435) // C *.
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4436) bool IsFirstSame =
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4437) FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4438) bool IsSecondSame =
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4439) FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4440) if (IsFirstSame) {
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4441) if (!IsSecondSame)
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4442) return ImplicitConversionSequence::Better;
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4443) } else if (IsSecondSame)
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4444) return ImplicitConversionSequence::Worse;
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4445) }
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4446) return ToAssignLeft? ImplicitConversionSequence::Worse
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4447) : ImplicitConversionSequence::Better;
+a9832134597af (Alex Lorenz 2017-04-06 13:06:34 +0000 4448) }
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4449)
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4450) // -- "conversion of B* to A* is better than conversion of C* to A*,"
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4451) if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4452) (FromAssignLeft != FromAssignRight))
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4453) return FromAssignLeft? ImplicitConversionSequence::Better
+058d3deab8924 (Douglas Gregor 2011-01-31 18:51:41 +0000 4454) : ImplicitConversionSequence::Worse;
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4455) }
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4456) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4457)
+ac741ffd44eec (Fariborz Jahanian 2009-10-20 20:07:35 +0000 4458) // Ranking of member-pointer types.
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4459) if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4460) FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4461) ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 4462) const auto *FromMemPointer1 = FromType1->castAs<MemberPointerType>();
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 4463) const auto *ToMemPointer1 = ToType1->castAs<MemberPointerType>();
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 4464) const auto *FromMemPointer2 = FromType2->castAs<MemberPointerType>();
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 4465) const auto *ToMemPointer2 = ToType2->castAs<MemberPointerType>();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4466) const Type *FromPointeeType1 = FromMemPointer1->getClass();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4467) const Type *ToPointeeType1 = ToMemPointer1->getClass();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4468) const Type *FromPointeeType2 = FromMemPointer2->getClass();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4469) const Type *ToPointeeType2 = ToMemPointer2->getClass();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4470) QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4471) QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4472) QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4473) QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
+ac741ffd44eec (Fariborz Jahanian 2009-10-20 20:07:35 +0000 4474) // conversion of A::* to B::* is better than conversion of A::* to C::*,
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4475) if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4476) if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4477) return ImplicitConversionSequence::Worse;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4478) else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4479) return ImplicitConversionSequence::Better;
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4480) }
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4481) // conversion of B::* to C::* is better than conversion of A::* to C::*
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4482) if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4483) if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4484) return ImplicitConversionSequence::Better;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4485) else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4486) return ImplicitConversionSequence::Worse;
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4487) }
+9a587b01118ed (Fariborz Jahanian 2009-10-20 20:04:46 +0000 4488) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4489)
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 4490) if (SCS1.Second == ICK_Derived_To_Base) {
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4491) // -- conversion of C to B is better than conversion of C to A,
+83af86a6bc101 (Douglas Gregor 2010-02-25 19:01:05 +0000 4492) // -- binding of an expression of type C to a reference of type
+83af86a6bc101 (Douglas Gregor 2010-02-25 19:01:05 +0000 4493) // B& is better than binding an expression of type C to a
+83af86a6bc101 (Douglas Gregor 2010-02-25 19:01:05 +0000 4494) // reference of type A&,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4495) if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4496) !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4497) if (S.IsDerivedFrom(Loc, ToType1, ToType2))
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4498) return ImplicitConversionSequence::Better;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4499) else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4500) return ImplicitConversionSequence::Worse;
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4501) }
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4502)
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4503) // -- conversion of B to A is better than conversion of C to A.
+83af86a6bc101 (Douglas Gregor 2010-02-25 19:01:05 +0000 4504) // -- binding of an expression of type B to a reference of type
+83af86a6bc101 (Douglas Gregor 2010-02-25 19:01:05 +0000 4505) // A& is better than binding an expression of type C to a
+83af86a6bc101 (Douglas Gregor 2010-02-25 19:01:05 +0000 4506) // reference of type A&,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4507) if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4508) S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4509) if (S.IsDerivedFrom(Loc, FromType2, FromType1))
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4510) return ImplicitConversionSequence::Better;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4511) else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4512) return ImplicitConversionSequence::Worse;
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4513) }
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 4514) }
+ef30a5ff98e19 (Douglas Gregor 2008-10-29 14:50:44 +0000 4515)
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4516) return ImplicitConversionSequence::Indistinguishable;
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4517) }
+5c407d9a9b8c5 (Douglas Gregor 2008-10-23 00:40:37 +0000 4518)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 4519) /// Determine whether the given type is valid, e.g., it is not an invalid
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4520) /// C++ class.
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4521) static bool isTypeValid(QualType T) {
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4522) if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4523) return !Record->isInvalidDecl();
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4524)
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4525) return true;
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4526) }
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4527)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4528) static QualType withoutUnaligned(ASTContext &Ctx, QualType T) {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4529) if (!T.getQualifiers().hasUnaligned())
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4530) return T;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4531)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4532) Qualifiers Q;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4533) T = Ctx.getUnqualifiedArrayType(T, Q);
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4534) Q.removeUnaligned();
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4535) return Ctx.getQualifiedType(T, Q);
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4536) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4537)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4538) /// CompareReferenceRelationship - Compare the two types T1 and T2 to
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4539) /// determine whether they are reference-compatible,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4540) /// reference-related, or incompatible, for use in C++ initialization by
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4541) /// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4542) /// type, and the first type (T1) is the pointee type of the reference
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4543) /// type being initialized.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4544) Sema::ReferenceCompareResult
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4545) Sema::CompareReferenceRelationship(SourceLocation Loc,
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4546) QualType OrigT1, QualType OrigT2,
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4547) ReferenceConversions *ConvOut) {
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4548) assert(!OrigT1->isReferenceType() &&
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4549) "T1 must be the pointee type of the reference type");
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4550) assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type");
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4551)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4552) QualType T1 = Context.getCanonicalType(OrigT1);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4553) QualType T2 = Context.getCanonicalType(OrigT2);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4554) Qualifiers T1Quals, T2Quals;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4555) QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4556) QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4557)
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4558) ReferenceConversions ConvTmp;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4559) ReferenceConversions &Conv = ConvOut ? *ConvOut : ConvTmp;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4560) Conv = ReferenceConversions();
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4561)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4562) // C++2a [dcl.init.ref]p4:
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4563) // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4564) // reference-related to "cv2 T2" if T1 is similar to T2, or
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4565) // T1 is a base class of T2.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4566) // "cv1 T1" is reference-compatible with "cv2 T2" if
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4567) // a prvalue of type "pointer to cv2 T2" can be converted to the type
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4568) // "pointer to cv1 T1" via a standard conversion sequence.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4569)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4570) // Check for standard conversions we can apply to pointers: derived-to-base
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4571) // conversions, ObjC pointer conversions, and function pointer conversions.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4572) // (Qualification conversions are checked last.)
+1be59c510612d (Richard Smith 2016-10-22 01:32:19 +0000 4573) QualType ConvertedT2;
+8b2d2fe234163 (Douglas Gregor 2010-08-07 11:51:51 +0000 4574) if (UnqualT1 == UnqualT2) {
+8b2d2fe234163 (Douglas Gregor 2010-08-07 11:51:51 +0000 4575) // Nothing to do.
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 4576) } else if (isCompleteType(Loc, OrigT2) &&
+45bb4834e9671 (Douglas Gregor 2013-03-26 23:36:30 +0000 4577) isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 4578) IsDerivedFrom(Loc, UnqualT2, UnqualT1))
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4579) Conv |= ReferenceConversions::DerivedToBase;
+8b2d2fe234163 (Douglas Gregor 2010-08-07 11:51:51 +0000 4580) else if (UnqualT1->isObjCObjectOrInterfaceType() &&
+8b2d2fe234163 (Douglas Gregor 2010-08-07 11:51:51 +0000 4581) UnqualT2->isObjCObjectOrInterfaceType() &&
+8b2d2fe234163 (Douglas Gregor 2010-08-07 11:51:51 +0000 4582) Context.canBindObjCObjectType(UnqualT1, UnqualT2))
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4583) Conv |= ReferenceConversions::ObjC;
+1be59c510612d (Richard Smith 2016-10-22 01:32:19 +0000 4584) else if (UnqualT2->isFunctionType() &&
+766f15814a012 (Peter Collingbourne 2019-10-19 00:34:54 +0000 4585) IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2)) {
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4586) Conv |= ReferenceConversions::Function;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4587) // No need to check qualifiers; function types don't have them.
+1be59c510612d (Richard Smith 2016-10-22 01:32:19 +0000 4588) return Ref_Compatible;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4589) }
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4590) bool ConvertedReferent = Conv != 0;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4591)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4592) // We can have a qualification conversion. Compute whether the types are
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4593) // similar at the same time.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4594) bool PreviousToQualsIncludeConst = true;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4595) bool TopLevel = true;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4596) do {
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4597) if (T1 == T2)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4598) break;
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 4599)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4600) // We will need a qualification conversion.
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4601) Conv |= ReferenceConversions::Qualification;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4602)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4603) // Track whether we performed a qualification conversion anywhere other
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4604) // than the top level. This matters for ranking reference bindings in
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4605) // overload resolution.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4606) if (!TopLevel)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4607) Conv |= ReferenceConversions::NestedQualification;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4608)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4609) // MS compiler ignores __unaligned qualifier for references; do the same.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4610) T1 = withoutUnaligned(Context, T1);
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4611) T2 = withoutUnaligned(Context, T2);
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4612)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4613) // If we find a qualifier mismatch, the types are not reference-compatible,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4614) // but are still be reference-related if they're similar.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4615) bool ObjCLifetimeConversion = false;
+6064f426a1830 (Anastasia Stulova 2020-02-06 11:56:21 +0000 4616) if (!isQualificationConversionStep(T2, T1, /*CStyle=*/false, TopLevel,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4617) PreviousToQualsIncludeConst,
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4618) ObjCLifetimeConversion))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4619) return (ConvertedReferent || Context.hasSimilarType(T1, T2))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4620) ? Ref_Related
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4621) : Ref_Incompatible;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4622)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4623) // FIXME: Should we track this for any level other than the first?
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4624) if (ObjCLifetimeConversion)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4625) Conv |= ReferenceConversions::ObjCLifetime;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4626)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4627) TopLevel = false;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4628) } while (Context.UnwrapSimilarTypes(T1, T2));
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4629)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4630) // At this point, if the types are reference-related, we must either have the
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4631) // same inner type (ignoring qualifiers), or must have already worked out how
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4632) // to convert the referent.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4633) return (ConvertedReferent || Context.hasSameUnqualifiedType(T1, T2))
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4634) ? Ref_Compatible
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4635) : Ref_Incompatible;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4636) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4637)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 4638) /// Look for a user-defined conversion to a value reference-compatible
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4639) /// with DeclType. Return true if something definite is found.
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4640) static bool
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4641) FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4642) QualType DeclType, SourceLocation DeclLoc,
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4643) Expr *Init, QualType T2, bool AllowRvalues,
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4644) bool AllowExplicit) {
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4645) assert(T2->isRecordType() && "Can only find conversions of record types.");
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 4646) auto *T2RecordDecl = cast<CXXRecordDecl>(T2->castAs<RecordType>()->getDecl());
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4647)
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 4648) OverloadCandidateSet CandidateSet(
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 4649) DeclLoc, OverloadCandidateSet::CSK_InitByUserDefinedConversion);
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 4650) const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 4651) for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4652) NamedDecl *D = *I;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4653) CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4654) if (isa<UsingShadowDecl>(D))
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4655) D = cast<UsingShadowDecl>(D)->getTargetDecl();
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4656)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4657) FunctionTemplateDecl *ConvTemplate
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4658) = dyn_cast<FunctionTemplateDecl>(D);
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4659) CXXConversionDecl *Conv;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4660) if (ConvTemplate)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4661) Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4662) else
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4663) Conv = cast<CXXConversionDecl>(D);
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4664)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4665) if (AllowRvalues) {
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4666) // If we are initializing an rvalue reference, don't permit conversion
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4667) // functions that return lvalues.
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4668) if (!ConvTemplate && DeclType->isRValueReferenceType()) {
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4669) const ReferenceType *RefType
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4670) = Conv->getConversionType()->getAs<LValueReferenceType>();
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4671) if (RefType && !RefType->getPointeeType()->isFunctionType())
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4672) continue;
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 4673) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 4674)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4675) if (!ConvTemplate &&
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 4676) S.CompareReferenceRelationship(
+766f15814a012 (Peter Collingbourne 2019-10-19 00:34:54 +0000 4677) DeclLoc,
+766f15814a012 (Peter Collingbourne 2019-10-19 00:34:54 +0000 4678) Conv->getConversionType()
+766f15814a012 (Peter Collingbourne 2019-10-19 00:34:54 +0000 4679) .getNonReferenceType()
+766f15814a012 (Peter Collingbourne 2019-10-19 00:34:54 +0000 4680) .getUnqualifiedType(),
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4681) DeclType.getNonReferenceType().getUnqualifiedType()) ==
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4682) Sema::Ref_Incompatible)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4683) continue;
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4684) } else {
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4685) // If the conversion function doesn't return a reference type,
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4686) // it can't be considered for this conversion. An rvalue reference
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4687) // is only acceptable if its referencee is a function type.
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4688)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4689) const ReferenceType *RefType =
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4690) Conv->getConversionType()->getAs<ReferenceType>();
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4691) if (!RefType ||
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4692) (!RefType->isLValueReferenceType() &&
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4693) !RefType->getPointeeType()->isFunctionType()))
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4694) continue;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4695) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4696)
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4697) if (ConvTemplate)
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 4698) S.AddTemplateConversionCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 4699) ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 4700) /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4701) else
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 4702) S.AddConversionCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 4703) Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 4704) /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4705) }
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4706)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 4707) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 4708)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4709) OverloadCandidateSet::iterator Best;
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 4710) switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4711) case OR_Success:
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4712) // C++ [over.ics.ref]p1:
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4713) //
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4714) // [...] If the parameter binds directly to the result of
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4715) // applying a conversion function to the argument
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4716) // expression, the implicit conversion sequence is a
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4717) // user-defined conversion sequence (13.3.3.1.2), with the
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4718) // second standard conversion sequence either an identity
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4719) // conversion or, if the conversion function returns an
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4720) // entity of a type that is a derived class of the parameter
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4721) // type, a derived-to-base Conversion.
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4722) if (!Best->FinalConversion.DirectBinding)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4723) return false;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4724)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4725) ICS.setUserDefined();
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4726) ICS.UserDefined.Before = Best->Conversions[0].Standard;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4727) ICS.UserDefined.After = Best->FinalConversion;
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 4728) ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4729) ICS.UserDefined.ConversionFunction = Best->Function;
+30909031a7f76 (John McCall 2011-09-21 08:36:56 +0000 4730) ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4731) ICS.UserDefined.EllipsisConversion = false;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4732) assert(ICS.UserDefined.After.ReferenceBinding &&
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4733) ICS.UserDefined.After.DirectBinding &&
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4734) "Expected a direct reference binding!");
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4735) return true;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4736)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4737) case OR_Ambiguous:
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4738) ICS.setAmbiguous();
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4739) for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4740) Cand != CandidateSet.end(); ++Cand)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 4741) if (Cand->Best)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 4742) ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4743) return true;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4744)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4745) case OR_No_Viable_Function:
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4746) case OR_Deleted:
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4747) // There was no suitable conversion, or we found a deleted
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4748) // conversion; continue with other checks.
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4749) return false;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4750) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4751)
+8a40f700e62b8 (David Blaikie 2012-01-17 06:56:22 +0000 4752) llvm_unreachable("Invalid OverloadResult!");
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4753) }
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4754)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 4755) /// Compute an implicit conversion sequence for reference
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4756) /// initialization.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4757) static ImplicitConversionSequence
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 4758) TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4759) SourceLocation DeclLoc,
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4760) bool SuppressUserConversions,
+adc7a704d2a38 (Douglas Gregor 2010-04-16 17:45:54 +0000 4761) bool AllowExplicit) {
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4762) assert(DeclType->isReferenceType() && "Reference init needs a reference");
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4763)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4764) // Most paths end in a failed conversion.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4765) ImplicitConversionSequence ICS;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4766) ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4767)
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 4768) QualType T1 = DeclType->castAs<ReferenceType>()->getPointeeType();
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4769) QualType T2 = Init->getType();
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4770)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4771) // If the initializer is the address of an overloaded function, try
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4772) // to resolve the overloaded function. If all goes well, T2 is the
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4773) // type of the resulting function.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4774) if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4775) DeclAccessPair Found;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4776) if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4777) false, Found))
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4778) T2 = Fn->getType();
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4779) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4780)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4781) // Compute some basic properties of the types and the initializer.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4782) bool isRValRef = DeclType->isRValueReferenceType();
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4783) Expr::Classification InitCategory = Init->Classify(S.Context);
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4784)
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4785) Sema::ReferenceConversions RefConv;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4786) Sema::ReferenceCompareResult RefRelationship =
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4787) S.CompareReferenceRelationship(DeclLoc, T1, T2, &RefConv);
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4788)
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4789) auto SetAsReferenceBinding = [&](bool BindsDirectly) {
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4790) ICS.setStandard();
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4791) ICS.Standard.First = ICK_Identity;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4792) // FIXME: A reference binding can be a function conversion too. We should
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4793) // consider that when ordering reference-to-function bindings.
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4794) ICS.Standard.Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4795) ? ICK_Derived_To_Base
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4796) : (RefConv & Sema::ReferenceConversions::ObjC)
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4797) ? ICK_Compatible_Conversion
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4798) : ICK_Identity;
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4799) // FIXME: As a speculative fix to a defect introduced by CWG2352, we rank
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4800) // a reference binding that performs a non-top-level qualification
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4801) // conversion as a qualification conversion, not as an identity conversion.
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4802) ICS.Standard.Third = (RefConv &
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4803) Sema::ReferenceConversions::NestedQualification)
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4804) ? ICK_Qualification
+f041e9ad706ae (Richard Smith 2020-01-09 15:31:56 -0800 4805) : ICK_Identity;
+065fc1eafe7c6 (Richard Smith 2020-07-07 18:25:57 -0700 4806) ICS.Standard.setFromType(T2);
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4807) ICS.Standard.setToType(0, T2);
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4808) ICS.Standard.setToType(1, T1);
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4809) ICS.Standard.setToType(2, T1);
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4810) ICS.Standard.ReferenceBinding = true;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4811) ICS.Standard.DirectBinding = BindsDirectly;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4812) ICS.Standard.IsLvalueReference = !isRValRef;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4813) ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4814) ICS.Standard.BindsToRvalue = InitCategory.isRValue();
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4815) ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4816) ICS.Standard.ObjCLifetimeConversionBinding =
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4817) (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4818) ICS.Standard.CopyConstructor = nullptr;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4819) ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4820) };
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4821)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4822) // C++0x [dcl.init.ref]p5:
+870f3743e4883 (Douglas Gregor 2010-04-18 09:22:00 +0000 4823) // A reference to type "cv1 T1" is initialized by an expression
+870f3743e4883 (Douglas Gregor 2010-04-18 09:22:00 +0000 4824) // of type "cv2 T2" as follows:
+870f3743e4883 (Douglas Gregor 2010-04-18 09:22:00 +0000 4825)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4826) // -- If reference is an lvalue reference and the initializer expression
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4827) if (!isRValRef) {
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4828) // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4829) // reference-compatible with "cv2 T2," or
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4830) //
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4831) // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
+ce76629905aa1 (Richard Smith 2016-10-21 23:01:55 +0000 4832) if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4833) // C++ [over.ics.ref]p1:
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4834) // When a parameter of reference type binds directly (8.5.3)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4835) // to an argument expression, the implicit conversion sequence
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4836) // is the identity conversion, unless the argument expression
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4837) // has a type that is a derived class of the parameter type,
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4838) // in which case the implicit conversion sequence is a
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4839) // derived-to-base Conversion (13.3.3.1).
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4840) SetAsReferenceBinding(/*BindsDirectly=*/true);
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4841)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4842) // Nothing more to do: the inaccessibility/ambiguity check for
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4843) // derived-to-base conversions is suppressed when we're
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4844) // computing the implicit conversion sequence (C++
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4845) // [over.best.ics]p2).
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4846) return ICS;
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4847) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4848)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4849) // -- has a class type (i.e., T2 is a class type), where T1 is
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4850) // not reference-related to T2, and can be implicitly
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4851) // converted to an lvalue of type "cv3 T3," where "cv1 T1"
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4852) // is reference-compatible with "cv3 T3" 92) (this
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4853) // conversion is selected by enumerating the applicable
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4854) // conversion functions (13.3.1.6) and choosing the best
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4855) // one through overload resolution (13.3)),
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4856) if (!SuppressUserConversions && T2->isRecordType() &&
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 4857) S.isCompleteType(DeclLoc, T2) &&
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4858) RefRelationship == Sema::Ref_Incompatible) {
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4859) if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4860) Init, T2, /*AllowRvalues=*/false,
+836a7e8468a76 (Douglas Gregor 2010-08-11 02:15:33 +0000 4861) AllowExplicit))
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4862) return ICS;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4863) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4864) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4865)
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4866) // -- Otherwise, the reference shall be an lvalue reference to a
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4867) // non-volatile const type (i.e., cv1 shall be const), or the reference
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4868) // shall be an rvalue reference.
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4869) if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified())) {
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4870) if (InitCategory.isRValue() && RefRelationship != Sema::Ref_Incompatible)
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4871) ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4872) return ICS;
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4873) }
+d92badfd9c998 (Sebastian Redl 2010-06-30 18:13:39 +0000 4874)
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4875) // -- If the initializer expression
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4876) //
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4877) // -- is an xvalue, class prvalue, array prvalue or function
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4878) // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
+ce76629905aa1 (Richard Smith 2016-10-21 23:01:55 +0000 4879) if (RefRelationship == Sema::Ref_Compatible &&
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4880) (InitCategory.isXValue() ||
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4881) (InitCategory.isPRValue() &&
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4882) (T2->isRecordType() || T2->isArrayType())) ||
+ce76629905aa1 (Richard Smith 2016-10-21 23:01:55 +0000 4883) (InitCategory.isLValue() && T2->isFunctionType()))) {
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4884) // In C++11, this is always a direct binding. In C++98/03, it's a direct
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4885) // binding unless we're binding to a class prvalue.
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4886) // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4887) // allow the use of rvalue references in C++98/03 for the benefit of
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4888) // standard library implementors; therefore, we need the xvalue check here.
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4889) SetAsReferenceBinding(/*BindsDirectly=*/S.getLangOpts().CPlusPlus11 ||
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 4890) !(InitCategory.isPRValue() || T2->isRecordType()));
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4891) return ICS;
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4892) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4893)
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4894) // -- has a class type (i.e., T2 is a class type), where T1 is not
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4895) // reference-related to T2, and can be implicitly converted to
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4896) // an xvalue, class prvalue, or function lvalue of type
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4897) // "cv3 T3", where "cv1 T1" is reference-compatible with
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4898) // "cv3 T3",
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4899) //
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4900) // then the reference is bound to the value of the initializer
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4901) // expression in the first case and to the result of the conversion
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4902) // in the second case (or, in either case, to an appropriate base
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4903) // class subobject).
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4904) if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 4905) T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4906) FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4907) Init, T2, /*AllowRvalues=*/true,
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4908) AllowExplicit)) {
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4909) // In the second case, if the reference is an rvalue reference
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4910) // and the second standard conversion sequence of the
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4911) // user-defined conversion sequence includes an lvalue-to-rvalue
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4912) // conversion, the program is ill-formed.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4913) if (ICS.isUserDefined() && isRValRef &&
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4914) ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4915) ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 4916)
+f143cd5051581 (Douglas Gregor 2011-01-24 16:14:37 +0000 4917) return ICS;
+be468d9a2b39a (Rafael Espindola 2011-01-22 15:32:35 +0000 4918) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 4919)
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4920) // A temporary of function type cannot be created; don't even try.
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4921) if (T1->isFunctionType())
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4922) return ICS;
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4923)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4924) // -- Otherwise, a temporary of type "cv1 T1" is created and
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4925) // initialized from the initializer expression using the
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4926) // rules for a non-reference copy initialization (8.5). The
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4927) // reference is then bound to the temporary. If T1 is
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4928) // reference-related to T2, cv1 must be the same
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4929) // cv-qualification as, or greater cv-qualification than,
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4930) // cv2; otherwise, the program is ill-formed.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4931) if (RefRelationship == Sema::Ref_Related) {
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4932) // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4933) // we would be reference-compatible or reference-compatible with
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4934) // added qualification. But that wasn't the case, so the reference
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4935) // initialization fails.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4936) //
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4937) // Note that we only want to check address spaces and cvr-qualifiers here.
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 4938) // ObjC GC, lifetime and unaligned qualifiers aren't important.
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4939) Qualifiers T1Quals = T1.getQualifiers();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4940) Qualifiers T2Quals = T2.getQualifiers();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4941) T1Quals.removeObjCGCAttr();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4942) T1Quals.removeObjCLifetime();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4943) T2Quals.removeObjCGCAttr();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4944) T2Quals.removeObjCLifetime();
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 4945) // MS compiler ignores __unaligned qualifier for references; do the same.
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 4946) T1Quals.removeUnaligned();
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 4947) T2Quals.removeUnaligned();
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4948) if (!T1Quals.compatiblyIncludes(T2Quals))
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4949) return ICS;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4950) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4951)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4952) // If at least one of the types is a class type, the types are not
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4953) // related, and we aren't allowed any user conversions, the
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4954) // reference binding fails. This case is important for breaking
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4955) // recursion, since TryImplicitConversion below will attempt to
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4956) // create a temporary through the use of a copy constructor.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4957) if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4958) (T1->isRecordType() || T2->isRecordType()))
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4959) return ICS;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4960)
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 4961) // If T1 is reference-related to T2 and the reference is an rvalue
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 4962) // reference, the initializer expression shall not be an lvalue.
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4963) if (RefRelationship >= Sema::Ref_Related && isRValRef &&
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4964) Init->Classify(S.Context).isLValue()) {
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4965) ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, Init, DeclType);
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 4966) return ICS;
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 4967) }
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 4968)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4969) // C++ [over.ics.ref]p2:
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4970) // When a parameter of reference type is not bound directly to
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4971) // an argument expression, the conversion sequence is the one
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4972) // required to convert the argument expression to the
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4973) // underlying type of the reference according to
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4974) // 13.3.3.1. Conceptually, this conversion sequence corresponds
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4975) // to copy-initializing a temporary of the underlying type with
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4976) // the argument expression. Any
diff erence in top-level
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4977) // cv-qualification is subsumed by the initialization itself
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4978) // and does not constitute a conversion.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 4979) ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 4980) AllowedExplicit::None,
+582813596a100 (Douglas Gregor 2011-01-27 00:58:17 +0000 4981) /*InOverloadResolution=*/false,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4982) /*CStyle=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 4983) /*AllowObjCWritebackConversion=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 4984) /*AllowObjCConversionOnExplicit=*/false);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4985)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4986) // Of course, that's still a reference binding.
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4987) if (ICS.isStandard()) {
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4988) ICS.Standard.ReferenceBinding = true;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4989) ICS.Standard.IsLvalueReference = !isRValRef;
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4990) ICS.Standard.BindsToFunctionLvalue = false;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 4991) ICS.Standard.BindsToRvalue = true;
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 4992) ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 4993) ICS.Standard.ObjCLifetimeConversionBinding = false;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 4994) } else if (ICS.isUserDefined()) {
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4995) const ReferenceType *LValRefType =
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4996) ICS.UserDefined.ConversionFunction->getReturnType()
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4997) ->getAs<LValueReferenceType>();
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4998)
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 4999) // C++ [over.ics.ref]p3:
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5000) // Except for an implicit object parameter, for which see 13.3.1, a
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5001) // standard conversion sequence cannot be formed if it requires [...]
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5002) // binding an rvalue reference to an lvalue other than a function
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5003) // lvalue.
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5004) // Note that the function case is not possible here.
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 5005) if (isRValRef && LValRefType) {
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 5006) ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5007) return ICS;
+b0e6c8a3500c1 (Douglas Gregor 2011-10-04 23:59:32 +0000 5008) }
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5009)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5010) ICS.UserDefined.After.ReferenceBinding = true;
+3ec7910e10b6f (Douglas Gregor 2011-08-15 13:59:46 +0000 5011) ICS.UserDefined.After.IsLvalueReference = !isRValRef;
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5012) ICS.UserDefined.After.BindsToFunctionLvalue = false;
+19172c4f70fac (Richard Smith 2014-07-14 02:28:44 +0000 5013) ICS.UserDefined.After.BindsToRvalue = !LValRefType;
+3ec7910e10b6f (Douglas Gregor 2011-08-15 13:59:46 +0000 5014) ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
+3ec7910e10b6f (Douglas Gregor 2011-08-15 13:59:46 +0000 5015) ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5016) }
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 5017)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5018) return ICS;
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5019) }
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5020)
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5021) static ImplicitConversionSequence
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5022) TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5023) bool SuppressUserConversions,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5024) bool InOverloadResolution,
+6073dcab38e4e (Douglas Gregor 2012-02-24 23:56:31 +0000 5025) bool AllowObjCWritebackConversion,
+6073dcab38e4e (Douglas Gregor 2012-02-24 23:56:31 +0000 5026) bool AllowExplicit = false);
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5027)
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5028) /// TryListConversion - Try to copy-initialize a value of type ToType from the
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5029) /// initializer list From.
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5030) static ImplicitConversionSequence
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5031) TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5032) bool SuppressUserConversions,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5033) bool InOverloadResolution,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5034) bool AllowObjCWritebackConversion) {
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5035) // C++11 [over.ics.list]p1:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5036) // When an argument is an initializer list, it is not an expression and
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5037) // special rules apply for converting it to a parameter type.
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5038)
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5039) ImplicitConversionSequence Result;
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5040) Result.setBad(BadConversionSequence::no_conversion, From, ToType);
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5041)
+09edce0400716 (Sebastian Redl 2012-01-23 22:09:39 +0000 5042) // We need a complete type for what follows. Incomplete types can never be
+10f0fc04a8f50 (Sebastian Redl 2012-01-17 22:49:48 +0000 5043) // initialized from init lists.
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5044) if (!S.isCompleteType(From->getBeginLoc(), ToType))
+10f0fc04a8f50 (Sebastian Redl 2012-01-17 22:49:48 +0000 5045) return Result;
+10f0fc04a8f50 (Sebastian Redl 2012-01-17 22:49:48 +0000 5046)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5047) // Per DR1467:
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5048) // If the parameter type is a class X and the initializer list has a single
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5049) // element of type cv U, where U is X or a class derived from X, the
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5050) // implicit conversion sequence is the one required to convert the element
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5051) // to the parameter type.
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5052) //
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5053) // Otherwise, if the parameter type is a character array [... ]
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5054) // and the initializer list has a single element that is an
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5055) // appropriately-typed string literal (8.5.2 [dcl.init.string]), the
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5056) // implicit conversion sequence is the identity conversion.
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5057) if (From->getNumInits() == 1) {
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5058) if (ToType->isRecordType()) {
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5059) QualType InitType = From->getInit(0)->getType();
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5060) if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5061) S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5062) return TryCopyInitialization(S, From->getInit(0), ToType,
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5063) SuppressUserConversions,
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5064) InOverloadResolution,
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5065) AllowObjCWritebackConversion);
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5066) }
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5067)
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5068) if (const auto *AT = S.Context.getAsArrayType(ToType)) {
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5069) if (S.IsStringInit(From->getInit(0), AT)) {
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5070) InitializedEntity Entity =
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5071) InitializedEntity::InitializeParameter(S.Context, ToType,
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5072) /*Consumed=*/false);
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5073) if (S.CanPerformCopyInitialization(Entity, From)) {
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5074) Result.setStandard();
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5075) Result.Standard.setAsIdentityConversion();
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5076) Result.Standard.setFromType(ToType);
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5077) Result.Standard.setAllToTypes(ToType);
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5078) return Result;
+0ce6d6b46eb70 (Mark de Wever 2020-10-03 14:31:46 +0200 5079) }
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5080) }
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5081) }
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5082) }
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5083)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5084) // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5085) // C++11 [over.ics.list]p2:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5086) // If the parameter type is std::initializer_list<X> or "array of X" and
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5087) // all the elements can be implicitly converted to X, the implicit
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5088) // conversion sequence is the worst conversion necessary to convert an
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5089) // element of the list to X.
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5090) //
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5091) // C++14 [over.ics.list]p3:
+b01d86b3159a5 (NAKAMURA Takumi 2015-02-25 11:02:00 +0000 5092) // Otherwise, if the parameter type is "array of N X", if the initializer
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5093) // list has exactly N elements or if it has fewer than N elements and X is
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5094) // default-constructible, and if all the elements of the initializer list
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5095) // can be implicitly converted to X, the implicit conversion sequence is
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5096) // the worst conversion necessary to convert an element of the list to X.
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 5097) //
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5098) QualType InitTy = ToType;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5099) ArrayType const *AT = S.Context.getAsArrayType(ToType);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5100) if (AT || S.isStdInitializerList(ToType, &InitTy)) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5101) unsigned e = From->getNumInits();
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5102) bool Clear = true;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5103) if (AT) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5104) InitTy = AT->getElementType();
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5105) if (ConstantArrayType const *CT = dyn_cast<ConstantArrayType>(AT)) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5106) if (CT->getSize().ult(e))
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5107) Clear = false; // Too many inits, fatally bad
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5108) else if (CT->getSize().ugt(e)) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5109) // Need an init from empty {}, is there one?
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5110) // FIXME: Is there a simpler way than this?
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5111) InitListExpr EmptyList(S.Context, From->getEndLoc(), None,
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5112) From->getEndLoc());
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5113) EmptyList.setType(S.Context.VoidTy);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5114) auto ICS = TryListConversion(
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5115) S, &EmptyList, InitTy, SuppressUserConversions,
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5116) InOverloadResolution, AllowObjCWritebackConversion);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5117) if (!ICS.isBad())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5118) Result = ICS;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5119) Clear = false;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5120) }
+10f0fc04a8f50 (Sebastian Redl 2012-01-17 22:49:48 +0000 5121) }
+10f0fc04a8f50 (Sebastian Redl 2012-01-17 22:49:48 +0000 5122) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5123) if (Clear) {
+0f5c1c01273da (Douglas Gregor 2012-04-04 23:09:20 +0000 5124) Result.setStandard();
+0f5c1c01273da (Douglas Gregor 2012-04-04 23:09:20 +0000 5125) Result.Standard.setAsIdentityConversion();
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5126) Result.Standard.setFromType(InitTy);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5127) Result.Standard.setAllToTypes(InitTy);
+0f5c1c01273da (Douglas Gregor 2012-04-04 23:09:20 +0000 5128) }
+0f5c1c01273da (Douglas Gregor 2012-04-04 23:09:20 +0000 5129)
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5130) if (!Result.isBad())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5131) for (unsigned i = 0; i < e; ++i) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5132) Expr *Init = From->getInit(i);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5133) ImplicitConversionSequence ICS = TryCopyInitialization(
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5134) S, Init, InitTy, SuppressUserConversions, InOverloadResolution,
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5135) AllowObjCWritebackConversion);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5136) // Keep the worse conversion.
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5137) if (CompareImplicitConversionSequences(S, From->getBeginLoc(), ICS,
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5138) Result) ==
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5139) ImplicitConversionSequence::Worse) {
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5140) Result = ICS;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5141) // Bail as soon as we find something unconvertible.
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5142) if (Result.isBad())
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5143) break;
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5144) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5145) }
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5146)
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5147) // Record the type being initialized so that we may compare sequences
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5148) Result.setInitializerListToType(ToType);
+cc812d9aa51bf (Nathan Sidwell 2021-05-25 07:04:25 -0700 5149)
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5150) return Result;
+10f0fc04a8f50 (Sebastian Redl 2012-01-17 22:49:48 +0000 5151) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5152)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5153) // C++14 [over.ics.list]p4:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5154) // C++11 [over.ics.list]p3:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5155) // Otherwise, if the parameter is a non-aggregate class X and overload
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5156) // resolution chooses a single best constructor [...] the implicit
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5157) // conversion sequence is a user-defined conversion sequence. If multiple
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5158) // constructors are viable but none is better than the others, the
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5159) // implicit conversion sequence is a user-defined conversion sequence.
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 5160) if (ToType->isRecordType() && !ToType->isAggregateType()) {
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 5161) // This function can deal with initializer lists.
+a93f1028a07a9 (Richard Smith 2013-09-06 22:30:28 +0000 5162) return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 5163) AllowedExplicit::None,
+a93f1028a07a9 (Richard Smith 2013-09-06 22:30:28 +0000 5164) InOverloadResolution, /*CStyle=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5165) AllowObjCWritebackConversion,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5166) /*AllowObjCConversionOnExplicit=*/false);
+6901c0de675f3 (Sebastian Redl 2011-12-22 18:58:38 +0000 5167) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5168)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5169) // C++14 [over.ics.list]p5:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5170) // C++11 [over.ics.list]p4:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5171) // Otherwise, if the parameter has an aggregate type which can be
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5172) // initialized from the initializer list [...] the implicit conversion
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5173) // sequence is a user-defined conversion sequence.
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5174) if (ToType->isAggregateType()) {
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5175) // Type is an aggregate, argument is an init list. At this point it comes
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5176) // down to checking whether the initialization works.
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5177) // FIXME: Find out whether this parameter is consumed or not.
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5178) InitializedEntity Entity =
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5179) InitializedEntity::InitializeParameter(S.Context, ToType,
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5180) /*Consumed=*/false);
+5030928d60a1d (Richard Smith 2019-08-30 22:52:55 +0000 5181) if (S.CanPerformAggregateInitializationForOverloadResolution(Entity,
+5030928d60a1d (Richard Smith 2019-08-30 22:52:55 +0000 5182) From)) {
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5183) Result.setUserDefined();
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5184) Result.UserDefined.Before.setAsIdentityConversion();
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5185) // Initializer lists don't have a type.
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5186) Result.UserDefined.Before.setFromType(QualType());
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5187) Result.UserDefined.Before.setAllToTypes(QualType());
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5188)
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5189) Result.UserDefined.After.setAsIdentityConversion();
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5190) Result.UserDefined.After.setFromType(ToType);
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5191) Result.UserDefined.After.setAllToTypes(ToType);
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 5192) Result.UserDefined.ConversionFunction = nullptr;
+72ef7bc2b580f (Sebastian Redl 2011-11-01 15:53:09 +0000 5193) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5194) return Result;
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5195) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5196)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5197) // C++14 [over.ics.list]p6:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5198) // C++11 [over.ics.list]p5:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5199) // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5200) if (ToType->isReferenceType()) {
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5201) // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5202) // mention initializer lists in any way. So we go by what list-
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5203) // initialization would do and try to extrapolate from that.
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5204)
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 5205) QualType T1 = ToType->castAs<ReferenceType>()->getPointeeType();
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5206)
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5207) // If the initializer list has a single element that is reference-related
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5208) // to the parameter type, we initialize the reference from that.
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5209) if (From->getNumInits() == 1) {
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5210) Expr *Init = From->getInit(0);
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5211)
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5212) QualType T2 = Init->getType();
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5213)
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5214) // If the initializer is the address of an overloaded function, try
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5215) // to resolve the overloaded function. If all goes well, T2 is the
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5216) // type of the resulting function.
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5217) if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5218) DeclAccessPair Found;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5219) if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5220) Init, ToType, false, Found))
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5221) T2 = Fn->getType();
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5222) }
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5223)
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5224) // Compute some basic properties of the types and the initializer.
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5225) Sema::ReferenceCompareResult RefRelationship =
+3ced23976aa8a (Richard Smith 2019-12-18 14:01:40 -0800 5226) S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2);
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5227)
+4d2bbd78ff7eb (Richard Smith 2013-09-06 01:22:42 +0000 5228) if (RefRelationship >= Sema::Ref_Related) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5229) return TryReferenceInit(S, Init, ToType, /*FIXME*/ From->getBeginLoc(),
+a93f1028a07a9 (Richard Smith 2013-09-06 22:30:28 +0000 5230) SuppressUserConversions,
+a93f1028a07a9 (Richard Smith 2013-09-06 22:30:28 +0000 5231) /*AllowExplicit=*/false);
+4d2bbd78ff7eb (Richard Smith 2013-09-06 01:22:42 +0000 5232) }
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5233) }
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5234)
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5235) // Otherwise, we bind the reference to a temporary created from the
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5236) // initializer list.
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5237) Result = TryListConversion(S, From, T1, SuppressUserConversions,
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5238) InOverloadResolution,
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5239) AllowObjCWritebackConversion);
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5240) if (Result.isFailure())
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5241) return Result;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5242) assert(!Result.isEllipsis() &&
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5243) "Sub-initialization cannot result in ellipsis conversion.");
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5244)
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5245) // Can we even bind to a temporary?
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5246) if (ToType->isRValueReferenceType() ||
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5247) (T1.isConstQualified() && !T1.isVolatileQualified())) {
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5248) StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5249) Result.UserDefined.After;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5250) SCS.ReferenceBinding = true;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5251) SCS.IsLvalueReference = ToType->isLValueReferenceType();
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5252) SCS.BindsToRvalue = true;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5253) SCS.BindsToFunctionLvalue = false;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5254) SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5255) SCS.ObjCLifetimeConversionBinding = false;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5256) } else
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5257) Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue,
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5258) From, ToType);
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5259) return Result;
+df888642733dd (Sebastian Redl 2011-12-03 14:54:30 +0000 5260) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5261)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5262) // C++14 [over.ics.list]p7:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5263) // C++11 [over.ics.list]p6:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5264) // Otherwise, if the parameter type is not a class:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5265) if (!ToType->isRecordType()) {
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5266) // - if the initializer list has one element that is not itself an
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5267) // initializer list, the implicit conversion sequence is the one
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5268) // required to convert the element to the parameter type.
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5269) unsigned NumInits = From->getNumInits();
+1bbaba874633e (Richard Smith 2015-01-27 23:23:39 +0000 5270) if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5271) Result = TryCopyInitialization(S, From->getInit(0), ToType,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5272) SuppressUserConversions,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5273) InOverloadResolution,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5274) AllowObjCWritebackConversion);
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5275) // - if the initializer list has no elements, the implicit conversion
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5276) // sequence is the identity conversion.
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5277) else if (NumInits == 0) {
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5278) Result.setStandard();
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5279) Result.Standard.setAsIdentityConversion();
+b73bc9af60367 (John McCall 2012-04-04 02:40:27 +0000 5280) Result.Standard.setFromType(ToType);
+b73bc9af60367 (John McCall 2012-04-04 02:40:27 +0000 5281) Result.Standard.setAllToTypes(ToType);
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5282) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5283) return Result;
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5284) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5285)
+19d08672844ee (Larisse Voufo 2015-01-27 18:47:05 +0000 5286) // C++14 [over.ics.list]p8:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5287) // C++11 [over.ics.list]p7:
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5288) // In all cases other than those enumerated above, no conversion is possible
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5289) return Result;
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5290) }
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5291)
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 5292) /// TryCopyInitialization - Try to copy-initialize a value of type
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 5293) /// ToType from the expression From. Return the implicit conversion
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 5294) /// sequence required to pass this argument, which may be a bad
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 5295) /// conversion sequence (meaning that the argument cannot be passed to
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 5296) /// a parameter of this type). If @p SuppressUserConversions, then we
+e81335c85ba47 (Douglas Gregor 2010-04-16 18:00:29 +0000 5297) /// do not permit any user-defined conversion sequences.
+cb13cfc878200 (Douglas Gregor 2010-04-16 17:51:22 +0000 5298) static ImplicitConversionSequence
+cb13cfc878200 (Douglas Gregor 2010-04-16 17:51:22 +0000 5299) TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5300) bool SuppressUserConversions,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 5301) bool InOverloadResolution,
+6073dcab38e4e (Douglas Gregor 2012-02-24 23:56:31 +0000 5302) bool AllowObjCWritebackConversion,
+6073dcab38e4e (Douglas Gregor 2012-02-24 23:56:31 +0000 5303) bool AllowExplicit) {
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5304) if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5305) return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5306) InOverloadResolution,AllowObjCWritebackConversion);
+b17be8dcfec4a (Sebastian Redl 2011-10-16 18:19:34 +0000 5307)
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5308) if (ToType->isReferenceType())
+cb13cfc878200 (Douglas Gregor 2010-04-16 17:51:22 +0000 5309) return TryReferenceInit(S, From, ToType,
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5310) /*FIXME:*/ From->getBeginLoc(),
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5311) SuppressUserConversions, AllowExplicit);
+38ae6ab6bc14d (Douglas Gregor 2010-04-13 16:31:36 +0000 5312)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5313) return TryImplicitConversion(S, From, ToType,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5314) SuppressUserConversions,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 5315) AllowedExplicit::None,
+582813596a100 (Douglas Gregor 2011-01-27 00:58:17 +0000 5316) InOverloadResolution,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 5317) /*CStyle=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5318) AllowObjCWritebackConversion,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5319) /*AllowObjCConversionOnExplicit=*/false);
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 5320) }
+8e1cf608dc587 (Douglas Gregor 2008-10-29 00:13:59 +0000 5321)
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5322) static bool TryCopyInitialization(const CanQualType FromQTy,
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5323) const CanQualType ToQTy,
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5324) Sema &S,
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5325) SourceLocation Loc,
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5326) ExprValueKind FromVK) {
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5327) OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5328) ImplicitConversionSequence ICS =
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5329) TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5330)
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5331) return !ICS.isBad();
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5332) }
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 5333)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5334) /// TryObjectArgumentInitialization - Try to initialize the object
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5335) /// parameter of the given member function (@c Method) from the
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5336) /// expression @p From.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5337) static ImplicitConversionSequence
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 5338) TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5339) Expr::Classification FromClassification,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5340) CXXMethodDecl *Method,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5341) CXXRecordDecl *ActingContext) {
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5342) QualType ClassType = S.Context.getTypeDeclType(ActingContext);
+931e0bd331953 (Sebastian Redl 2009-11-18 20:55:52 +0000 5343) // [class.dtor]p2: A destructor can be invoked for a const, volatile or
+931e0bd331953 (Sebastian Redl 2009-11-18 20:55:52 +0000 5344) // const volatile object.
+88559637641e9 (Marco Antognini 2019-07-22 09:39:13 +0000 5345) Qualifiers Quals = Method->getMethodQualifiers();
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5346) if (isa<CXXDestructorDecl>(Method)) {
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5347) Quals.addConst();
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5348) Quals.addVolatile();
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5349) }
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5350)
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5351) QualType ImplicitParamType = S.Context.getQualifiedType(ClassType, Quals);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5352)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5353) // Set up the conversion sequence as a "bad" conversion, to allow us
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5354) // to exit early.
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5355) ImplicitConversionSequence ICS;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5356)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5357) // We need to have an object of class type.
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5358) if (const PointerType *PT = FromType->getAs<PointerType>()) {
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5359) FromType = PT->getPointeeType();
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5360)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5361) // When we had a pointer, it's implicitly dereferenced, so we
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5362) // better have an lvalue.
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5363) assert(FromClassification.isLValue());
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5364) }
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5365)
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5366) assert(FromType->isRecordType());
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5367)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5368) // C++0x [over.match.funcs]p4:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5369) // For non-static member functions, the type of the implicit object
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5370) // parameter is
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5371) //
+7c2888689dfdd (NAKAMURA Takumi 2011-01-27 07:09:49 +0000 5372) // - "lvalue reference to cv X" for functions declared without a
+7c2888689dfdd (NAKAMURA Takumi 2011-01-27 07:09:49 +0000 5373) // ref-qualifier or with the & ref-qualifier
+7c2888689dfdd (NAKAMURA Takumi 2011-01-27 07:09:49 +0000 5374) // - "rvalue reference to cv X" for functions declared with the &&
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5375) // ref-qualifier
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5376) //
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5377) // where X is the class of which the function is a member and cv is the
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5378) // cv-qualification on the member function declaration.
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5379) //
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5380) // However, when finding an implicit conversion sequence for the argument, we
+122f88d481971 (Richard Smith 2016-12-06 23:52:28 +0000 5381) // are not allowed to perform user-defined conversions
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5382) // (C++ [over.match.funcs]p5). We perform a simplified version of
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5383) // reference binding here, that allows class rvalues to bind to
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5384) // non-constant references.
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5385)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5386) // First check the qualifiers.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5387) QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5388) if (ImplicitParamType.getCVRQualifiers()
+1b8fe5b716b8b (Douglas Gregor 2009-11-16 21:35:15 +0000 5389) != FromTypeCanon.getLocalCVRQualifiers() &&
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 5390) !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5391) ICS.setBad(BadConversionSequence::bad_qualifiers,
+03c66d3c57b51 (Richard Smith 2013-01-26 02:07:32 +0000 5392) FromType, ImplicitParamType);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5393) return ICS;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 5394) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5395)
+f2ace9d6005b4 (Michael Liao 2019-12-06 11:48:15 -0500 5396) if (FromTypeCanon.hasAddressSpace()) {
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5397) Qualifiers QualsImplicitParamType = ImplicitParamType.getQualifiers();
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5398) Qualifiers QualsFromType = FromTypeCanon.getQualifiers();
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5399) if (!QualsImplicitParamType.isAddressSpaceSupersetOf(QualsFromType)) {
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5400) ICS.setBad(BadConversionSequence::bad_qualifiers,
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5401) FromType, ImplicitParamType);
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5402) return ICS;
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5403) }
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5404) }
+5cffa45401149 (Anastasia Stulova 2019-01-21 16:01:38 +0000 5405)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5406) // Check that we have either the same type or a derived type. It
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5407) // affects the conversion rank.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5408) QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5409) ImplicitConversionKind SecondKind;
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5410) if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5411) SecondKind = ICK_Identity;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 5412) } else if (S.IsDerivedFrom(Loc, FromType, ClassType))
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5413) SecondKind = ICK_Derived_To_Base;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 5414) else {
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5415) ICS.setBad(BadConversionSequence::unrelated_class,
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5416) FromType, ImplicitParamType);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5417) return ICS;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 5418) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5419)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5420) // Check the ref-qualifier.
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5421) switch (Method->getRefQualifier()) {
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5422) case RQ_None:
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5423) // Do nothing; we don't care about lvalueness or rvalueness.
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5424) break;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5425)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5426) case RQ_LValue:
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5427) if (!FromClassification.isLValue() && !Quals.hasOnlyConst()) {
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5428) // non-const lvalue reference cannot bind to an rvalue
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5429) ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5430) ImplicitParamType);
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5431) return ICS;
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5432) }
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5433) break;
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5434)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5435) case RQ_RValue:
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5436) if (!FromClassification.isRValue()) {
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5437) // rvalue reference cannot bind to an lvalue
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5438) ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5439) ImplicitParamType);
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5440) return ICS;
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5441) }
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5442) break;
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5443) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5444)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5445) // Success. Mark this as a reference binding.
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 5446) ICS.setStandard();
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5447) ICS.Standard.setAsIdentityConversion();
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 5448) ICS.Standard.Second = SecondKind;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 5449) ICS.Standard.setFromType(FromType);
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 5450) ICS.Standard.setAllToTypes(ImplicitParamType);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5451) ICS.Standard.ReferenceBinding = true;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5452) ICS.Standard.DirectBinding = true;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5453) ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
+e696ebbd70b3d (Douglas Gregor 2011-01-26 14:52:12 +0000 5454) ICS.Standard.BindsToFunctionLvalue = false;
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 5455) ICS.Standard.BindsToRvalue = FromClassification.isRValue();
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 5456) ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
+e1a47c176656a (Douglas Gregor 2011-01-26 19:41:18 +0000 5457) = (Method->getRefQualifier() == RQ_None);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5458) return ICS;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5459) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5460)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5461) /// PerformObjectArgumentInitialization - Perform initialization of
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5462) /// the implicit object parameter for the given Method with the given
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5463) /// expression.
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5464) ExprResult
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5465) Sema::PerformObjectArgumentInitialization(Expr *From,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5466) NestedNameSpecifier *Qualifier,
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 5467) NamedDecl *FoundDecl,
+cc3f325fa69e7 (Douglas Gregor 2010-03-03 23:55:11 +0000 5468) CXXMethodDecl *Method) {
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5469) QualType FromRecordType, DestType;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 5470) QualType ImplicitParamRecordType =
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 5471) Method->getThisType()->castAs<PointerType>()->getPointeeType();
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 5472)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5473) Expr::Classification FromClassification;
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 5474) if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5475) FromRecordType = PT->getPointeeType();
+5488ab4ddd47a (Brian Gesiak 2019-01-11 01:54:53 +0000 5476) DestType = Method->getThisType();
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5477) FromClassification = Expr::Classification::makeSimpleLValue();
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5478) } else {
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5479) FromRecordType = From->getType();
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5480) DestType = ImplicitParamRecordType;
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 5481) FromClassification = From->Classify(Context);
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5482)
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5483) // When performing member access on an rvalue, materialize a temporary.
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5484) if (From->isRValue()) {
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5485) From = CreateMaterializeTemporaryExpr(FromRecordType, From,
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5486) Method->getRefQualifier() !=
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5487) RefQualifierKind::RQ_RValue);
+7ed5fb2d22942 (Richard Smith 2018-07-27 17:13:18 +0000 5488) }
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5489) }
+bfdea0f13684f (Anders Carlsson 2009-05-01 18:34:30 +0000 5490)
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 5491) // Note that we always use the true parent context when performing
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 5492) // the actual argument initialization.
+b58e51c304112 (Nico Weber 2014-11-19 05:21:39 +0000 5493) ImplicitConversionSequence ICS = TryObjectArgumentInitialization(
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5494) *this, From->getBeginLoc(), From->getType(), FromClassification, Method,
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 5495) Method->getParent());
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5496) if (ICS.isBad()) {
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5497) switch (ICS.Bad.Kind) {
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5498) case BadConversionSequence::bad_qualifiers: {
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5499) Qualifiers FromQs = FromRecordType.getQualifiers();
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5500) Qualifiers ToQs = DestType.getQualifiers();
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5501) unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5502) if (CVR) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5503) Diag(From->getBeginLoc(), diag::err_member_function_call_bad_cvr)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5504) << Method->getDeclName() << FromRecordType << (CVR - 1)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5505) << From->getSourceRange();
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5506) Diag(Method->getLocation(), diag::note_previous_decl)
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5507) << Method->getDeclName();
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5508) return ExprError();
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5509) }
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5510) break;
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5511) }
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5512)
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5513) case BadConversionSequence::lvalue_ref_to_rvalue:
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5514) case BadConversionSequence::rvalue_ref_to_lvalue: {
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5515) bool IsRValueQualified =
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5516) Method->getRefQualifier() == RefQualifierKind::RQ_RValue;
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5517) Diag(From->getBeginLoc(), diag::err_member_function_call_bad_ref)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5518) << Method->getDeclName() << FromClassification.isRValue()
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5519) << IsRValueQualified;
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5520) Diag(Method->getLocation(), diag::note_previous_decl)
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5521) << Method->getDeclName();
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5522) return ExprError();
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5523) }
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5524)
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5525) case BadConversionSequence::no_conversion:
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5526) case BadConversionSequence::unrelated_class:
+bb93578108c52 (Jacob Bandes-Storch 2017-12-31 18:27:29 +0000 5527) break;
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5528) }
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5529)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5530) return Diag(From->getBeginLoc(), diag::err_member_function_call_bad_type)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5531) << ImplicitParamRecordType << FromRecordType
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5532) << From->getSourceRange();
+9813d3221d7d5 (Argyrios Kyrtzidis 2010-11-16 08:04:45 +0000 5533) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 5534)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5535) if (ICS.Standard.Second == ICK_Derived_To_Base) {
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5536) ExprResult FromRes =
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5537) PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5538) if (FromRes.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5539) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 5540) From = FromRes.get();
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5541) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5542)
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5543) if (!Context.hasSameType(From->getType(), DestType)) {
+26e095e84f0d0 (Anastasia Stulova 2019-05-02 16:10:50 +0000 5544) CastKind CK;
+82888b78d47ed (Sven van Haastregt 2019-11-04 13:12:17 +0000 5545) QualType PteeTy = DestType->getPointeeType();
+82888b78d47ed (Sven van Haastregt 2019-11-04 13:12:17 +0000 5546) LangAS DestAS =
+82888b78d47ed (Sven van Haastregt 2019-11-04 13:12:17 +0000 5547) PteeTy.isNull() ? DestType.getAddressSpace() : PteeTy.getAddressSpace();
+82888b78d47ed (Sven van Haastregt 2019-11-04 13:12:17 +0000 5548) if (FromRecordType.getAddressSpace() != DestAS)
+26e095e84f0d0 (Anastasia Stulova 2019-05-02 16:10:50 +0000 5549) CK = CK_AddressSpaceConversion;
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5550) else
+26e095e84f0d0 (Anastasia Stulova 2019-05-02 16:10:50 +0000 5551) CK = CK_NoOp;
+26e095e84f0d0 (Anastasia Stulova 2019-05-02 16:10:50 +0000 5552) From = ImpCastExprToType(From, DestType, CK, From->getValueKind()).get();
+9d2872db7495d (Mikael Nilsson 2018-12-13 10:15:27 +0000 5553) }
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 5554) return From;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5555) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 5556)
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5557) /// TryContextuallyConvertToBool - Attempt to contextually convert the
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5558) /// expression From to bool (C++0x [conv]p3).
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5559) static ImplicitConversionSequence
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5560) TryContextuallyConvertToBool(Sema &S, Expr *From) {
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5561) // C++ [dcl.init]/17.8:
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5562) // - Otherwise, if the initialization is direct-initialization, the source
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5563) // type is std::nullptr_t, and the destination type is bool, the initial
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5564) // value of the object being initialized is false.
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5565) if (From->getType()->isNullPtrType())
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5566) return ImplicitConversionSequence::getNullptrToBool(From->getType(),
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5567) S.Context.BoolTy,
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5568) From->isGLValue());
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5569)
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5570) // All other direct-initialization of bool is equivalent to an implicit
+9ce6dc9872be4 (Richard Smith 2020-02-11 06:09:18 -0800 5571) // conversion to bool in which explicit conversions are permitted.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5572) return TryImplicitConversion(S, From, S.Context.BoolTy,
+ef4c72135f8ec (Anders Carlsson 2009-08-27 17:24:15 +0000 5573) /*SuppressUserConversions=*/false,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 5574) AllowedExplicit::Conversions,
+582813596a100 (Douglas Gregor 2011-01-27 00:58:17 +0000 5575) /*InOverloadResolution=*/false,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 5576) /*CStyle=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5577) /*AllowObjCWritebackConversion=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5578) /*AllowObjCConversionOnExplicit=*/false);
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5579) }
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5580)
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5581) /// PerformContextuallyConvertToBool - Perform a contextual conversion
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5582) /// of the expression From to bool (C++0x [conv]p3).
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5583) ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 5584) if (checkPlaceholderForOverload(*this, From))
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 5585) return ExprError();
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 5586)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5587) ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 5588) if (!ICS.isBad())
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 5589) return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5590)
+76197416ac15c (Fariborz Jahanian 2009-11-18 18:26:29 +0000 5591) if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5592) return Diag(From->getBeginLoc(), diag::err_typecheck_bool_condition)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5593) << From->getType() << From->getSourceRange();
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 5594) return ExprError();
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5595) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 5596)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5597) /// Check that the specified conversion is permitted in a converted constant
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5598) /// expression, according to C++11 [expr.const]p3. Return true if the conversion
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5599) /// is acceptable.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5600) static bool CheckConvertedConstantConversions(Sema &S,
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5601) StandardConversionSequence &SCS) {
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5602) // Since we know that the target type is an integral or unscoped enumeration
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5603) // type, most conversion kinds are impossible. All possible First and Third
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5604) // conversions are fine.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5605) switch (SCS.Second) {
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5606) case ICK_Identity:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5607) case ICK_Integral_Promotion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5608) case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
+89831421af27b (Egor Churaev 2016-12-23 14:55:49 +0000 5609) case ICK_Zero_Queue_Conversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5610) return true;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5611)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5612) case ICK_Boolean_Conversion:
+ca24ed473b9ce (Richard Smith 2012-09-13 22:00:12 +0000 5613) // Conversion from an integral or unscoped enumeration type to bool is
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5614) // classified as ICK_Boolean_Conversion, but it's also arguably an integral
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5615) // conversion, so we allow it in a converted constant expression.
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5616) //
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5617) // FIXME: Per core issue 1407, we should not allow this, but that breaks
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5618) // a lot of popular code. We should at least add a warning for this
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5619) // (non-conforming) extension.
+ca24ed473b9ce (Richard Smith 2012-09-13 22:00:12 +0000 5620) return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() &&
+ca24ed473b9ce (Richard Smith 2012-09-13 22:00:12 +0000 5621) SCS.getToType(2)->isBooleanType();
+ca24ed473b9ce (Richard Smith 2012-09-13 22:00:12 +0000 5622)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5623) case ICK_Pointer_Conversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5624) case ICK_Pointer_Member:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5625) // C++1z: null pointer conversions and null member pointer conversions are
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5626) // only permitted if the source type is std::nullptr_t.
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5627) return SCS.getFromType()->isNullPtrType();
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5628)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5629) case ICK_Floating_Promotion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5630) case ICK_Complex_Promotion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5631) case ICK_Floating_Conversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5632) case ICK_Complex_Conversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5633) case ICK_Floating_Integral:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5634) case ICK_Compatible_Conversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5635) case ICK_Derived_To_Base:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5636) case ICK_Vector_Conversion:
+feed5a7239d8e (Cullen Rhodes 2020-08-11 13:04:21 +0000 5637) case ICK_SVE_Vector_Conversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5638) case ICK_Vector_Splat:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5639) case ICK_Complex_Real:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5640) case ICK_Block_Pointer_Conversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5641) case ICK_TransparentUnionConversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5642) case ICK_Writeback_Conversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5643) case ICK_Zero_Event_Conversion:
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 5644) case ICK_C_Only_Conversion:
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 5645) case ICK_Incompatible_Pointer_Conversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5646) return false;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5647)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5648) case ICK_Lvalue_To_Rvalue:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5649) case ICK_Array_To_Pointer:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5650) case ICK_Function_To_Pointer:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5651) llvm_unreachable("found a first conversion kind in Second");
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5652)
+b4a2d36c3f74e (Aaron Puchert 2020-08-29 18:13:56 +0200 5653) case ICK_Function_Conversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5654) case ICK_Qualification:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5655) llvm_unreachable("found a third conversion kind in Second");
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5656)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5657) case ICK_Num_Conversion_Kinds:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5658) break;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5659) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5660)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5661) llvm_unreachable("unknown conversion kind");
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5662) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5663)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5664) /// CheckConvertedConstantExpression - Check that the expression From is a
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5665) /// converted constant expression of type T, perform the conversion and produce
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5666) /// the converted expression, per C++11 [expr.const]p3.
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5667) static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5668) QualType T, APValue &Value,
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5669) Sema::CCEKind CCE,
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5670) bool RequireInt,
+8ba442bc2136c (Hans Wennborg 2021-01-20 15:25:33 +0100 5671) NamedDecl *Dest) {
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5672) assert(S.getLangOpts().CPlusPlus11 &&
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5673) "converted constant expression outside C++11");
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5674)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5675) if (checkPlaceholderForOverload(S, From))
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5676) return ExprError();
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5677)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5678) // C++1z [expr.const]p3:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5679) // A converted constant expression of type T is an expression,
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5680) // implicitly converted to type T, where the converted
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5681) // expression is a constant expression and the implicit conversion
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5682) // sequence contains only [... list of conversions ...].
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5683) // C++1z [stmt.if]p2:
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5684) // If the if statement is of the form if constexpr, the value of the
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5685) // condition shall be a contextually converted constant expression of type
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5686) // bool.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5687) ImplicitConversionSequence ICS =
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 5688) CCE == Sema::CCEK_ConstexprIf || CCE == Sema::CCEK_ExplicitBool
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5689) ? TryContextuallyConvertToBool(S, From)
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5690) : TryCopyInitialization(S, From, T,
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5691) /*SuppressUserConversions=*/false,
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5692) /*InOverloadResolution=*/false,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 5693) /*AllowObjCWritebackConversion=*/false,
+4a00774e59c71 (Ismail Pazarbasi 2016-09-07 18:24:54 +0000 5694) /*AllowExplicit=*/false);
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 5695) StandardConversionSequence *SCS = nullptr;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5696) switch (ICS.getKind()) {
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5697) case ImplicitConversionSequence::StandardConversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5698) SCS = &ICS.Standard;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5699) break;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5700) case ImplicitConversionSequence::UserDefinedConversion:
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5701) if (T->isRecordType())
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5702) SCS = &ICS.UserDefined.Before;
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5703) else
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5704) SCS = &ICS.UserDefined.After;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5705) break;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5706) case ImplicitConversionSequence::AmbiguousConversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5707) case ImplicitConversionSequence::BadConversion:
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5708) if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5709) return S.Diag(From->getBeginLoc(),
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5710) diag::err_typecheck_converted_constant_expression)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5711) << From->getType() << From->getSourceRange() << T;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5712) return ExprError();
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5713)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5714) case ImplicitConversionSequence::EllipsisConversion:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5715) llvm_unreachable("ellipsis conversion in converted constant expression");
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5716) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5717)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5718) // Check that we would only use permitted conversions.
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5719) if (!CheckConvertedConstantConversions(S, *SCS)) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5720) return S.Diag(From->getBeginLoc(),
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5721) diag::err_typecheck_converted_constant_expression_disallowed)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5722) << From->getType() << From->getSourceRange() << T;
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5723) }
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5724) // [...] and where the reference binding (if any) binds directly.
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5725) if (SCS->ReferenceBinding && !SCS->DirectBinding) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5726) return S.Diag(From->getBeginLoc(),
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5727) diag::err_typecheck_converted_constant_expression_indirect)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5728) << From->getType() << From->getSourceRange() << T;
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5729) }
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5730)
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5731) // Usually we can simply apply the ImplicitConversionSequence we formed
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5732) // earlier, but that's not guaranteed to work when initializing an object of
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5733) // class type.
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5734) ExprResult Result;
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5735) if (T->isRecordType()) {
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5736) assert(CCE == Sema::CCEK_TemplateArg &&
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5737) "unexpected class type converted constant expr");
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5738) Result = S.PerformCopyInitialization(
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5739) InitializedEntity::InitializeTemplateParameter(
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5740) T, cast<NonTypeTemplateParmDecl>(Dest)),
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5741) SourceLocation(), From);
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5742) } else {
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5743) Result = S.PerformImplicitConversion(From, T, ICS, Sema::AA_Converting);
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5744) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5745) if (Result.isInvalid())
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5746) return Result;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5747)
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5748) // C++2a [intro.execution]p5:
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5749) // A full-expression is [...] a constant-expression [...]
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5750) Result =
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5751) S.ActOnFinishFullExpr(Result.get(), From->getExprLoc(),
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5752) /*DiscardedValue=*/false, /*IsConstexpr=*/true);
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5753) if (Result.isInvalid())
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5754) return Result;
+40c3d6e335900 (Richard Smith 2019-09-19 22:00:16 +0000 5755)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5756) // Check for a narrowing implicit conversion.
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5757) bool ReturnPreNarrowingValue = false;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5758) APValue PreNarrowingValue;
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 5759) QualType PreNarrowingType;
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5760) switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
+5614ca77153b2 (Richard Smith 2012-03-23 23:55:39 +0000 5761) PreNarrowingType)) {
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5762) case NK_Dependent_Narrowing:
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5763) // Implicit conversion to a narrower type, but the expression is
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5764) // value-dependent so we can't tell whether it's actually narrowing.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5765) case NK_Variable_Narrowing:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5766) // Implicit conversion to a narrower type, and the value is not a constant
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5767) // expression. We'll diagnose this in a moment.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5768) case NK_Not_Narrowing:
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5769) break;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5770)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5771) case NK_Constant_Narrowing:
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5772) if (CCE == Sema::CCEK_ArrayBound &&
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5773) PreNarrowingType->isIntegralOrEnumerationType() &&
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5774) PreNarrowingValue.isInt()) {
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5775) // Don't diagnose array bound narrowing here; we produce more precise
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5776) // errors by allowing the un-narrowed value through.
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5777) ReturnPreNarrowingValue = true;
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5778) break;
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5779) }
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5780) S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5781) << CCE << /*Constant*/ 1
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5782) << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << T;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5783) break;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5784)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5785) case NK_Type_Narrowing:
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5786) // FIXME: It would be better to diagnose that the expression is not a
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5787) // constant expression.
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5788) S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5789) << CCE << /*Constant*/ 0 << From->getType() << T;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5790) break;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5791) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5792)
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5793) if (Result.get()->isValueDependent()) {
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5794) Value = APValue();
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5795) return Result;
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5796) }
+52e624f3ecbe1 (Richard Smith 2016-12-21 21:42:57 +0000 5797)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5798) // Check the expression is a constant expression.
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 5799) SmallVector<PartialDiagnosticAt, 8> Notes;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5800) Expr::EvalResult Eval;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5801) Eval.Diag = &Notes;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5802)
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5803) ConstantExprKind Kind;
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5804) if (CCE == Sema::CCEK_TemplateArg && T->isRecordType())
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5805) Kind = ConstantExprKind::ClassTemplateArgument;
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5806) else if (CCE == Sema::CCEK_TemplateArg)
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5807) Kind = ConstantExprKind::NonClassTemplateArgument;
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5808) else
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5809) Kind = ConstantExprKind::Normal;
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5810)
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5811) if (!Result.get()->EvaluateAsConstantExpr(Eval, S.Context, Kind) ||
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5812) (RequireInt && !Eval.Val.isInt())) {
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5813) // The expression can't be folded, so we can't keep it at this position in
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5814) // the AST.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5815) Result = ExprError();
+911e142f034a3 (Richard Smith 2012-01-30 22:27:01 +0000 5816) } else {
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5817) Value = Eval.Val;
+911e142f034a3 (Richard Smith 2012-01-30 22:27:01 +0000 5818)
+911e142f034a3 (Richard Smith 2012-01-30 22:27:01 +0000 5819) if (Notes.empty()) {
+911e142f034a3 (Richard Smith 2012-01-30 22:27:01 +0000 5820) // It's a constant expression.
+8ba442bc2136c (Hans Wennborg 2021-01-20 15:25:33 +0100 5821) Expr *E = ConstantExpr::Create(S.Context, Result.get(), Value);
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5822) if (ReturnPreNarrowingValue)
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5823) Value = std::move(PreNarrowingValue);
+c1c1bed5d0828 (Richard Smith 2020-08-19 12:46:52 -0700 5824) return E;
+911e142f034a3 (Richard Smith 2012-01-30 22:27:01 +0000 5825) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5826) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5827)
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5828) // It's not a constant expression. Produce an appropriate diagnostic.
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5829) if (Notes.size() == 1 &&
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5830) Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr) {
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5831) S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5832) } else if (!Notes.empty() && Notes[0].second.getDiagID() ==
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5833) diag::note_constexpr_invalid_template_arg) {
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5834) Notes[0].second.setDiagID(diag::err_constexpr_invalid_template_arg);
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5835) for (unsigned I = 0; I < Notes.size(); ++I)
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5836) S.Diag(Notes[I].first, Notes[I].second);
+7b3515880c22c (Richard Smith 2020-10-24 22:08:24 -0700 5837) } else {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5838) S.Diag(From->getBeginLoc(), diag::err_expr_not_cce)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5839) << CCE << From->getSourceRange();
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5840) for (unsigned I = 0; I < Notes.size(); ++I)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5841) S.Diag(Notes[I].first, Notes[I].second);
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5842) }
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5843) return ExprError();
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5844) }
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5845)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5846) ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5847) APValue &Value, CCEKind CCE,
+8ba442bc2136c (Hans Wennborg 2021-01-20 15:25:33 +0100 5848) NamedDecl *Dest) {
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5849) return ::CheckConvertedConstantExpression(*this, From, T, Value, CCE, false,
+8ba442bc2136c (Hans Wennborg 2021-01-20 15:25:33 +0100 5850) Dest);
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5851) }
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5852)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5853) ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5854) llvm::APSInt &Value,
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5855) CCEKind CCE) {
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5856) assert(T->isIntegralOrEnumerationType() && "unexpected converted const type");
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5857)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5858) APValue V;
+ba4768c966581 (Richard Smith 2020-09-20 23:16:08 -0700 5859) auto R = ::CheckConvertedConstantExpression(*this, From, T, V, CCE, true,
+8ba442bc2136c (Hans Wennborg 2021-01-20 15:25:33 +0100 5860) /*Dest=*/nullptr);
+01bfa68fecaf5 (Richard Smith 2016-12-27 02:02:09 +0000 5861) if (!R.isInvalid() && !R.get()->isValueDependent())
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5862) Value = V.getInt();
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5863) return R;
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5864) }
+f8379a0fc3592 (Richard Smith 2012-01-18 23:55:52 +0000 5865)
+410cc893745ee (Richard Smith 2014-11-26 03:26:53 +0000 5866)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5867) /// dropPointerConversions - If the given standard conversion sequence
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5868) /// involves any pointer conversions, remove them. This may change
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5869) /// the result type of the conversion sequence.
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5870) static void dropPointerConversion(StandardConversionSequence &SCS) {
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5871) if (SCS.Second == ICK_Pointer_Conversion) {
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5872) SCS.Second = ICK_Identity;
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5873) SCS.Third = ICK_Identity;
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5874) SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5875) }
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5876) }
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5877)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5878) /// TryContextuallyConvertToObjCPointer - Attempt to contextually
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5879) /// convert the expression From to an Objective-C pointer type.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5880) static ImplicitConversionSequence
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5881) TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5882) // Do an implicit conversion to 'id'.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5883) QualType Ty = S.Context.getObjCIdType();
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5884) ImplicitConversionSequence ICS
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5885) = TryImplicitConversion(S, From, Ty,
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5886) // FIXME: Are these flags correct?
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5887) /*SuppressUserConversions=*/false,
+d28763cad06e6 (Richard Smith 2020-01-29 12:07:14 -0800 5888) AllowedExplicit::Conversions,
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5889) /*InOverloadResolution=*/false,
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5890) /*CStyle=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5891) /*AllowObjCWritebackConversion=*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 5892) /*AllowObjCConversionOnExplicit=*/true);
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5893)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5894) // Strip off any final conversions to 'id'.
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5895) switch (ICS.getKind()) {
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5896) case ImplicitConversionSequence::BadConversion:
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5897) case ImplicitConversionSequence::AmbiguousConversion:
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5898) case ImplicitConversionSequence::EllipsisConversion:
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5899) break;
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5900)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5901) case ImplicitConversionSequence::UserDefinedConversion:
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5902) dropPointerConversion(ICS.UserDefined.After);
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5903) break;
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5904)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5905) case ImplicitConversionSequence::StandardConversion:
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5906) dropPointerConversion(ICS.Standard);
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5907) break;
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5908) }
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5909)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5910) return ICS;
+cac49a8f8a11d (Fariborz Jahanian 2010-05-12 23:29:11 +0000 5911) }
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 5912)
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5913) /// PerformContextuallyConvertToObjCPointer - Perform a contextual
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5914) /// conversion of the expression From to an Objective-C pointer type.
+e15a370084f37 (Richard Smith 2016-10-06 23:12:58 +0000 5915) /// Returns a valid but null ExprResult if no conversion sequence exists.
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5916) ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) {
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 5917) if (checkPlaceholderForOverload(*this, From))
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 5918) return ExprError();
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 5919)
+8b07ec253d404 (John McCall 2010-05-15 11:32:37 +0000 5920) QualType Ty = Context.getObjCIdType();
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5921) ImplicitConversionSequence ICS =
+fec112d50e801 (John McCall 2011-09-09 06:11:02 +0000 5922) TryContextuallyConvertToObjCPointer(*this, From);
+cac49a8f8a11d (Fariborz Jahanian 2010-05-12 23:29:11 +0000 5923) if (!ICS.isBad())
+cac49a8f8a11d (Fariborz Jahanian 2010-05-12 23:29:11 +0000 5924) return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
+e15a370084f37 (Richard Smith 2016-10-06 23:12:58 +0000 5925) return ExprResult();
+cac49a8f8a11d (Fariborz Jahanian 2010-05-12 23:29:11 +0000 5926) }
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 5927)
+8dd3425077ba7 (Richard Smith 2012-02-04 07:07:42 +0000 5928) /// Determine whether the provided type is an integral type, or an enumeration
+8dd3425077ba7 (Richard Smith 2012-02-04 07:07:42 +0000 5929) /// type of a permitted flavor.
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 5930) bool Sema::ICEConvertDiagnoser::match(QualType T) {
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 5931) return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 5932) : T->isIntegralOrUnscopedEnumerationType();
+8dd3425077ba7 (Richard Smith 2012-02-04 07:07:42 +0000 5933) }
+8dd3425077ba7 (Richard Smith 2012-02-04 07:07:42 +0000 5934)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5935) static ExprResult
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5936) diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5937) Sema::ContextualImplicitConverter &Converter,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5938) QualType T, UnresolvedSetImpl &ViableConversions) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5939)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5940) if (Converter.Suppress)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5941) return ExprError();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5942)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5943) Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5944) for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5945) CXXConversionDecl *Conv =
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5946) cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5947) QualType ConvTy = Conv->getConversionType().getNonReferenceType();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5948) Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5949) }
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 5950) return From;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5951) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5952)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5953) static bool
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5954) diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5955) Sema::ContextualImplicitConverter &Converter,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5956) QualType T, bool HadMultipleCandidates,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5957) UnresolvedSetImpl &ExplicitConversions) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5958) if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5959) DeclAccessPair Found = ExplicitConversions[0];
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5960) CXXConversionDecl *Conversion =
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5961) cast<CXXConversionDecl>(Found->getUnderlyingDecl());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5962)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5963) // The user probably meant to invoke the given explicit
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5964) // conversion; use it.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5965) QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5966) std::string TypeStr;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5967) ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5968)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5969) Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 5970) << FixItHint::CreateInsertion(From->getBeginLoc(),
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5971) "static_cast<" + TypeStr + ">(")
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5972) << FixItHint::CreateInsertion(
+1c301dcbc4e59 (Stephen Kelly 2018-08-09 21:09:38 +0000 5973) SemaRef.getLocForEndOfToken(From->getEndLoc()), ")");
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5974) Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5975)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5976) // If we aren't in a SFINAE context, build a call to the
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5977) // explicit conversion function.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5978) if (SemaRef.isSFINAEContext())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5979) return true;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5980)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 5981) SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5982) ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5983) HadMultipleCandidates);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5984) if (Result.isInvalid())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5985) return true;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5986) // Record usage of conversion in an implicit cast.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5987) From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 5988) CK_UserDefinedConversion, Result.get(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 5989) nullptr, Result.get()->getValueKind(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 5990) SemaRef.CurFPFeatureOverrides());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5991) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5992) return false;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5993) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5994)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5995) static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5996) Sema::ContextualImplicitConverter &Converter,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5997) QualType T, bool HadMultipleCandidates,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5998) DeclAccessPair &Found) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 5999) CXXConversionDecl *Conversion =
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6000) cast<CXXConversionDecl>(Found->getUnderlyingDecl());
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 6001) SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6002)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6003) QualType ToType = Conversion->getConversionType().getNonReferenceType();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6004) if (!Converter.SuppressConversion) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6005) if (SemaRef.isSFINAEContext())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6006) return true;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6007)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6008) Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6009) << From->getSourceRange();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6010) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6011)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6012) ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6013) HadMultipleCandidates);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6014) if (Result.isInvalid())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6015) return true;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6016) // Record usage of conversion in an implicit cast.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6017) From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 6018) CK_UserDefinedConversion, Result.get(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 6019) nullptr, Result.get()->getValueKind(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 6020) SemaRef.CurFPFeatureOverrides());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6021) return false;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6022) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6023)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6024) static ExprResult finishContextualImplicitConversion(
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6025) Sema &SemaRef, SourceLocation Loc, Expr *From,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6026) Sema::ContextualImplicitConverter &Converter) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6027) if (!Converter.match(From->getType()) && !Converter.Suppress)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6028) Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6029) << From->getSourceRange();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6030)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6031) return SemaRef.DefaultLvalueConversion(From);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6032) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6033)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6034) static void
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6035) collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6036) UnresolvedSetImpl &ViableConversions,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6037) OverloadCandidateSet &CandidateSet) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6038) for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6039) DeclAccessPair FoundDecl = ViableConversions[I];
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6040) NamedDecl *D = FoundDecl.getDecl();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6041) CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6042) if (isa<UsingShadowDecl>(D))
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6043) D = cast<UsingShadowDecl>(D)->getTargetDecl();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6044)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6045) CXXConversionDecl *Conv;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6046) FunctionTemplateDecl *ConvTemplate;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6047) if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6048) Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6049) else
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6050) Conv = cast<CXXConversionDecl>(D);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6051)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6052) if (ConvTemplate)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6053) SemaRef.AddTemplateConversionCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6054) ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6055) /*AllowObjCConversionOnExplicit=*/false, /*AllowExplicit*/ true);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6056) else
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6057) SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 6058) ToType, CandidateSet,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6059) /*AllowObjCConversionOnExplicit=*/false,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6060) /*AllowExplicit*/ true);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6061) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6062) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6063)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 6064) /// Attempt to convert the given expression to a type which is accepted
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6065) /// by the given converter.
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6066) ///
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6067) /// This routine will attempt to convert an expression of class type to a
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6068) /// type accepted by the specified converter. In C++11 and before, the class
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6069) /// must have a single non-explicit conversion function converting to a matching
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6070) /// type. In C++1y, there can be multiple such conversion functions, but only
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6071) /// one target type.
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6072) ///
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6073) /// \param Loc The source location of the construct that requires the
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6074) /// conversion.
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6075) ///
+18348b6218e4c (James Dennett 2012-06-22 08:52:37 +0000 6076) /// \param From The expression we're converting from.
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6077) ///
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6078) /// \param Converter Used to control and diagnose the conversion process.
+8dd3425077ba7 (Richard Smith 2012-02-04 07:07:42 +0000 6079) ///
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6080) /// \returns The expression, converted to an integral or enumeration type if
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6081) /// successful.
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6082) ExprResult Sema::PerformContextualImplicitConversion(
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6083) SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6084) // We can't perform any more checking for type-dependent expressions.
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6085) if (From->isTypeDependent())
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 6086) return From;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6087)
+1da70394f68a5 (Eli Friedman 2012-01-26 00:26:18 +0000 6088) // Process placeholders immediately.
+1da70394f68a5 (Eli Friedman 2012-01-26 00:26:18 +0000 6089) if (From->hasPlaceholderType()) {
+1da70394f68a5 (Eli Friedman 2012-01-26 00:26:18 +0000 6090) ExprResult result = CheckPlaceholderExpr(From);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6091) if (result.isInvalid())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6092) return result;
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 6093) From = result.get();
+1da70394f68a5 (Eli Friedman 2012-01-26 00:26:18 +0000 6094) }
+1da70394f68a5 (Eli Friedman 2012-01-26 00:26:18 +0000 6095)
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6096) // If the expression already has a matching type, we're golden.
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6097) QualType T = From->getType();
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6098) if (Converter.match(T))
+1da70394f68a5 (Eli Friedman 2012-01-26 00:26:18 +0000 6099) return DefaultLvalueConversion(From);
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6100)
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6101) // FIXME: Check for missing '()' if T is a function type?
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6102)
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6103) // We can only perform contextual implicit conversions on objects of class
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6104) // type.
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6105) const RecordType *RecordTy = T->getAs<RecordType>();
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 6106) if (!RecordTy || !getLangOpts().CPlusPlus) {
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6107) if (!Converter.Suppress)
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6108) Converter.diagnoseNoMatch(*this, Loc, T) << From->getSourceRange();
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 6109) return From;
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6110) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6111)
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6112) // We must have a complete class type.
+a6c5abb754044 (Douglas Gregor 2012-05-04 16:48:41 +0000 6113) struct TypeDiagnoserPartialDiag : TypeDiagnoser {
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6114) ContextualImplicitConverter &Converter;
+e2b3744890f63 (Douglas Gregor 2012-05-04 22:38:52 +0000 6115) Expr *From;
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6116)
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6117) TypeDiagnoserPartialDiag(ContextualImplicitConverter &Converter, Expr *From)
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 6118) : Converter(Converter), From(From) {}
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6119)
+e14c0f8e733e0 (Craig Topper 2014-03-12 04:55:44 +0000 6120) void diagnose(Sema &S, SourceLocation Loc, QualType T) override {
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6121) Converter.diagnoseIncomplete(S, Loc, T) << From->getSourceRange();
+7bfb2d026ec99 (Douglas Gregor 2012-05-04 16:32:21 +0000 6122) }
+ccc11811052db (Richard Smith 2013-05-21 19:05:48 +0000 6123) } IncompleteDiagnoser(Converter, From);
+7bfb2d026ec99 (Douglas Gregor 2012-05-04 16:32:21 +0000 6124)
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 6125) if (Converter.Suppress ? !isCompleteType(Loc, T)
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 6126) : RequireCompleteType(Loc, T, IncompleteDiagnoser))
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 6127) return From;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6128)
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6129) // Look for a conversion to an integral or enumeration type.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6130) UnresolvedSet<4>
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6131) ViableConversions; // These are *potentially* viable in C++1y.
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6132) UnresolvedSet<4> ExplicitConversions;
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 6133) const auto &Conversions =
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6134) cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6135)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6136) bool HadMultipleCandidates =
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 6137) (std::distance(Conversions.begin(), Conversions.end()) > 1);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6138)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6139) // To check that there is only one target type, in C++1y:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6140) QualType ToType;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6141) bool HasUniqueTargetType = true;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6142)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6143) // Collect explicit or viable (potentially in C++1y) conversions.
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 6144) for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6145) NamedDecl *D = (*I)->getUnderlyingDecl();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6146) CXXConversionDecl *Conversion;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6147) FunctionTemplateDecl *ConvTemplate = dyn_cast<FunctionTemplateDecl>(D);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6148) if (ConvTemplate) {
+dd69ef38dba72 (Aaron Ballman 2014-08-19 15:55:55 +0000 6149) if (getLangOpts().CPlusPlus14)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6150) Conversion = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6151) else
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6152) continue; // C++11 does not consider conversion operator templates(?).
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6153) } else
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6154) Conversion = cast<CXXConversionDecl>(D);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6155)
+dd69ef38dba72 (Aaron Ballman 2014-08-19 15:55:55 +0000 6156) assert((!ConvTemplate || getLangOpts().CPlusPlus14) &&
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6157) "Conversion operator templates are considered potentially "
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6158) "viable in C++1y");
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 6159)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6160) QualType CurToType = Conversion->getConversionType().getNonReferenceType();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6161) if (Converter.match(CurToType) || ConvTemplate) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6162)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6163) if (Conversion->isExplicit()) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6164) // FIXME: For C++1y, do we need this restriction?
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6165) // cf. diagnoseNoViableConversion()
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6166) if (!ConvTemplate)
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6167) ExplicitConversions.addDecl(I.getDecl(), I.getAccess());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6168) } else {
+dd69ef38dba72 (Aaron Ballman 2014-08-19 15:55:55 +0000 6169) if (!ConvTemplate && getLangOpts().CPlusPlus14) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6170) if (ToType.isNull())
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6171) ToType = CurToType.getUnqualifiedType();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6172) else if (HasUniqueTargetType &&
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6173) (CurToType.getUnqualifiedType() != ToType))
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6174) HasUniqueTargetType = false;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6175) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6176) ViableConversions.addDecl(I.getDecl(), I.getAccess());
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6177) }
+8dd3425077ba7 (Richard Smith 2012-02-04 07:07:42 +0000 6178) }
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6179) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6180)
+dd69ef38dba72 (Aaron Ballman 2014-08-19 15:55:55 +0000 6181) if (getLangOpts().CPlusPlus14) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6182) // C++1y [conv]p6:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6183) // ... An expression e of class type E appearing in such a context
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6184) // is said to be contextually implicitly converted to a specified
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6185) // type T and is well-formed if and only if e can be implicitly
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6186) // converted to a type T that is determined as follows: E is searched
+67170bd71ace5 (Larisse Voufo 2013-06-10 08:25:58 +0000 6187) // for conversion functions whose return type is cv T or reference to
+67170bd71ace5 (Larisse Voufo 2013-06-10 08:25:58 +0000 6188) // cv T such that T is allowed by the context. There shall be
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6189) // exactly one such T.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6190)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6191) // If no unique T is found:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6192) if (ToType.isNull()) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6193) if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6194) HadMultipleCandidates,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6195) ExplicitConversions))
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6196) return ExprError();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6197) return finishContextualImplicitConversion(*this, Loc, From, Converter);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6198) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6199)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6200) // If more than one unique Ts are found:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6201) if (!HasUniqueTargetType)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6202) return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6203) ViableConversions);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6204)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6205) // If one unique T is found:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6206) // First, build a candidate set from the previously recorded
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6207) // potentially viable conversions.
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6208) OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Normal);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6209) collectViableConversionCandidates(*this, From, ToType, ViableConversions,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6210) CandidateSet);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6211)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6212) // Then, perform overload resolution over the candidate set.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6213) OverloadCandidateSet::iterator Best;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6214) switch (CandidateSet.BestViableFunction(*this, Loc, Best)) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6215) case OR_Success: {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6216) // Apply this conversion.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6217) DeclAccessPair Found =
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6218) DeclAccessPair::make(Best->Function, Best->FoundDecl.getAccess());
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6219) if (recordConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6220) HadMultipleCandidates, Found))
+668443efb1db5 (Douglas Gregor 2011-01-20 00:18:04 +0000 6221) return ExprError();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6222) break;
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6223) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6224) case OR_Ambiguous:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6225) return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6226) ViableConversions);
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6227) case OR_No_Viable_Function:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6228) if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6229) HadMultipleCandidates,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6230) ExplicitConversions))
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6231) return ExprError();
+f3b3ccda590c1 (Adrian Prantl 2017-12-19 22:06:11 +0000 6232) LLVM_FALLTHROUGH;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6233) case OR_Deleted:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6234) // We'll complain below about a non-integral condition type.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6235) break;
+4799d03ce8411 (Douglas Gregor 2010-06-30 00:20:43 +0000 6236) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6237) } else {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6238) switch (ViableConversions.size()) {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6239) case 0: {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6240) if (diagnoseNoViableConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6241) HadMultipleCandidates,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6242) ExplicitConversions))
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6243) return ExprError();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6244)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6245) // We'll complain below about a non-integral condition type.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6246) break;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6247) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6248) case 1: {
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6249) // Apply this conversion.
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6250) DeclAccessPair Found = ViableConversions[0];
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6251) if (recordConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6252) HadMultipleCandidates, Found))
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6253) return ExprError();
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6254) break;
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6255) }
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6256) default:
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6257) return diagnoseAmbiguousConversion(*this, Loc, From, Converter, T,
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6258) ViableConversions);
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6259) }
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6260) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6261)
+236bec24ec195 (Larisse Voufo 2013-06-10 06:50:24 +0000 6262) return finishContextualImplicitConversion(*this, Loc, From, Converter);
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6263) }
+f4ea725d38cc5 (Douglas Gregor 2010-06-29 23:17:37 +0000 6264)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6265) /// IsAcceptableNonMemberOperatorCandidate - Determine whether Fn is
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6266) /// an acceptable non-member overloaded operator for a call whose
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6267) /// arguments have types T1 (and, if non-empty, T2). This routine
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6268) /// implements the check in C++ [over.match.oper]p3b2 concerning
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6269) /// enumeration types.
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6270) static bool IsAcceptableNonMemberOperatorCandidate(ASTContext &Context,
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6271) FunctionDecl *Fn,
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6272) ArrayRef<Expr *> Args) {
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6273) QualType T1 = Args[0]->getType();
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6274) QualType T2 = Args.size() > 1 ? Args[1]->getType() : QualType();
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6275)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6276) if (T1->isDependentType() || (!T2.isNull() && T2->isDependentType()))
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6277) return true;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6278)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6279) if (T1->isRecordType() || (!T2.isNull() && T2->isRecordType()))
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6280) return true;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6281)
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 6282) const auto *Proto = Fn->getType()->castAs<FunctionProtoType>();
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6283) if (Proto->getNumParams() < 1)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6284) return false;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6285)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6286) if (T1->isEnumeralType()) {
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6287) QualType ArgType = Proto->getParamType(0).getNonReferenceType();
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6288) if (Context.hasSameUnqualifiedType(T1, ArgType))
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6289) return true;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6290) }
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6291)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6292) if (Proto->getNumParams() < 2)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6293) return false;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6294)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6295) if (!T2.isNull() && T2->isEnumeralType()) {
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6296) QualType ArgType = Proto->getParamType(1).getNonReferenceType();
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6297) if (Context.hasSameUnqualifiedType(T2, ArgType))
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6298) return true;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6299) }
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6300)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6301) return false;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6302) }
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6303)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6304) /// AddOverloadCandidate - Adds the given function to the set of
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 6305) /// candidate functions, using the given function call arguments. If
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 6306) /// @p SuppressUserConversions, then don't allow user-defined
+2fe9883a961df (Douglas Gregor 2008-11-03 19:09:14 +0000 6307) /// conversions via constructors or conversion operators.
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 6308) ///
+2a4d13c5cf5e9 (James Dennett 2012-06-15 07:13:21 +0000 6309) /// \param PartialOverloading true if we are performing "partial" overloading
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 6310) /// based on an incomplete set of function arguments. This feature is used by
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 6311) /// code completion.
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6312) void Sema::AddOverloadCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6313) FunctionDecl *Function, DeclAccessPair FoundDecl, ArrayRef<Expr *> Args,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6314) OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6315) bool PartialOverloading, bool AllowExplicit, bool AllowExplicitConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6316) ADLCallKind IsADLCandidate, ConversionSequenceList EarlyConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6317) OverloadCandidateParamOrder PO) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6318) const FunctionProtoType *Proto
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 6319) = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>());
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6320) assert(Proto && "Functions without a prototype cannot be overloaded");
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 6321) assert(!Function->getDescribedFunctionTemplate() &&
+7c2888689dfdd (NAKAMURA Takumi 2011-01-27 07:09:49 +0000 6322) "Use AddTemplateOverloadCandidate for function templates");
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 6323)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6324) if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) {
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6325) if (!isa<CXXConstructorDecl>(Method)) {
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6326) // If we get here, it's because we're calling a member function
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6327) // that is named without a member access expression (e.g.,
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6328) // "this->f") that was either written explicitly or created
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6329) // implicitly. This can happen with a qualified call to a member
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 6330) // function, e.g., X::f(). We use an empty type for the implied
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 6331) // object argument (C++ [over.call.func]p3), and the acting context
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 6332) // is irrelevant.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6333) AddMethodCandidate(Method, FoundDecl, Method->getParent(), QualType(),
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6334) Expr::Classification::makeSimpleLValue(), Args,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6335) CandidateSet, SuppressUserConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6336) PartialOverloading, EarlyConversions, PO);
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6337) return;
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6338) }
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6339) // We treat a constructor like a non-member function, since its object
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6340) // argument doesn't participate in overload resolution.
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6341) }
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6342)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6343) if (!CandidateSet.isNewCandidate(Function, PO))
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6344) return;
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 6345)
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6346) // C++11 [class.copy]p11: [DR1402]
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6347) // A defaulted move constructor that is defined as deleted is ignored by
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6348) // overload resolution.
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6349) CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function);
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6350) if (Constructor && Constructor->isDefaulted() && Constructor->isDeleted() &&
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6351) Constructor->isMoveConstructor())
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6352) return;
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6353)
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 6354) // Overload resolution is always an unevaluated context.
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 6355) EnterExpressionEvaluationContext Unevaluated(
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 6356) *this, Sema::ExpressionEvaluationContext::Unevaluated);
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 6357)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6358) // C++ [over.match.oper]p3:
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6359) // if no operand has a class type, only those non-member functions in the
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6360) // lookup set that have a first parameter of type T1 or "reference to
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6361) // (possibly cv-qualified) T1", when T1 is an enumeration type, or (if there
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6362) // is a right operand) a second parameter of type T2 or "reference to
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6363) // (possibly cv-qualified) T2", when T2 is an enumeration type, are
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6364) // candidate functions.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6365) if (CandidateSet.getKind() == OverloadCandidateSet::CSK_Operator &&
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6366) !IsAcceptableNonMemberOperatorCandidate(Context, Function, Args))
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6367) return;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6368)
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6369) // Add this candidate
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6370) OverloadCandidate &Candidate =
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6371) CandidateSet.addCandidate(Args.size(), EarlyConversions);
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6372) Candidate.FoundDecl = FoundDecl;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6373) Candidate.Function = Function;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6374) Candidate.Viable = true;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6375) Candidate.RewriteKind =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6376) CandidateSet.getRewriteInfo().getRewriteKind(Function, PO);
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6377) Candidate.IsSurrogate = false;
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 6378) Candidate.IsADLCandidate = IsADLCandidate;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6379) Candidate.IgnoreObjectArgument = false;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6380) Candidate.ExplicitCallArguments = Args.size();
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6381)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6382) // Explicit functions are not actually candidates at all if we're not
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6383) // allowing them in this context, but keep them around so we can point
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6384) // to them in diagnostics.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6385) if (!AllowExplicit && ExplicitSpecifier::getFromDecl(Function).isExplicit()) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6386) Candidate.Viable = false;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6387) Candidate.FailureKind = ovl_fail_explicit;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6388) return;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6389) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 6390)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 6391) if (Function->isMultiVersion() && Function->hasAttr<TargetAttr>() &&
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 6392) !Function->getAttr<TargetAttr>()->isDefaultVersion()) {
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 6393) Candidate.Viable = false;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 6394) Candidate.FailureKind = ovl_non_default_multiversion_function;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 6395) return;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 6396) }
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 6397)
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6398) if (Constructor) {
+ffe14e37121c5 (Douglas Gregor 2009-11-14 01:20:54 +0000 6399) // C++ [class.copy]p3:
+ffe14e37121c5 (Douglas Gregor 2009-11-14 01:20:54 +0000 6400) // A member function template is never instantiated to perform the copy
+ffe14e37121c5 (Douglas Gregor 2009-11-14 01:20:54 +0000 6401) // of a class object to an object of its class type.
+ffe14e37121c5 (Douglas Gregor 2009-11-14 01:20:54 +0000 6402) QualType ClassType = Context.getTypeDeclType(Constructor->getParent());
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 6403) if (Args.size() == 1 && Constructor->isSpecializationCopyingObject() &&
+901e717f9295e (Douglas Gregor 2010-02-21 18:30:38 +0000 6404) (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) ||
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 6405) IsDerivedFrom(Args[0]->getBeginLoc(), Args[0]->getType(),
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 6406) ClassType))) {
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6407) Candidate.Viable = false;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6408) Candidate.FailureKind = ovl_fail_illegal_constructor;
+ffe14e37121c5 (Douglas Gregor 2009-11-14 01:20:54 +0000 6409) return;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 6410) }
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6411)
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6412) // C++ [over.match.funcs]p8: (proposed DR resolution)
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6413) // A constructor inherited from class type C that has a first parameter
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6414) // of type "reference to P" (including such a constructor instantiated
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6415) // from a template) is excluded from the set of candidate functions when
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6416) // constructing an object of type cv D if the argument list has exactly
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6417) // one argument and D is reference-related to P and P is reference-related
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6418) // to C.
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6419) auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl.getDecl());
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6420) if (Shadow && Args.size() == 1 && Constructor->getNumParams() >= 1 &&
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6421) Constructor->getParamDecl(0)->getType()->isReferenceType()) {
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6422) QualType P = Constructor->getParamDecl(0)->getType()->getPointeeType();
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6423) QualType C = Context.getRecordType(Constructor->getParent());
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6424) QualType D = Context.getRecordType(Shadow->getParent());
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6425) SourceLocation Loc = Args.front()->getExprLoc();
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6426) if ((Context.hasSameUnqualifiedType(P, C) || IsDerivedFrom(Loc, P, C)) &&
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6427) (Context.hasSameUnqualifiedType(D, P) || IsDerivedFrom(Loc, D, P))) {
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6428) Candidate.Viable = false;
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6429) Candidate.FailureKind = ovl_fail_inhctor_slice;
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6430) return;
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6431) }
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 6432) }
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6433)
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6434) // Check that the constructor is capable of constructing an object in the
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6435) // destination address space.
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6436) if (!Qualifiers::isAddressSpaceSupersetOf(
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6437) Constructor->getMethodQualifiers().getAddressSpace(),
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6438) CandidateSet.getDestAS())) {
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6439) Candidate.Viable = false;
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6440) Candidate.FailureKind = ovl_fail_object_addrspace_mismatch;
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 6441) }
+ffe14e37121c5 (Douglas Gregor 2009-11-14 01:20:54 +0000 6442) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6443)
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 6444) unsigned NumParams = Proto->getNumParams();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6445)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6446) // (C++ 13.3.2p2): A candidate function having fewer than m
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6447) // parameters is viable only if it has an ellipsis in its parameter
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6448) // list (8.3.5).
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 6449) if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
+2a920014d3b33 (Douglas Gregor 2009-09-23 14:56:09 +0000 6450) !Proto->isVariadic()) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6451) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 6452) Candidate.FailureKind = ovl_fail_too_many_arguments;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6453) return;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6454) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6455)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6456) // (C++ 13.3.2p2): A candidate function having more than m parameters
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6457) // is viable only if the (m+1)st parameter has a default argument
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6458) // (8.3.6). For the purposes of overload resolution, the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6459) // parameter list is truncated on the right, so that there are
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6460) // exactly m parameters.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6461) unsigned MinRequiredArgs = Function->getMinRequiredArguments();
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 6462) if (Args.size() < MinRequiredArgs && !PartialOverloading) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6463) // Not enough arguments.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6464) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 6465) Candidate.FailureKind = ovl_fail_too_few_arguments;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6466) return;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6467) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6468)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6469) // (CUDA B.1): Check for invalid calls between targets.
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 6470) if (getLangOpts().CUDA)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6471) if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 6472) // Skip the check for callers that are implicit members, because in this
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 6473) // case we may not yet know what the member's target is; the target is
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 6474) // inferred for the member automatically, based on the bases and fields of
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 6475) // the class.
+b008003aa3f0d (Justin Lebar 2016-08-10 01:09:11 +0000 6476) if (!Caller->isImplicit() && !IsAllowedCUDACall(Caller, Function)) {
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6477) Candidate.Viable = false;
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6478) Candidate.FailureKind = ovl_fail_bad_target;
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6479) return;
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6480) }
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 6481)
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 6482) if (Function->getTrailingRequiresClause()) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6483) ConstraintSatisfaction Satisfaction;
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 6484) if (CheckFunctionConstraints(Function, Satisfaction) ||
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6485) !Satisfaction.IsSatisfied) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6486) Candidate.Viable = false;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6487) Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6488) return;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6489) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6490) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6491)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6492) // Determine the implicit conversion sequences for each of the
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6493) // arguments.
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 6494) for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6495) unsigned ConvIdx =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6496) PO == OverloadCandidateParamOrder::Reversed ? 1 - ArgIdx : ArgIdx;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6497) if (Candidate.Conversions[ConvIdx].isInitialized()) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6498) // We already formed a conversion sequence for this parameter during
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6499) // template argument deduction.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6500) } else if (ArgIdx < NumParams) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6501) // (C++ 13.3.2p3): for F to be a viable function, there shall
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6502) // exist for each argument an implicit conversion sequence
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6503) // (13.3.3.1) that converts that argument to the corresponding
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6504) // parameter of F.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 6505) QualType ParamType = Proto->getParamType(ArgIdx);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6506) Candidate.Conversions[ConvIdx] = TryCopyInitialization(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6507) *this, Args[ArgIdx], ParamType, SuppressUserConversions,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6508) /*InOverloadResolution=*/true,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6509) /*AllowObjCWritebackConversion=*/
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 6510) getLangOpts().ObjCAutoRefCount, AllowExplicitConversions);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6511) if (Candidate.Conversions[ConvIdx].isBad()) {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 6512) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 6513) Candidate.FailureKind = ovl_fail_bad_conversion;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6514) return;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6515) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6516) } else {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6517) // (C++ 13.3.2p2): For the purposes of overload resolution, any
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6518) // argument for which there is no corresponding parameter is
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6519) // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6520) Candidate.Conversions[ConvIdx].setEllipsis();
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6521) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6522) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6523)
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6524) if (EnableIfAttr *FailedAttr =
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6525) CheckEnableIf(Function, CandidateSet.getLocation(), Args)) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6526) Candidate.Viable = false;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6527) Candidate.FailureKind = ovl_fail_enable_if;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6528) Candidate.DeductionFailure.Data = FailedAttr;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6529) return;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6530) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6531) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6532)
+d2a3cd7261503 (Manman Ren 2016-04-07 19:30:20 +0000 6533) ObjCMethodDecl *
+d2a3cd7261503 (Manman Ren 2016-04-07 19:30:20 +0000 6534) Sema::SelectBestMethod(Selector Sel, MultiExprArg Args, bool IsInstance,
+d2a3cd7261503 (Manman Ren 2016-04-07 19:30:20 +0000 6535) SmallVectorImpl<ObjCMethodDecl *> &Methods) {
+d2a3cd7261503 (Manman Ren 2016-04-07 19:30:20 +0000 6536) if (Methods.size() <= 1)
+0ded42451d8d4 (Fariborz Jahanian 2014-08-13 21:24:14 +0000 6537) return nullptr;
+d2a3cd7261503 (Manman Ren 2016-04-07 19:30:20 +0000 6538)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6539) for (unsigned b = 0, e = Methods.size(); b < e; b++) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6540) bool Match = true;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6541) ObjCMethodDecl *Method = Methods[b];
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6542) unsigned NumNamedArgs = Sel.getNumArgs();
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6543) // Method might have more arguments than selector indicates. This is due
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6544) // to addition of c-style arguments in method.
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6545) if (Method->param_size() > NumNamedArgs)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6546) NumNamedArgs = Method->param_size();
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6547) if (Args.size() < NumNamedArgs)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6548) continue;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 6549)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6550) for (unsigned i = 0; i < NumNamedArgs; i++) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6551) // We can't do any type-checking on a type-dependent argument.
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6552) if (Args[i]->isTypeDependent()) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6553) Match = false;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6554) break;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6555) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 6556)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6557) ParmVarDecl *param = Method->parameters()[i];
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6558) Expr *argExpr = Args[i];
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6559) assert(argExpr && "SelectBestMethod(): missing expression");
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 6560)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6561) // Strip the unbridged-cast placeholder expression off unless it's
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6562) // a consumed argument.
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6563) if (argExpr->hasPlaceholderType(BuiltinType::ARCUnbridgedCast) &&
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6564) !param->hasAttr<CFConsumedAttr>())
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6565) argExpr = stripARCUnbridgedCast(argExpr);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 6566)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6567) // If the parameter is __unknown_anytype, move on to the next method.
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6568) if (param->getType() == Context.UnknownAnyTy) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6569) Match = false;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6570) break;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6571) }
+4546181e12c89 (George Burgess IV 2015-10-11 20:13:20 +0000 6572)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6573) ImplicitConversionSequence ConversionState
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6574) = TryCopyInitialization(*this, argExpr, param->getType(),
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6575) /*SuppressUserConversions*/false,
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6576) /*InOverloadResolution=*/true,
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6577) /*AllowObjCWritebackConversion=*/
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6578) getLangOpts().ObjCAutoRefCount,
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6579) /*AllowExplicit*/false);
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6580) // This function looks for a reasonably-exact match, so we consider
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6581) // incompatible pointer conversions to be a failure here.
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6582) if (ConversionState.isBad() ||
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6583) (ConversionState.isStandard() &&
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6584) ConversionState.Standard.Second ==
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6585) ICK_Incompatible_Pointer_Conversion)) {
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6586) Match = false;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6587) break;
+2099b54102e7d (George Burgess IV 2016-09-02 22:59:57 +0000 6588) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6589) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6590) // Promote additional arguments to variadic methods.
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6591) if (Match && Method->isVariadic()) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6592) for (unsigned i = NumNamedArgs, e = Args.size(); i < e; ++i) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6593) if (Args[i]->isTypeDependent()) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6594) Match = false;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6595) break;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6596) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6597) ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6598) nullptr);
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6599) if (Arg.isInvalid()) {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6600) Match = false;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6601) break;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6602) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6603) }
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6604) } else {
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6605) // Check for extra arguments to non-variadic methods.
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6606) if (Args.size() != NumNamedArgs)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6607) Match = false;
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6608) else if (Match && NumNamedArgs == 0 && Methods.size() > 1) {
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6609) // Special case when selectors have no argument. In this case, select
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6610) // one with the most general result type of 'id'.
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6611) for (unsigned b = 0, e = Methods.size(); b < e; b++) {
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6612) QualType ReturnT = Methods[b]->getReturnType();
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6613) if (ReturnT->isObjCIdType())
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6614) return Methods[b];
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6615) }
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6616) }
+180d76b4089e7 (Fariborz Jahanian 2014-08-27 16:38:47 +0000 6617) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6618)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6619) if (Match)
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6620) return Method;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6621) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6622) return nullptr;
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6623) }
+30ae8d44139ba (Fariborz Jahanian 2014-08-13 21:07:35 +0000 6624)
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6625) static bool convertArgsForAvailabilityChecks(
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6626) Sema &S, FunctionDecl *Function, Expr *ThisArg, SourceLocation CallLoc,
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6627) ArrayRef<Expr *> Args, Sema::SFINAETrap &Trap, bool MissingImplicitThis,
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6628) Expr *&ConvertedThis, SmallVectorImpl<Expr *> &ConvertedArgs) {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6629) if (ThisArg) {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6630) CXXMethodDecl *Method = cast<CXXMethodDecl>(Function);
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6631) assert(!isa<CXXConstructorDecl>(Method) &&
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6632) "Shouldn't have `this` for ctors!");
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6633) assert(!Method->isStatic() && "Shouldn't have `this` for static methods!");
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6634) ExprResult R = S.PerformObjectArgumentInitialization(
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6635) ThisArg, /*Qualifier=*/nullptr, Method, Method);
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6636) if (R.isInvalid())
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6637) return false;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6638) ConvertedThis = R.get();
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6639) } else {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6640) if (auto *MD = dyn_cast<CXXMethodDecl>(Function)) {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6641) (void)MD;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6642) assert((MissingImplicitThis || MD->isStatic() ||
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6643) isa<CXXConstructorDecl>(MD)) &&
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6644) "Expected `this` for non-ctor instance methods");
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6645) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6646) ConvertedThis = nullptr;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6647) }
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6648)
+458b3f3a114d5 (George Burgess IV 2016-08-12 04:19:35 +0000 6649) // Ignore any variadic arguments. Converting them is pointless, since the
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6650) // user can't refer to them in the function condition.
+53b938da5a39c (George Burgess IV 2016-08-12 04:12:31 +0000 6651) unsigned ArgSizeNoVarargs = std::min(Function->param_size(), Args.size());
+53b938da5a39c (George Burgess IV 2016-08-12 04:12:31 +0000 6652)
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6653) // Convert the arguments.
+53b938da5a39c (George Burgess IV 2016-08-12 04:12:31 +0000 6654) for (unsigned I = 0; I != ArgSizeNoVarargs; ++I) {
+e96abf79599d5 (George Burgess IV 2016-02-24 22:31:14 +0000 6655) ExprResult R;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6656) R = S.PerformCopyInitialization(InitializedEntity::InitializeParameter(
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6657) S.Context, Function->getParamDecl(I)),
+e96abf79599d5 (George Burgess IV 2016-02-24 22:31:14 +0000 6658) SourceLocation(), Args[I]);
+e96abf79599d5 (George Burgess IV 2016-02-24 22:31:14 +0000 6659)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6660) if (R.isInvalid())
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6661) return false;
+e96abf79599d5 (George Burgess IV 2016-02-24 22:31:14 +0000 6662)
+e96abf79599d5 (George Burgess IV 2016-02-24 22:31:14 +0000 6663) ConvertedArgs.push_back(R.get());
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6664) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6665)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6666) if (Trap.hasErrorOccurred())
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6667) return false;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6668)
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6669) // Push default arguments if needed.
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6670) if (!Function->isVariadic() && Args.size() < Function->getNumParams()) {
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6671) for (unsigned i = Args.size(), e = Function->getNumParams(); i != e; ++i) {
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6672) ParmVarDecl *P = Function->getParamDecl(i);
+b5f2c4e45b8d5 (Richard Smith 2020-06-02 10:42:36 -0700 6673) if (!P->hasDefaultArg())
+b5f2c4e45b8d5 (Richard Smith 2020-06-02 10:42:36 -0700 6674) return false;
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6675) ExprResult R = S.BuildCXXDefaultArgExpr(CallLoc, Function, P);
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6676) if (R.isInvalid())
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6677) return false;
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6678) ConvertedArgs.push_back(R.get());
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6679) }
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6680)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6681) if (Trap.hasErrorOccurred())
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6682) return false;
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6683) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6684) return true;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6685) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6686)
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6687) EnableIfAttr *Sema::CheckEnableIf(FunctionDecl *Function,
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6688) SourceLocation CallLoc,
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6689) ArrayRef<Expr *> Args,
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6690) bool MissingImplicitThis) {
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 6691) auto EnableIfAttrs = Function->specific_attrs<EnableIfAttr>();
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 6692) if (EnableIfAttrs.begin() == EnableIfAttrs.end())
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6693) return nullptr;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6694)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6695) SFINAETrap Trap(*this);
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6696) SmallVector<Expr *, 16> ConvertedArgs;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6697) // FIXME: We should look into making enable_if late-parsed.
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6698) Expr *DiscardedThis;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6699) if (!convertArgsForAvailabilityChecks(
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 6700) *this, Function, /*ThisArg=*/nullptr, CallLoc, Args, Trap,
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6701) /*MissingImplicitThis=*/true, DiscardedThis, ConvertedArgs))
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 6702) return *EnableIfAttrs.begin();
+e283c5529e3c0 (Nick Lewycky 2015-08-25 22:33:16 +0000 6703)
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 6704) for (auto *EIA : EnableIfAttrs) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6705) APValue Result;
+e8f10cc0b9a9f (George Burgess IV 2016-05-11 01:38:27 +0000 6706) // FIXME: This doesn't consider value-dependent cases, because doing so is
+e8f10cc0b9a9f (George Burgess IV 2016-05-11 01:38:27 +0000 6707) // very
diff icult. Ideally, we should handle them more gracefully.
+04323c24a1ac9 (Dmitri Gribenko 2019-05-17 17:16:53 +0000 6708) if (EIA->getCond()->isValueDependent() ||
+04323c24a1ac9 (Dmitri Gribenko 2019-05-17 17:16:53 +0000 6709) !EIA->getCond()->EvaluateWithSubstitution(
+e8f10cc0b9a9f (George Burgess IV 2016-05-11 01:38:27 +0000 6710) Result, Context, Function, llvm::makeArrayRef(ConvertedArgs)))
+e8f10cc0b9a9f (George Burgess IV 2016-05-11 01:38:27 +0000 6711) return EIA;
+e8f10cc0b9a9f (George Burgess IV 2016-05-11 01:38:27 +0000 6712)
+e8f10cc0b9a9f (George Burgess IV 2016-05-11 01:38:27 +0000 6713) if (!Result.isInt() || !Result.getInt().getBoolValue())
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6714) return EIA;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6715) }
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 6716) return nullptr;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6717) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 6718)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6719) template <typename CheckFn>
+a7233bd801602 (Argyrios Kyrtzidis 2017-05-24 00:46:27 +0000 6720) static bool diagnoseDiagnoseIfAttrsWith(Sema &S, const NamedDecl *ND,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6721) bool ArgDependent, SourceLocation Loc,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6722) CheckFn &&IsSuccessful) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6723) SmallVector<const DiagnoseIfAttr *, 8> Attrs;
+a7233bd801602 (Argyrios Kyrtzidis 2017-05-24 00:46:27 +0000 6724) for (const auto *DIA : ND->specific_attrs<DiagnoseIfAttr>()) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6725) if (ArgDependent == DIA->getArgDependent())
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6726) Attrs.push_back(DIA);
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6727) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6728)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6729) // Common case: No diagnose_if attributes, so we can quit early.
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6730) if (Attrs.empty())
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6731) return false;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6732)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6733) auto WarningBegin = std::stable_partition(
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6734) Attrs.begin(), Attrs.end(),
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6735) [](const DiagnoseIfAttr *DIA) { return DIA->isError(); });
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6736)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6737) // Note that diagnose_if attributes are late-parsed, so they appear in the
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6738) // correct order (unlike enable_if attributes).
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6739) auto ErrAttr = llvm::find_if(llvm::make_range(Attrs.begin(), WarningBegin),
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6740) IsSuccessful);
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6741) if (ErrAttr != WarningBegin) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6742) const DiagnoseIfAttr *DIA = *ErrAttr;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6743) S.Diag(Loc, diag::err_diagnose_if_succeeded) << DIA->getMessage();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6744) S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6745) << DIA->getParent() << DIA->getCond()->getSourceRange();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6746) return true;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6747) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6748)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6749) for (const auto *DIA : llvm::make_range(WarningBegin, Attrs.end()))
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6750) if (IsSuccessful(DIA)) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6751) S.Diag(Loc, diag::warn_diagnose_if_succeeded) << DIA->getMessage();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6752) S.Diag(DIA->getLocation(), diag::note_from_diagnose_if)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6753) << DIA->getParent() << DIA->getCond()->getSourceRange();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6754) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6755)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6756) return false;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6757) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6758)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6759) bool Sema::diagnoseArgDependentDiagnoseIfAttrs(const FunctionDecl *Function,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6760) const Expr *ThisArg,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6761) ArrayRef<const Expr *> Args,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6762) SourceLocation Loc) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6763) return diagnoseDiagnoseIfAttrsWith(
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6764) *this, Function, /*ArgDependent=*/true, Loc,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6765) [&](const DiagnoseIfAttr *DIA) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6766) APValue Result;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6767) // It's sane to use the same Args for any redecl of this function, since
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6768) // EvaluateWithSubstitution only cares about the position of each
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6769) // argument in the arg list, not the ParmVarDecl* it maps to.
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6770) if (!DIA->getCond()->EvaluateWithSubstitution(
+a7233bd801602 (Argyrios Kyrtzidis 2017-05-24 00:46:27 +0000 6771) Result, Context, cast<FunctionDecl>(DIA->getParent()), Args, ThisArg))
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6772) return false;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6773) return Result.isInt() && Result.getInt().getBoolValue();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6774) });
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6775) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6776)
+a7233bd801602 (Argyrios Kyrtzidis 2017-05-24 00:46:27 +0000 6777) bool Sema::diagnoseArgIndependentDiagnoseIfAttrs(const NamedDecl *ND,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6778) SourceLocation Loc) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6779) return diagnoseDiagnoseIfAttrsWith(
+a7233bd801602 (Argyrios Kyrtzidis 2017-05-24 00:46:27 +0000 6780) *this, ND, /*ArgDependent=*/false, Loc,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6781) [&](const DiagnoseIfAttr *DIA) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6782) bool Result;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6783) return DIA->getCond()->EvaluateAsBooleanCondition(Result, Context) &&
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6784) Result;
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6785) });
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6786) }
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6787)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 6788) /// Add all of the function declarations in the given function set to
+ed4265c24e2b6 (Nick Lewycky 2013-09-22 10:06:01 +0000 6789) /// the overload candidate set.
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 6790) void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns,
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 6791) ArrayRef<Expr *> Args,
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6792) OverloadCandidateSet &CandidateSet,
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 6793) TemplateArgumentListInfo *ExplicitTemplateArgs,
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 6794) bool SuppressUserConversions,
+e3962aebca1e2 (Benjamin Kramer 2017-10-26 08:41:28 +0000 6795) bool PartialOverloading,
+e3962aebca1e2 (Benjamin Kramer 2017-10-26 08:41:28 +0000 6796) bool FirstArgumentIsBase) {
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 6797) for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 6798) NamedDecl *D = F.getDecl()->getUnderlyingDecl();
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6799) ArrayRef<Expr *> FunctionArgs = Args;
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6800)
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6801) FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6802) FunctionDecl *FD =
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6803) FunTmpl ? FunTmpl->getTemplatedDecl() : cast<FunctionDecl>(D);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6804)
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6805) if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) {
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6806) QualType ObjectType;
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6807) Expr::Classification ObjectClassification;
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6808) if (Args.size() > 0) {
+f1898cfa42a05 (Erik Verbruggen 2017-03-28 07:22:21 +0000 6809) if (Expr *E = Args[0]) {
+2a8c18d991188 (Alexander Kornienko 2018-04-06 15:14:32 +0000 6810) // Use the explicit base to restrict the lookup:
+f1898cfa42a05 (Erik Verbruggen 2017-03-28 07:22:21 +0000 6811) ObjectType = E->getType();
+143a9e0b1236d (Ilya Biryukov 2018-12-07 13:17:52 +0000 6812) // Pointers in the object arguments are implicitly dereferenced, so we
+143a9e0b1236d (Ilya Biryukov 2018-12-07 13:17:52 +0000 6813) // always classify them as l-values.
+143a9e0b1236d (Ilya Biryukov 2018-12-07 13:17:52 +0000 6814) if (!ObjectType.isNull() && ObjectType->isPointerType())
+143a9e0b1236d (Ilya Biryukov 2018-12-07 13:17:52 +0000 6815) ObjectClassification = Expr::Classification::makeSimpleLValue();
+143a9e0b1236d (Ilya Biryukov 2018-12-07 13:17:52 +0000 6816) else
+143a9e0b1236d (Ilya Biryukov 2018-12-07 13:17:52 +0000 6817) ObjectClassification = E->Classify(Context);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6818) } // .. else there is an implicit base.
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6819) FunctionArgs = Args.slice(1);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6820) }
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6821) if (FunTmpl) {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6822) AddMethodTemplateCandidate(
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6823) FunTmpl, F.getPair(),
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 6824) cast<CXXRecordDecl>(FunTmpl->getDeclContext()),
+f1898cfa42a05 (Erik Verbruggen 2017-03-28 07:22:21 +0000 6825) ExplicitTemplateArgs, ObjectType, ObjectClassification,
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6826) FunctionArgs, CandidateSet, SuppressUserConversions,
+f1898cfa42a05 (Erik Verbruggen 2017-03-28 07:22:21 +0000 6827) PartialOverloading);
+f1898cfa42a05 (Erik Verbruggen 2017-03-28 07:22:21 +0000 6828) } else {
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6829) AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(),
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6830) cast<CXXMethodDecl>(FD)->getParent(), ObjectType,
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6831) ObjectClassification, FunctionArgs, CandidateSet,
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6832) SuppressUserConversions, PartialOverloading);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6833) }
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6834) } else {
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6835) // This branch handles both standalone functions and static methods.
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6836)
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6837) // Slice the first argument (which is the base) when we access
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6838) // static method as non-static.
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6839) if (Args.size() > 0 &&
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6840) (!Args[0] || (FirstArgumentIsBase && isa<CXXMethodDecl>(FD) &&
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6841) !isa<CXXConstructorDecl>(FD)))) {
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6842) assert(cast<CXXMethodDecl>(FD)->isStatic());
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6843) FunctionArgs = Args.slice(1);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6844) }
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6845) if (FunTmpl) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6846) AddTemplateOverloadCandidate(FunTmpl, F.getPair(),
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6847) ExplicitTemplateArgs, FunctionArgs,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6848) CandidateSet, SuppressUserConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6849) PartialOverloading);
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6850) } else {
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6851) AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet,
+f83cfda02bd06 (Ivan Donchevskii 2018-06-21 08:34:50 +0000 6852) SuppressUserConversions, PartialOverloading);
+f1898cfa42a05 (Erik Verbruggen 2017-03-28 07:22:21 +0000 6853) }
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 6854) }
+15448f8d238c5 (Douglas Gregor 2009-06-27 21:05:07 +0000 6855) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 6856) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 6857)
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6858) /// AddMethodCandidate - Adds a named decl (which is some kind of
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6859) /// method) as a method candidate to the given overload set.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6860) void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, QualType ObjectType,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 6861) Expr::Classification ObjectClassification,
+51629dfce2e0c (Rafael Espindola 2013-04-29 19:29:25 +0000 6862) ArrayRef<Expr *> Args,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6863) OverloadCandidateSet &CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6864) bool SuppressUserConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6865) OverloadCandidateParamOrder PO) {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 6866) NamedDecl *Decl = FoundDecl.getDecl();
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 6867) CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext());
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6868)
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6869) if (isa<UsingShadowDecl>(Decl))
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6870) Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 6871)
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6872) if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) {
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6873) assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) &&
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6874) "Expected a member function template");
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 6875) AddMethodTemplateCandidate(TD, FoundDecl, ActingContext,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6876) /*ExplicitArgs*/ nullptr, ObjectType,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6877) ObjectClassification, Args, CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6878) SuppressUserConversions, false, PO);
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6879) } else {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 6880) AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6881) ObjectType, ObjectClassification, Args, CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6882) SuppressUserConversions, false, None, PO);
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6883) }
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6884) }
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 6885)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6886) /// AddMethodCandidate - Adds the given C++ member function to the set
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6887) /// of candidate functions, using the given function call arguments
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6888) /// and the object argument (@c Object). For example, in a call
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6889) /// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6890) /// both @c a1 and @c a2. If @p SuppressUserConversions, then don't
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6891) /// allow user-defined conversions via constructors or conversion
+f1e4669232de4 (Douglas Gregor 2010-04-16 17:33:27 +0000 6892) /// operators.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 6893) void
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 6894) Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl,
+b89836b6db6fa (John McCall 2010-01-26 01:37:31 +0000 6895) CXXRecordDecl *ActingContext, QualType ObjectType,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 6896) Expr::Classification ObjectClassification,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 6897) ArrayRef<Expr *> Args,
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6898) OverloadCandidateSet &CandidateSet,
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 6899) bool SuppressUserConversions,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6900) bool PartialOverloading,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6901) ConversionSequenceList EarlyConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6902) OverloadCandidateParamOrder PO) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 6903) const FunctionProtoType *Proto
+9dd450bb78148 (John McCall 2009-09-21 23:43:11 +0000 6904) = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>());
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6905) assert(Proto && "Methods without a prototype cannot be overloaded");
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6906) assert(!isa<CXXConstructorDecl>(Method) &&
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 6907) "Use AddOverloadCandidate for constructors");
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6908)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6909) if (!CandidateSet.isNewCandidate(Method, PO))
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 6910) return;
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 6911)
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6912) // C++11 [class.copy]p23: [DR1402]
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6913) // A defaulted move assignment operator that is defined as deleted is
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6914) // ignored by overload resolution.
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6915) if (Method->isDefaulted() && Method->isDeleted() &&
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6916) Method->isMoveAssignmentOperator())
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6917) return;
+8b86f2d4010e1 (Richard Smith 2013-11-04 01:48:18 +0000 6918)
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 6919) // Overload resolution is always an unevaluated context.
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 6920) EnterExpressionEvaluationContext Unevaluated(
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 6921) *this, Sema::ExpressionEvaluationContext::Unevaluated);
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 6922)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6923) // Add this candidate
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6924) OverloadCandidate &Candidate =
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 6925) CandidateSet.addCandidate(Args.size() + 1, EarlyConversions);
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 6926) Candidate.FoundDecl = FoundDecl;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6927) Candidate.Function = Method;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6928) Candidate.RewriteKind =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6929) CandidateSet.getRewriteInfo().getRewriteKind(Method, PO);
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 6930) Candidate.IsSurrogate = false;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6931) Candidate.IgnoreObjectArgument = false;
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 6932) Candidate.ExplicitCallArguments = Args.size();
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6933)
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 6934) unsigned NumParams = Proto->getNumParams();
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6935)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6936) // (C++ 13.3.2p2): A candidate function having fewer than m
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6937) // parameters is viable only if it has an ellipsis in its parameter
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6938) // list (8.3.5).
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 6939) if (TooManyArguments(NumParams, Args.size(), PartialOverloading) &&
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 6940) !Proto->isVariadic()) {
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6941) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 6942) Candidate.FailureKind = ovl_fail_too_many_arguments;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6943) return;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6944) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6945)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6946) // (C++ 13.3.2p2): A candidate function having more than m parameters
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6947) // is viable only if the (m+1)st parameter has a default argument
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6948) // (8.3.6). For the purposes of overload resolution, the
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6949) // parameter list is truncated on the right, so that there are
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6950) // exactly m parameters.
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6951) unsigned MinRequiredArgs = Method->getMinRequiredArguments();
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 6952) if (Args.size() < MinRequiredArgs && !PartialOverloading) {
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6953) // Not enough arguments.
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6954) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 6955) Candidate.FailureKind = ovl_fail_too_few_arguments;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6956) return;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6957) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6958)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6959) Candidate.Viable = true;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6960)
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 6961) if (Method->isStatic() || ObjectType.isNull())
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6962) // The implicit object argument is ignored.
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6963) Candidate.IgnoreObjectArgument = true;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6964) else {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6965) unsigned ConvIdx = PO == OverloadCandidateParamOrder::Reversed ? 1 : 0;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6966) // Determine the implicit conversion sequence for the object
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6967) // parameter.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6968) Candidate.Conversions[ConvIdx] = TryObjectArgumentInitialization(
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 6969) *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 6970) Method, ActingContext);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 6971) if (Candidate.Conversions[ConvIdx].isBad()) {
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6972) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 6973) Candidate.FailureKind = ovl_fail_bad_conversion;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6974) return;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 6975) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6976) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6977)
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6978) // (CUDA B.1): Check for invalid calls between targets.
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6979) if (getLangOpts().CUDA)
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6980) if (const FunctionDecl *Caller = dyn_cast<FunctionDecl>(CurContext))
+b008003aa3f0d (Justin Lebar 2016-08-10 01:09:11 +0000 6981) if (!IsAllowedCUDACall(Caller, Method)) {
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6982) Candidate.Viable = false;
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6983) Candidate.FailureKind = ovl_fail_bad_target;
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6984) return;
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6985) }
+291a57e2c22b6 (Eli Bendersky 2014-09-25 23:59:08 +0000 6986)
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 6987) if (Method->getTrailingRequiresClause()) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6988) ConstraintSatisfaction Satisfaction;
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 6989) if (CheckFunctionConstraints(Method, Satisfaction) ||
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6990) !Satisfaction.IsSatisfied) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6991) Candidate.Viable = false;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6992) Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6993) return;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6994) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6995) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 6996)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6997) // Determine the implicit conversion sequences for each of the
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 6998) // arguments.
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 6999) for (unsigned ArgIdx = 0; ArgIdx < Args.size(); ++ArgIdx) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7000) unsigned ConvIdx =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7001) PO == OverloadCandidateParamOrder::Reversed ? 0 : (ArgIdx + 1);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7002) if (Candidate.Conversions[ConvIdx].isInitialized()) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7003) // We already formed a conversion sequence for this parameter during
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7004) // template argument deduction.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7005) } else if (ArgIdx < NumParams) {
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7006) // (C++ 13.3.2p3): for F to be a viable function, there shall
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7007) // exist for each argument an implicit conversion sequence
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7008) // (13.3.3.1) that converts that argument to the corresponding
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7009) // parameter of F.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 7010) QualType ParamType = Proto->getParamType(ArgIdx);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7011) Candidate.Conversions[ConvIdx]
+cb13cfc878200 (Douglas Gregor 2010-04-16 17:51:22 +0000 7012) = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7013) SuppressUserConversions,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 7014) /*InOverloadResolution=*/true,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 7015) /*AllowObjCWritebackConversion=*/
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 7016) getLangOpts().ObjCAutoRefCount);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7017) if (Candidate.Conversions[ConvIdx].isBad()) {
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7018) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7019) Candidate.FailureKind = ovl_fail_bad_conversion;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7020) return;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7021) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7022) } else {
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7023) // (C++ 13.3.2p2): For the purposes of overload resolution, any
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7024) // argument for which there is no corresponding parameter is
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7025) // considered to "match the ellipsis" (C+ 13.3.3.1.3).
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7026) Candidate.Conversions[ConvIdx].setEllipsis();
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7027) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7028) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7029)
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 7030) if (EnableIfAttr *FailedAttr =
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 7031) CheckEnableIf(Method, CandidateSet.getLocation(), Args, true)) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7032) Candidate.Viable = false;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7033) Candidate.FailureKind = ovl_fail_enable_if;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7034) Candidate.DeductionFailure.Data = FailedAttr;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7035) return;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7036) }
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7037)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 7038) if (Method->isMultiVersion() && Method->hasAttr<TargetAttr>() &&
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7039) !Method->getAttr<TargetAttr>()->isDefaultVersion()) {
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7040) Candidate.Viable = false;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7041) Candidate.FailureKind = ovl_non_default_multiversion_function;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7042) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7043) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7044)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7045) /// Add a C++ member function template as a candidate to the candidate
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7046) /// set, using template argument deduction to produce an appropriate member
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7047) /// function template specialization.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7048) void Sema::AddMethodTemplateCandidate(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7049) FunctionTemplateDecl *MethodTmpl, DeclAccessPair FoundDecl,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7050) CXXRecordDecl *ActingContext,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7051) TemplateArgumentListInfo *ExplicitTemplateArgs, QualType ObjectType,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7052) Expr::Classification ObjectClassification, ArrayRef<Expr *> Args,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7053) OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7054) bool PartialOverloading, OverloadCandidateParamOrder PO) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7055) if (!CandidateSet.isNewCandidate(MethodTmpl, PO))
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7056) return;
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7057)
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7058) // C++ [over.match.funcs]p7:
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7059) // In each case where a candidate is a function template, candidate
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7060) // function template specializations are generated using template argument
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7061) // deduction (14.8.3, 14.8.2). Those candidates are then handled as
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7062) // candidate functions in the usual way.113) A given name can refer to one
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7063) // or more function templates and also to a set of overloaded non-template
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7064) // functions. In such a case, the candidate functions generated from each
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7065) // function template are combined with the set of non-template candidate
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7066) // functions.
+e6706e40bb692 (Craig Topper 2012-09-19 02:26:47 +0000 7067) TemplateDeductionInfo Info(CandidateSet.getLocation());
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 7068) FunctionDecl *Specialization = nullptr;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7069) ConversionSequenceList Conversions;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7070) if (TemplateDeductionResult Result = DeduceTemplateArguments(
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7071) MethodTmpl, ExplicitTemplateArgs, Args, Specialization, Info,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7072) PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7073) return CheckNonDependentConversions(
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7074) MethodTmpl, ParamTypes, Args, CandidateSet, Conversions,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7075) SuppressUserConversions, ActingContext, ObjectType,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7076) ObjectClassification, PO);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7077) })) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7078) OverloadCandidate &Candidate =
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7079) CandidateSet.addCandidate(Conversions.size(), Conversions);
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7080) Candidate.FoundDecl = FoundDecl;
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7081) Candidate.Function = MethodTmpl->getTemplatedDecl();
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7082) Candidate.Viable = false;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7083) Candidate.RewriteKind =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7084) CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7085) Candidate.IsSurrogate = false;
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7086) Candidate.IgnoreObjectArgument =
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7087) cast<CXXMethodDecl>(Candidate.Function)->isStatic() ||
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7088) ObjectType.isNull();
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 7089) Candidate.ExplicitCallArguments = Args.size();
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7090) if (Result == TDK_NonDependentConversionFailure)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7091) Candidate.FailureKind = ovl_fail_bad_conversion;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7092) else {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7093) Candidate.FailureKind = ovl_fail_bad_deduction;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7094) Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7095) Info);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7096) }
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7097) return;
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7098) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7099)
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7100) // Add the function template specialization produced by template argument
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7101) // deduction as a candidate.
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7102) assert(Specialization && "Missing member function template specialization?");
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7103) assert(isa<CXXMethodDecl>(Specialization) &&
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7104) "Specialization is not a member function?");
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7105) AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 7106) ActingContext, ObjectType, ObjectClassification, Args,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 7107) CandidateSet, SuppressUserConversions, PartialOverloading,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7108) Conversions, PO);
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7109) }
+97628d6a4ce22 (Douglas Gregor 2009-08-21 00:16:32 +0000 7110)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7111) /// Determine whether a given function template has a simple explicit specifier
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7112) /// or a non-value-dependent explicit-specification that evaluates to true.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7113) static bool isNonDependentlyExplicit(FunctionTemplateDecl *FTD) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7114) return ExplicitSpecifier::getFromDecl(FTD->getTemplatedDecl()).isExplicit();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7115) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7116)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7117) /// Add a C++ function template specialization as a candidate
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7118) /// in the candidate set, using template argument deduction to produce
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7119) /// an appropriate function template specialization.
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 7120) void Sema::AddTemplateOverloadCandidate(
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 7121) FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 7122) TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 7123) OverloadCandidateSet &CandidateSet, bool SuppressUserConversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7124) bool PartialOverloading, bool AllowExplicit, ADLCallKind IsADLCandidate,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7125) OverloadCandidateParamOrder PO) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7126) if (!CandidateSet.isNewCandidate(FunctionTemplate, PO))
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7127) return;
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7128)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7129) // If the function template has a non-dependent explicit specification,
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7130) // exclude it now if appropriate; we are not permitted to perform deduction
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7131) // and substitution in this case.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7132) if (!AllowExplicit && isNonDependentlyExplicit(FunctionTemplate)) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7133) OverloadCandidate &Candidate = CandidateSet.addCandidate();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7134) Candidate.FoundDecl = FoundDecl;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7135) Candidate.Function = FunctionTemplate->getTemplatedDecl();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7136) Candidate.Viable = false;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7137) Candidate.FailureKind = ovl_fail_explicit;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7138) return;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7139) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7140)
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7141) // C++ [over.match.funcs]p7:
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7142) // In each case where a candidate is a function template, candidate
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7143) // function template specializations are generated using template argument
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7144) // deduction (14.8.3, 14.8.2). Those candidates are then handled as
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7145) // candidate functions in the usual way.113) A given name can refer to one
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7146) // or more function templates and also to a set of overloaded non-template
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7147) // functions. In such a case, the candidate functions generated from each
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7148) // function template are combined with the set of non-template candidate
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7149) // functions.
+e6706e40bb692 (Craig Topper 2012-09-19 02:26:47 +0000 7150) TemplateDeductionInfo Info(CandidateSet.getLocation());
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 7151) FunctionDecl *Specialization = nullptr;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7152) ConversionSequenceList Conversions;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7153) if (TemplateDeductionResult Result = DeduceTemplateArguments(
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7154) FunctionTemplate, ExplicitTemplateArgs, Args, Specialization, Info,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7155) PartialOverloading, [&](ArrayRef<QualType> ParamTypes) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7156) return CheckNonDependentConversions(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7157) FunctionTemplate, ParamTypes, Args, CandidateSet, Conversions,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7158) SuppressUserConversions, nullptr, QualType(), {}, PO);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7159) })) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7160) OverloadCandidate &Candidate =
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7161) CandidateSet.addCandidate(Conversions.size(), Conversions);
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7162) Candidate.FoundDecl = FoundDecl;
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 7163) Candidate.Function = FunctionTemplate->getTemplatedDecl();
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 7164) Candidate.Viable = false;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7165) Candidate.RewriteKind =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7166) CandidateSet.getRewriteInfo().getRewriteKind(Candidate.Function, PO);
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 7167) Candidate.IsSurrogate = false;
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 7168) Candidate.IsADLCandidate = IsADLCandidate;
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7169) // Ignore the object argument if there is one, since we don't have an object
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7170) // type.
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7171) Candidate.IgnoreObjectArgument =
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7172) isa<CXXMethodDecl>(Candidate.Function) &&
+9d05e15c3a26c (Richard Smith 2017-01-10 20:52:50 +0000 7173) !isa<CXXConstructorDecl>(Candidate.Function);
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 7174) Candidate.ExplicitCallArguments = Args.size();
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7175) if (Result == TDK_NonDependentConversionFailure)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7176) Candidate.FailureKind = ovl_fail_bad_conversion;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7177) else {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7178) Candidate.FailureKind = ovl_fail_bad_deduction;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7179) Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7180) Info);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7181) }
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7182) return;
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7183) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7184)
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7185) // Add the function template specialization produced by template argument
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7186) // deduction as a candidate.
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7187) assert(Specialization && "Missing function template specialization?");
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7188) AddOverloadCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7189) Specialization, FoundDecl, Args, CandidateSet, SuppressUserConversions,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7190) PartialOverloading, AllowExplicit,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7191) /*AllowExplicitConversions*/ false, IsADLCandidate, Conversions, PO);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7192) }
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7193)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7194) /// Check that implicit conversion sequences can be formed for each argument
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7195) /// whose corresponding parameter has a non-dependent type, per DR1391's
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7196) /// [temp.deduct.call]p10.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7197) bool Sema::CheckNonDependentConversions(
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7198) FunctionTemplateDecl *FunctionTemplate, ArrayRef<QualType> ParamTypes,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7199) ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7200) ConversionSequenceList &Conversions, bool SuppressUserConversions,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7201) CXXRecordDecl *ActingContext, QualType ObjectType,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7202) Expr::Classification ObjectClassification, OverloadCandidateParamOrder PO) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7203) // FIXME: The cases in which we allow explicit conversions for constructor
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7204) // arguments never consider calling a constructor template. It's not clear
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7205) // that is correct.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7206) const bool AllowExplicit = false;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7207)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7208) auto *FD = FunctionTemplate->getTemplatedDecl();
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7209) auto *Method = dyn_cast<CXXMethodDecl>(FD);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7210) bool HasThisConversion = Method && !isa<CXXConstructorDecl>(Method);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7211) unsigned ThisConversions = HasThisConversion ? 1 : 0;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7212)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7213) Conversions =
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7214) CandidateSet.allocateConversionSequences(ThisConversions + Args.size());
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7215)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7216) // Overload resolution is always an unevaluated context.
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7217) EnterExpressionEvaluationContext Unevaluated(
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7218) *this, Sema::ExpressionEvaluationContext::Unevaluated);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7219)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7220) // For a method call, check the 'this' conversion here too. DR1391 doesn't
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7221) // require that, but this check should never result in a hard error, and
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7222) // overload resolution is permitted to sidestep instantiations.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7223) if (HasThisConversion && !cast<CXXMethodDecl>(FD)->isStatic() &&
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7224) !ObjectType.isNull()) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7225) unsigned ConvIdx = PO == OverloadCandidateParamOrder::Reversed ? 1 : 0;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7226) Conversions[ConvIdx] = TryObjectArgumentInitialization(
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7227) *this, CandidateSet.getLocation(), ObjectType, ObjectClassification,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7228) Method, ActingContext);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7229) if (Conversions[ConvIdx].isBad())
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7230) return true;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7231) }
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7232)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7233) for (unsigned I = 0, N = std::min(ParamTypes.size(), Args.size()); I != N;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7234) ++I) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7235) QualType ParamType = ParamTypes[I];
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7236) if (!ParamType->isDependentType()) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7237) unsigned ConvIdx = PO == OverloadCandidateParamOrder::Reversed
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7238) ? 0
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7239) : (ThisConversions + I);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7240) Conversions[ConvIdx]
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7241) = TryCopyInitialization(*this, Args[I], ParamType,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7242) SuppressUserConversions,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7243) /*InOverloadResolution=*/true,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7244) /*AllowObjCWritebackConversion=*/
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7245) getLangOpts().ObjCAutoRefCount,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7246) AllowExplicit);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7247) if (Conversions[ConvIdx].isBad())
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7248) return true;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7249) }
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7250) }
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7251)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 7252) return false;
+ad3f2fcf43eb7 (Douglas Gregor 2009-06-25 22:08:12 +0000 7253) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7254)
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7255) /// Determine whether this is an allowable conversion from the result
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7256) /// of an explicit conversion operator to the expected type, per C++
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7257) /// [over.match.conv]p1 and [over.match.ref]p1.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7258) ///
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7259) /// \param ConvType The return type of the conversion function.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7260) ///
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7261) /// \param ToType The type we are converting to.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7262) ///
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7263) /// \param AllowObjCPointerConversion Allow a conversion from one
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7264) /// Objective-C pointer to another.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7265) ///
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7266) /// \returns true if the conversion is allowable, false otherwise.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7267) static bool isAllowableExplicitConversion(Sema &S,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7268) QualType ConvType, QualType ToType,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7269) bool AllowObjCPointerConversion) {
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7270) QualType ToNonRefType = ToType.getNonReferenceType();
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7271)
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7272) // Easy case: the types are the same.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7273) if (S.Context.hasSameUnqualifiedType(ConvType, ToNonRefType))
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7274) return true;
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7275)
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7276) // Allow qualification conversions.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7277) bool ObjCLifetimeConversion;
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7278) if (S.IsQualificationConversion(ConvType, ToNonRefType, /*CStyle*/false,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7279) ObjCLifetimeConversion))
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7280) return true;
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7281)
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7282) // If we're not allowed to consider Objective-C pointer conversions,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7283) // we're done.
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7284) if (!AllowObjCPointerConversion)
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7285) return false;
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7286)
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7287) // Is this an Objective-C pointer conversion?
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7288) bool IncompatibleObjC = false;
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7289) QualType ConvertedType;
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7290) return S.isObjCPointerConversion(ConvType, ToNonRefType, ConvertedType,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7291) IncompatibleObjC);
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7292) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7293)
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7294) /// AddConversionCandidate - Add a C++ conversion function as a
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7295) /// candidate in the candidate set (C++ [over.match.conv],
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7296) /// C++ [over.match.copy]). From is the expression we're converting from,
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7297) /// and ToType is the type that we're eventually trying to convert to
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7298) /// (which may or may not be the same type as the type that the
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7299) /// conversion function produces).
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7300) void Sema::AddConversionCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7301) CXXConversionDecl *Conversion, DeclAccessPair FoundDecl,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7302) CXXRecordDecl *ActingContext, Expr *From, QualType ToType,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7303) OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7304) bool AllowExplicit, bool AllowResultConversion) {
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7305) assert(!Conversion->getDescribedFunctionTemplate() &&
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7306) "Conversion function templates use AddTemplateConversionCandidate");
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 7307) QualType ConvType = Conversion->getConversionType().getNonReferenceType();
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7308) if (!CandidateSet.isNewCandidate(Conversion))
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7309) return;
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7310)
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7311) // If the conversion function has an undeduced return type, trigger its
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7312) // deduction now.
+dd69ef38dba72 (Aaron Ballman 2014-08-19 15:55:55 +0000 7313) if (getLangOpts().CPlusPlus14 && ConvType->isUndeducedType()) {
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7314) if (DeduceReturnType(Conversion, From->getExprLoc()))
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7315) return;
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7316) ConvType = Conversion->getConversionType().getNonReferenceType();
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7317) }
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 7318)
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7319) // If we don't allow any conversion of the result type, ignore conversion
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7320) // functions that don't convert to exactly (possibly cv-qualified) T.
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7321) if (!AllowResultConversion &&
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7322) !Context.hasSameUnqualifiedType(Conversion->getConversionType(), ToType))
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7323) return;
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7324)
+089c31637f86a (Richard Smith 2013-09-21 21:55:46 +0000 7325) // Per C++ [over.match.conv]p1, [over.match.ref]p1, an explicit conversion
+089c31637f86a (Richard Smith 2013-09-21 21:55:46 +0000 7326) // operator is only a candidate if its return type is the target type or
+089c31637f86a (Richard Smith 2013-09-21 21:55:46 +0000 7327) // can be converted to the target type with a qualification conversion.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7328) //
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7329) // FIXME: Include such functions in the candidate list and explain why we
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7330) // can't select them.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7331) if (Conversion->isExplicit() &&
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7332) !isAllowableExplicitConversion(*this, ConvType, ToType,
+4b60a1594d2c6 (Douglas Gregor 2013-11-07 22:34:54 +0000 7333) AllowObjCConversionOnExplicit))
+089c31637f86a (Richard Smith 2013-09-21 21:55:46 +0000 7334) return;
+089c31637f86a (Richard Smith 2013-09-21 21:55:46 +0000 7335)
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 7336) // Overload resolution is always an unevaluated context.
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7337) EnterExpressionEvaluationContext Unevaluated(
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7338) *this, Sema::ExpressionEvaluationContext::Unevaluated);
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 7339)
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7340) // Add this candidate
+fb761ff54452f (Benjamin Kramer 2012-01-14 16:31:55 +0000 7341) OverloadCandidate &Candidate = CandidateSet.addCandidate(1);
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7342) Candidate.FoundDecl = FoundDecl;
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7343) Candidate.Function = Conversion;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7344) Candidate.IsSurrogate = false;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 7345) Candidate.IgnoreObjectArgument = false;
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7346) Candidate.FinalConversion.setAsIdentityConversion();
+5ab116553171e (Douglas Gregor 2010-04-17 22:01:05 +0000 7347) Candidate.FinalConversion.setFromType(ConvType);
+3edc4d5ec3fdc (Douglas Gregor 2010-01-27 03:51:04 +0000 7348) Candidate.FinalConversion.setAllToTypes(ToType);
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7349) Candidate.Viable = true;
+6edd977c6f368 (Douglas Gregor 2011-01-19 23:54:39 +0000 7350) Candidate.ExplicitCallArguments = 1;
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7351)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7352) // Explicit functions are not actually candidates at all if we're not
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7353) // allowing them in this context, but keep them around so we can point
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7354) // to them in diagnostics.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7355) if (!AllowExplicit && Conversion->isExplicit()) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7356) Candidate.Viable = false;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7357) Candidate.FailureKind = ovl_fail_explicit;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7358) return;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7359) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7360)
+6affc78f1b43b (Douglas Gregor 2010-08-19 15:37:02 +0000 7361) // C++ [over.match.funcs]p4:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7362) // For conversion functions, the function is considered to be a member of
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7363) // the class of the implicit implied object argument for the purpose of
+6affc78f1b43b (Douglas Gregor 2010-08-19 15:37:02 +0000 7364) // defining the type of the implicit object parameter.
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7365) //
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7366) // Determine the implicit conversion sequence for the implicit
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7367) // object parameter.
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7368) QualType ImplicitParamType = From->getType();
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7369) if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>())
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7370) ImplicitParamType = FromPtrType->getPointeeType();
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7371) CXXRecordDecl *ConversionContext
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 7372) = cast<CXXRecordDecl>(ImplicitParamType->castAs<RecordType>()->getDecl());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7373)
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7374) Candidate.Conversions[0] = TryObjectArgumentInitialization(
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7375) *this, CandidateSet.getLocation(), From->getType(),
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7376) From->Classify(Context), Conversion, ConversionContext);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7377)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7378) if (Candidate.Conversions[0].isBad()) {
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7379) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7380) Candidate.FailureKind = ovl_fail_bad_conversion;
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7381) return;
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7382) }
+c9ed4681a8511 (Douglas Gregor 2010-08-19 15:57:50 +0000 7383)
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 7384) if (Conversion->getTrailingRequiresClause()) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7385) ConstraintSatisfaction Satisfaction;
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 7386) if (CheckFunctionConstraints(Conversion, Satisfaction) ||
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7387) !Satisfaction.IsSatisfied) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7388) Candidate.Viable = false;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7389) Candidate.FailureKind = ovl_fail_constraints_not_satisfied;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7390) return;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7391) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7392) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 7393)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7394) // We won't go through a user-defined type conversion function to convert a
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7395) // derived to base as such conversions are given Conversion Rank. They only
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7396) // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user]
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7397) QualType FromCanon
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7398) = Context.getCanonicalType(From->getType().getUnqualifiedType());
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7399) QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType();
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7400) if (FromCanon == ToCanon ||
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7401) IsDerivedFrom(CandidateSet.getLocation(), FromCanon, ToCanon)) {
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7402) Candidate.Viable = false;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 7403) Candidate.FailureKind = ovl_fail_trivial_conversion;
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7404) return;
+996a6aa3f18c3 (Fariborz Jahanian 2009-10-19 19:18:20 +0000 7405) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7406)
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7407) // To determine what the conversion from the result of calling the
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7408) // conversion function to the type we're eventually trying to
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7409) // convert to (ToType), we need to synthesize a call to the
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7410) // conversion function and attempt copy initialization from it. This
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7411) // makes sure that we get the right semantics with respect to
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7412) // lvalues/rvalues and the type. Fortunately, we can allocate this
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7413) // call on the stack and we don't need its arguments to be
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7414) // well-formed.
+5fc4db75798c8 (Bruno Ricci 2018-12-21 14:10:18 +0000 7415) DeclRefExpr ConversionRef(Context, Conversion, false, Conversion->getType(),
+5fc4db75798c8 (Bruno Ricci 2018-12-21 14:10:18 +0000 7416) VK_LValue, From->getBeginLoc());
+cf1421650953d (John McCall 2010-08-07 06:22:56 +0000 7417) ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack,
+cf1421650953d (John McCall 2010-08-07 06:22:56 +0000 7418) Context.getPointerType(Conversion->getType()),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 7419) CK_FunctionToPointerDecay, &ConversionRef,
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 7420) VK_RValue, FPOptionsOverride());
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7421)
+48d2464c3fd8b (Richard Smith 2011-07-13 22:53:21 +0000 7422) QualType ConversionType = Conversion->getConversionType();
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 7423) if (!isCompleteType(From->getBeginLoc(), ConversionType)) {
+72ebdabc5d60e (Douglas Gregor 2010-11-13 19:36:57 +0000 7424) Candidate.Viable = false;
+72ebdabc5d60e (Douglas Gregor 2010-11-13 19:36:57 +0000 7425) Candidate.FailureKind = ovl_fail_bad_final_conversion;
+72ebdabc5d60e (Douglas Gregor 2010-11-13 19:36:57 +0000 7426) return;
+72ebdabc5d60e (Douglas Gregor 2010-11-13 19:36:57 +0000 7427) }
+72ebdabc5d60e (Douglas Gregor 2010-11-13 19:36:57 +0000 7428)
+48d2464c3fd8b (Richard Smith 2011-07-13 22:53:21 +0000 7429) ExprValueKind VK = Expr::getValueKindForType(ConversionType);
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 7430)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7431) // Note that it is safe to allocate CallExpr on the stack here because
+d7b4f40b18476 (Ted Kremenek 2009-02-09 20:51:47 +0000 7432) // there are 0 arguments (i.e., nothing is allocated using ASTContext's
+d7b4f40b18476 (Ted Kremenek 2009-02-09 20:51:47 +0000 7433) // allocator).
+48d2464c3fd8b (Richard Smith 2011-07-13 22:53:21 +0000 7434) QualType CallResultType = ConversionType.getNonLValueExprType(Context);
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7435)
+ac8686205b0b0 (JF Bastien 2019-07-29 23:12:48 +0000 7436) alignas(CallExpr) char Buffer[sizeof(CallExpr) + sizeof(Stmt *)];
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7437) CallExpr *TheTemporaryCall = CallExpr::CreateTemporary(
+ac8686205b0b0 (JF Bastien 2019-07-29 23:12:48 +0000 7438) Buffer, &ConversionFn, CallResultType, VK, From->getBeginLoc());
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7439)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7440) ImplicitConversionSequence ICS =
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7441) TryCopyInitialization(*this, TheTemporaryCall, ToType,
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7442) /*SuppressUserConversions=*/true,
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7443) /*InOverloadResolution=*/false,
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 7444) /*AllowObjCWritebackConversion=*/false);
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7445)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7446) switch (ICS.getKind()) {
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7447) case ImplicitConversionSequence::StandardConversion:
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7448) Candidate.FinalConversion = ICS.Standard;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7449)
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7450) // C++ [over.ics.user]p3:
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7451) // If the user-defined conversion is specified by a specialization of a
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7452) // conversion function template, the second standard conversion sequence
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7453) // shall have exact match rank.
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7454) if (Conversion->getPrimaryTemplate() &&
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7455) GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) {
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7456) Candidate.Viable = false;
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7457) Candidate.FailureKind = ovl_fail_final_conversion_not_exact;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7458) return;
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 7459) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7460)
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7461) // C++0x [dcl.init.ref]p5:
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7462) // In the second case, if the reference is an rvalue reference and
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7463) // the second standard conversion sequence of the user-defined
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7464) // conversion sequence includes an lvalue-to-rvalue conversion, the
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7465) // program is ill-formed.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7466) if (ToType->isRValueReferenceType() &&
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7467) ICS.Standard.First == ICK_Lvalue_To_Rvalue) {
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7468) Candidate.Viable = false;
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7469) Candidate.FailureKind = ovl_fail_bad_final_conversion;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7470) return;
+cba72b1f620fd (Douglas Gregor 2011-01-21 05:18:22 +0000 7471) }
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7472) break;
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7473)
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7474) case ImplicitConversionSequence::BadConversion:
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7475) Candidate.Viable = false;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 7476) Candidate.FailureKind = ovl_fail_bad_final_conversion;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7477) return;
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7478)
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7479) default:
+83d382b1cad13 (David Blaikie 2011-09-23 05:06:16 +0000 7480) llvm_unreachable(
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7481) "Can only end up with a standard conversion sequence or failure");
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7482) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7483)
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 7484) if (EnableIfAttr *FailedAttr =
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 7485) CheckEnableIf(Conversion, CandidateSet.getLocation(), None)) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7486) Candidate.Viable = false;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7487) Candidate.FailureKind = ovl_fail_enable_if;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7488) Candidate.DeductionFailure.Data = FailedAttr;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7489) return;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7490) }
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7491)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 7492) if (Conversion->isMultiVersion() && Conversion->hasAttr<TargetAttr>() &&
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7493) !Conversion->getAttr<TargetAttr>()->isDefaultVersion()) {
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7494) Candidate.Viable = false;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7495) Candidate.FailureKind = ovl_non_default_multiversion_function;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 7496) }
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7497) }
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 7498)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7499) /// Adds a conversion function template specialization
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7500) /// candidate to the overload set, using template argument deduction
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7501) /// to deduce the template arguments of the conversion function
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7502) /// template from the type that we are converting to (C++
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7503) /// [temp.deduct.conv]).
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7504) void Sema::AddTemplateConversionCandidate(
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7505) FunctionTemplateDecl *FunctionTemplate, DeclAccessPair FoundDecl,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7506) CXXRecordDecl *ActingDC, Expr *From, QualType ToType,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7507) OverloadCandidateSet &CandidateSet, bool AllowObjCConversionOnExplicit,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7508) bool AllowExplicit, bool AllowResultConversion) {
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7509) assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) &&
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7510) "Only conversion function templates permitted here");
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7511)
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7512) if (!CandidateSet.isNewCandidate(FunctionTemplate))
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7513) return;
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7514)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7515) // If the function template has a non-dependent explicit specification,
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7516) // exclude it now if appropriate; we are not permitted to perform deduction
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7517) // and substitution in this case.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7518) if (!AllowExplicit && isNonDependentlyExplicit(FunctionTemplate)) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7519) OverloadCandidate &Candidate = CandidateSet.addCandidate();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7520) Candidate.FoundDecl = FoundDecl;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7521) Candidate.Function = FunctionTemplate->getTemplatedDecl();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7522) Candidate.Viable = false;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7523) Candidate.FailureKind = ovl_fail_explicit;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7524) return;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7525) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 7526)
+e6706e40bb692 (Craig Topper 2012-09-19 02:26:47 +0000 7527) TemplateDeductionInfo Info(CandidateSet.getLocation());
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 7528) CXXConversionDecl *Specialization = nullptr;
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7529) if (TemplateDeductionResult Result
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7530) = DeduceTemplateArguments(FunctionTemplate, ToType,
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7531) Specialization, Info)) {
+fb761ff54452f (Benjamin Kramer 2012-01-14 16:31:55 +0000 7532) OverloadCandidate &Candidate = CandidateSet.addCandidate();
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7533) Candidate.FoundDecl = FoundDecl;
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7534) Candidate.Function = FunctionTemplate->getTemplatedDecl();
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7535) Candidate.Viable = false;
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7536) Candidate.FailureKind = ovl_fail_bad_deduction;
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7537) Candidate.IsSurrogate = false;
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7538) Candidate.IgnoreObjectArgument = false;
+6edd977c6f368 (Douglas Gregor 2011-01-19 23:54:39 +0000 7539) Candidate.ExplicitCallArguments = 1;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7540) Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result,
+90cf2c98bbca9 (Douglas Gregor 2010-05-08 20:18:54 +0000 7541) Info);
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7542) return;
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7543) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7544)
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7545) // Add the conversion function template specialization produced by
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7546) // template argument deduction as a candidate.
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7547) assert(Specialization && "Missing function template specialization?");
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7548) AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType,
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 7549) CandidateSet, AllowObjCConversionOnExplicit,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 7550) AllowExplicit, AllowResultConversion);
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7551) }
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 7552)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7553) /// AddSurrogateCandidate - Adds a "surrogate" candidate function that
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7554) /// converts the given @c Object to a function pointer via the
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7555) /// conversion function @c Conversion, and then attempts to call it
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7556) /// with the given arguments (C++ [over.call.object]p2-4). Proto is
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7557) /// the type of function that we'll eventually be calling.
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7558) void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion,
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7559) DeclAccessPair FoundDecl,
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 7560) CXXRecordDecl *ActingContext,
+deaad8cc34239 (Douglas Gregor 2009-02-26 23:50:07 +0000 7561) const FunctionProtoType *Proto,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 7562) Expr *Object,
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 7563) ArrayRef<Expr *> Args,
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7564) OverloadCandidateSet& CandidateSet) {
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7565) if (!CandidateSet.isNewCandidate(Conversion))
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7566) return;
+5b0f2a2fbe3ac (Douglas Gregor 2009-09-28 04:47:19 +0000 7567)
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 7568) // Overload resolution is always an unevaluated context.
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7569) EnterExpressionEvaluationContext Unevaluated(
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7570) *this, Sema::ExpressionEvaluationContext::Unevaluated);
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 7571)
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 7572) OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size() + 1);
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7573) Candidate.FoundDecl = FoundDecl;
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 7574) Candidate.Function = nullptr;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7575) Candidate.Surrogate = Conversion;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7576) Candidate.Viable = true;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7577) Candidate.IsSurrogate = true;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 7578) Candidate.IgnoreObjectArgument = false;
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 7579) Candidate.ExplicitCallArguments = Args.size();
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7580)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7581) // Determine the implicit conversion sequence for the implicit
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7582) // object parameter.
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7583) ImplicitConversionSequence ObjectInit = TryObjectArgumentInitialization(
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7584) *this, CandidateSet.getLocation(), Object->getType(),
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 7585) Object->Classify(Context), Conversion, ActingContext);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7586) if (ObjectInit.isBad()) {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7587) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7588) Candidate.FailureKind = ovl_fail_bad_conversion;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 7589) Candidate.Conversions[0] = ObjectInit;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7590) return;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7591) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7592)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7593) // The first conversion is actually a user-defined conversion whose
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7594) // first conversion is ObjectInit's standard conversion (which is
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7595) // effectively a reference binding). Record it as such.
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7596) Candidate.Conversions[0].setUserDefined();
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7597) Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard;
+5582451e914f4 (Fariborz Jahanian 2009-11-06 00:23:08 +0000 7598) Candidate.Conversions[0].UserDefined.EllipsisConversion = false;
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 7599) Candidate.Conversions[0].UserDefined.HadMultipleCandidates = false;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7600) Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion;
+30909031a7f76 (John McCall 2011-09-21 08:36:56 +0000 7601) Candidate.Conversions[0].UserDefined.FoundConversionFunction = FoundDecl;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7602) Candidate.Conversions[0].UserDefined.After
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7603) = Candidate.Conversions[0].UserDefined.Before;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7604) Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion();
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7605)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7606) // Find the
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 7607) unsigned NumParams = Proto->getNumParams();
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7608)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7609) // (C++ 13.3.2p2): A candidate function having fewer than m
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7610) // parameters is viable only if it has an ellipsis in its parameter
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7611) // list (8.3.5).
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 7612) if (Args.size() > NumParams && !Proto->isVariadic()) {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7613) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7614) Candidate.FailureKind = ovl_fail_too_many_arguments;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7615) return;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7616) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7617)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7618) // Function types don't have any default arguments, so just check if
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7619) // we have enough arguments.
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 7620) if (Args.size() < NumParams) {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7621) // Not enough arguments.
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7622) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7623) Candidate.FailureKind = ovl_fail_too_few_arguments;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7624) return;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7625) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7626)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7627) // Determine the implicit conversion sequences for each of the
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7628) // arguments.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 7629) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 7630) if (ArgIdx < NumParams) {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7631) // (C++ 13.3.2p3): for F to be a viable function, there shall
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7632) // exist for each argument an implicit conversion sequence
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7633) // (13.3.3.1) that converts that argument to the corresponding
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7634) // parameter of F.
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 7635) QualType ParamType = Proto->getParamType(ArgIdx);
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7636) Candidate.Conversions[ArgIdx + 1]
+cb13cfc878200 (Douglas Gregor 2010-04-16 17:51:22 +0000 7637) = TryCopyInitialization(*this, Args[ArgIdx], ParamType,
+03068aa0777d7 (Anders Carlsson 2009-08-27 17:18:13 +0000 7638) /*SuppressUserConversions=*/false,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 7639) /*InOverloadResolution=*/false,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 7640) /*AllowObjCWritebackConversion=*/
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 7641) getLangOpts().ObjCAutoRefCount);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7642) if (Candidate.Conversions[ArgIdx + 1].isBad()) {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7643) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7644) Candidate.FailureKind = ovl_fail_bad_conversion;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7645) return;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7646) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7647) } else {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7648) // (C++ 13.3.2p2): For the purposes of overload resolution, any
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7649) // argument for which there is no corresponding parameter is
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7650) // considered to ""match the ellipsis" (C+ 13.3.3.1.3).
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7651) Candidate.Conversions[ArgIdx + 1].setEllipsis();
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7652) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7653) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7654)
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 7655) if (EnableIfAttr *FailedAttr =
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 7656) CheckEnableIf(Conversion, CandidateSet.getLocation(), None)) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7657) Candidate.Viable = false;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7658) Candidate.FailureKind = ovl_fail_enable_if;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7659) Candidate.DeductionFailure.Data = FailedAttr;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7660) return;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 7661) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7662) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 7663)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7664) /// Add all of the non-member operator function declarations in the given
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7665) /// function set to the overload candidate set.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7666) void Sema::AddNonMemberOperatorCandidates(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7667) const UnresolvedSetImpl &Fns, ArrayRef<Expr *> Args,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7668) OverloadCandidateSet &CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7669) TemplateArgumentListInfo *ExplicitTemplateArgs) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7670) for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7671) NamedDecl *D = F.getDecl()->getUnderlyingDecl();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7672) ArrayRef<Expr *> FunctionArgs = Args;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7673)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7674) FunctionTemplateDecl *FunTmpl = dyn_cast<FunctionTemplateDecl>(D);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7675) FunctionDecl *FD =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7676) FunTmpl ? FunTmpl->getTemplatedDecl() : cast<FunctionDecl>(D);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7677)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7678) // Don't consider rewritten functions if we're not rewriting.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7679) if (!CandidateSet.getRewriteInfo().isAcceptableCandidate(FD))
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7680) continue;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7681)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7682) assert(!isa<CXXMethodDecl>(FD) &&
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7683) "unqualified operator lookup found a member function");
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7684)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7685) if (FunTmpl) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7686) AddTemplateOverloadCandidate(FunTmpl, F.getPair(), ExplicitTemplateArgs,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7687) FunctionArgs, CandidateSet);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7688) if (CandidateSet.getRewriteInfo().shouldAddReversed(Context, FD))
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7689) AddTemplateOverloadCandidate(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7690) FunTmpl, F.getPair(), ExplicitTemplateArgs,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7691) {FunctionArgs[1], FunctionArgs[0]}, CandidateSet, false, false,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7692) true, ADLCallKind::NotADL, OverloadCandidateParamOrder::Reversed);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7693) } else {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7694) if (ExplicitTemplateArgs)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7695) continue;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7696) AddOverloadCandidate(FD, F.getPair(), FunctionArgs, CandidateSet);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7697) if (CandidateSet.getRewriteInfo().shouldAddReversed(Context, FD))
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7698) AddOverloadCandidate(FD, F.getPair(),
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7699) {FunctionArgs[1], FunctionArgs[0]}, CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7700) false, false, true, false, ADLCallKind::NotADL,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7701) None, OverloadCandidateParamOrder::Reversed);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7702) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7703) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7704) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7705)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7706) /// Add overload candidates for overloaded operators that are
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7707) /// member functions.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7708) ///
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7709) /// Add the overloaded operator candidates that are member functions
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7710) /// for the operator Op that was used in an operator expression such
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7711) /// as "x Op y". , Args/NumArgs provides the operator arguments, and
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7712) /// CandidateSet will store the added overload candidates. (C++
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7713) /// [over.match.oper]).
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7714) void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op,
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 7715) SourceLocation OpLoc,
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 7716) ArrayRef<Expr *> Args,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7717) OverloadCandidateSet &CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7718) OverloadCandidateParamOrder PO) {
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7719) DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7720)
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7721) // C++ [over.match.oper]p3:
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7722) // For a unary operator @ with an operand of a type whose
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7723) // cv-unqualified version is T1, and for a binary operator @ with
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7724) // a left operand of a type whose cv-unqualified version is T1 and
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7725) // a right operand of a type whose cv-unqualified version is T2,
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7726) // three sets of candidate functions, designated member
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7727) // candidates, non-member candidates and built-in candidates, are
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7728) // constructed as follows:
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7729) QualType T1 = Args[0]->getType();
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7730)
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7731) // -- If T1 is a complete class type or a class currently being
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7732) // defined, the set of member candidates is the result of the
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7733) // qualified lookup of T1::operator@ (13.3.1.1.1); otherwise,
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7734) // the set of member candidates is empty.
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 7735) if (const RecordType *T1Rec = T1->getAs<RecordType>()) {
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7736) // Complete the type if it can be completed.
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 7737) if (!isCompleteType(OpLoc, T1) && !T1Rec->isBeingDefined())
+82b8d4e6fd79e (Richard Smith 2015-12-18 22:19:11 +0000 7738) return;
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7739) // If the type is neither complete nor being defined, bail out now.
+0feaf0c7e3e13 (Richard Smith 2013-04-20 12:41:22 +0000 7740) if (!T1Rec->getDecl()->getDefinition())
+6a1f965853df1 (Douglas Gregor 2009-08-27 23:35:55 +0000 7741) return;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7742)
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 7743) LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName);
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 7744) LookupQualifiedName(Operators, T1Rec->getDecl());
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 7745) Operators.suppressDiagnostics();
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 7746)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7747) for (LookupResult::iterator Oper = Operators.begin(),
+6a1f965853df1 (Douglas Gregor 2009-08-27 23:35:55 +0000 7748) OperEnd = Operators.end();
+6a1f965853df1 (Douglas Gregor 2009-08-27 23:35:55 +0000 7749) Oper != OperEnd;
+f0f1cf087e704 (John McCall 2009-11-17 07:50:12 +0000 7750) ++Oper)
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 7751) AddMethodCandidate(Oper.getPair(), Args[0]->getType(),
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 7752) Args[0]->Classify(Context), Args.slice(1),
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 7753) CandidateSet, /*SuppressUserConversion=*/false, PO);
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7754) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7755) }
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7756)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7757) /// AddBuiltinCandidate - Add a candidate for a built-in
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7758) /// operator. ResultTy and ParamTys are the result and parameter types
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7759) /// of the built-in candidate, respectively. Args and NumArgs are the
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7760) /// arguments being passed to the candidate. IsAssignmentOperator
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7761) /// should be true when this built-in candidate is an assignment
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7762) /// operator. NumContextualBoolArguments is the number of arguments
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7763) /// (at the beginning of the argument list) that will be contextually
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7764) /// converted to bool.
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 7765) void Sema::AddBuiltinCandidate(QualType *ParamTys, ArrayRef<Expr *> Args,
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7766) OverloadCandidateSet& CandidateSet,
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7767) bool IsAssignmentOperator,
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7768) unsigned NumContextualBoolArguments) {
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 7769) // Overload resolution is always an unevaluated context.
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7770) EnterExpressionEvaluationContext Unevaluated(
+d143a0c2de131 (Faisal Vali 2017-04-01 21:30:49 +0000 7771) *this, Sema::ExpressionEvaluationContext::Unevaluated);
+27381f3d93454 (Douglas Gregor 2009-11-23 12:27:39 +0000 7772)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7773) // Add this candidate
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 7774) OverloadCandidate &Candidate = CandidateSet.addCandidate(Args.size());
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 7775) Candidate.FoundDecl = DeclAccessPair::make(nullptr, AS_none);
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 7776) Candidate.Function = nullptr;
+1d248c53ab1c5 (Douglas Gregor 2008-12-12 02:00:36 +0000 7777) Candidate.IsSurrogate = false;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 7778) Candidate.IgnoreObjectArgument = false;
+5f6ab9a8bf307 (George Burgess IV 2017-06-08 20:55:21 +0000 7779) std::copy(ParamTys, ParamTys + Args.size(), Candidate.BuiltinParamTypes);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7780)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7781) // Determine the implicit conversion sequences for each of the
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7782) // arguments.
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7783) Candidate.Viable = true;
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 7784) Candidate.ExplicitCallArguments = Args.size();
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 7785) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7786) // C++ [over.match.oper]p4:
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7787) // For the built-in assignment operators, conversions of the
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7788) // left operand are restricted as follows:
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7789) // -- no temporaries are introduced to hold the left operand, and
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7790) // -- no user-defined conversions are applied to the left
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7791) // operand to achieve a type match with the left-most
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7792) // parameter of a built-in candidate.
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7793) //
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7794) // We block these conversions by turning off user-defined
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7795) // conversions, since that is the only way that initialization of
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7796) // a reference to a non-class type can occur from something that
+c5e61070f6d1b (Douglas Gregor 2009-01-13 00:52:54 +0000 7797) // is not of the same type.
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7798) if (ArgIdx < NumContextualBoolArguments) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7799) assert(ParamTys[ArgIdx] == Context.BoolTy &&
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7800) "Contextual conversion to bool requires bool type");
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 7801) Candidate.Conversions[ArgIdx]
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 7802) = TryContextuallyConvertToBool(*this, Args[ArgIdx]);
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7803) } else {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7804) Candidate.Conversions[ArgIdx]
+cb13cfc878200 (Douglas Gregor 2010-04-16 17:51:22 +0000 7805) = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx],
+03068aa0777d7 (Anders Carlsson 2009-08-27 17:18:13 +0000 7806) ArgIdx == 0 && IsAssignmentOperator,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 7807) /*InOverloadResolution=*/false,
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 7808) /*AllowObjCWritebackConversion=*/
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 7809) getLangOpts().ObjCAutoRefCount);
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 7810) }
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 7811) if (Candidate.Conversions[ArgIdx].isBad()) {
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7812) Candidate.Viable = false;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 7813) Candidate.FailureKind = ovl_fail_bad_conversion;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7814) break;
+436424cfa5855 (Douglas Gregor 2008-11-18 23:14:02 +0000 7815) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7816) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7817) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7818)
+cd7b03342d936 (Craig Topper 2013-07-01 06:29:40 +0000 7819) namespace {
+cd7b03342d936 (Craig Topper 2013-07-01 06:29:40 +0000 7820)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7821) /// BuiltinCandidateTypeSet - A set of types that will be used for the
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7822) /// candidate operator functions for built-in operators (C++
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7823) /// [over.built]). The types are separated into pointer types and
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7824) /// enumeration types.
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7825) class BuiltinCandidateTypeSet {
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7826) /// TypeSet - A set of types.
+95853077c3f3f (Richard Smith 2016-03-25 00:08:53 +0000 7827) typedef llvm::SetVector<QualType, SmallVector<QualType, 8>,
+95853077c3f3f (Richard Smith 2016-03-25 00:08:53 +0000 7828) llvm::SmallPtrSet<QualType, 8>> TypeSet;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7829)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7830) /// PointerTypes - The set of pointer types that will be used in the
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7831) /// built-in candidates.
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7832) TypeSet PointerTypes;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7833)
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7834) /// MemberPointerTypes - The set of member pointer types that will be
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7835) /// used in the built-in candidates.
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7836) TypeSet MemberPointerTypes;
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7837)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7838) /// EnumerationTypes - The set of enumeration types that will be
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7839) /// used in the built-in candidates.
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7840) TypeSet EnumerationTypes;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7841)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7842) /// The set of vector types that will be used in the built-in
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 7843) /// candidates.
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 7844) TypeSet VectorTypes;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7845)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7846) /// The set of matrix types that will be used in the built-in
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7847) /// candidates.
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7848) TypeSet MatrixTypes;
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7849)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7850) /// A flag indicating non-record types are viable candidates
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7851) bool HasNonRecordTypes;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7852)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7853) /// A flag indicating whether either arithmetic or enumeration types
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7854) /// were present in the candidate set.
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7855) bool HasArithmeticOrEnumeralTypes;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7856)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 7857) /// A flag indicating whether the nullptr type was present in the
+80af31397acee (Douglas Gregor 2011-05-21 23:15:46 +0000 7858) /// candidate set.
+80af31397acee (Douglas Gregor 2011-05-21 23:15:46 +0000 7859) bool HasNullPtrType;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7860)
+8a2e601917708 (Douglas Gregor 2009-08-24 15:23:48 +0000 7861) /// Sema - The semantic analysis instance where we are building the
+8a2e601917708 (Douglas Gregor 2009-08-24 15:23:48 +0000 7862) /// candidate type set.
+8a2e601917708 (Douglas Gregor 2009-08-24 15:23:48 +0000 7863) Sema &SemaRef;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7864)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7865) /// Context - The AST context in which we will build the type sets.
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7866) ASTContext &Context;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7867)
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 7868) bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 7869) const Qualifiers &VisibleQuals);
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7870) bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7871)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7872) public:
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7873) /// iterator - Iterates through the types that are part of the set.
+a59a3e2d10626 (Chris Lattner 2009-03-29 00:04:01 +0000 7874) typedef TypeSet::iterator iterator;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7875)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 7876) BuiltinCandidateTypeSet(Sema &SemaRef)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7877) : HasNonRecordTypes(false),
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7878) HasArithmeticOrEnumeralTypes(false),
+80af31397acee (Douglas Gregor 2011-05-21 23:15:46 +0000 7879) HasNullPtrType(false),
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7880) SemaRef(SemaRef),
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7881) Context(SemaRef.Context) { }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7882)
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7883) void AddTypesConvertedFrom(QualType Ty,
+c02cfe2a55e13 (Douglas Gregor 2009-10-21 23:19:44 +0000 7884) SourceLocation Loc,
+c02cfe2a55e13 (Douglas Gregor 2009-10-21 23:19:44 +0000 7885) bool AllowUserConversions,
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 7886) bool AllowExplicitConversions,
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 7887) const Qualifiers &VisibleTypeConversionsQuals);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7888)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7889) llvm::iterator_range<iterator> pointer_types() { return PointerTypes; }
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7890) llvm::iterator_range<iterator> member_pointer_types() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7891) return MemberPointerTypes;
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7892) }
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7893) llvm::iterator_range<iterator> enumeration_types() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7894) return EnumerationTypes;
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 7895) }
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 7896) llvm::iterator_range<iterator> vector_types() { return VectorTypes; }
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7897) llvm::iterator_range<iterator> matrix_types() { return MatrixTypes; }
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7898)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 7899) bool containsMatrixType(QualType Ty) const { return MatrixTypes.count(Ty); }
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7900) bool hasNonRecordTypes() { return HasNonRecordTypes; }
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 7901) bool hasArithmeticOrEnumeralTypes() { return HasArithmeticOrEnumeralTypes; }
+80af31397acee (Douglas Gregor 2011-05-21 23:15:46 +0000 7902) bool hasNullPtrType() const { return HasNullPtrType; }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7903) };
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7904)
+cd7b03342d936 (Craig Topper 2013-07-01 06:29:40 +0000 7905) } // end anonymous namespace
+cd7b03342d936 (Craig Topper 2013-07-01 06:29:40 +0000 7906)
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7907) /// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7908) /// the set of pointer types along with any more-qualified variants of
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7909) /// that type. For example, if @p Ty is "int const *", this routine
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7910) /// will add "int const *", "int const volatile *", "int const
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7911) /// restrict *", and "int const volatile restrict *" to the set of
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7912) /// pointer types. Returns true if the add of @p Ty itself succeeded,
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7913) /// false otherwise.
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7914) ///
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7915) /// FIXME: what to do about extended qualifiers?
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7916) bool
+c02cfe2a55e13 (Douglas Gregor 2009-10-21 23:19:44 +0000 7917) BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty,
+c02cfe2a55e13 (Douglas Gregor 2009-10-21 23:19:44 +0000 7918) const Qualifiers &VisibleQuals) {
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7919)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7920) // Insert this type.
+95853077c3f3f (Richard Smith 2016-03-25 00:08:53 +0000 7921) if (!PointerTypes.insert(Ty))
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7922) return false;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7923)
+e4151b590ef4b (Fariborz Jahanian 2010-08-21 00:10:36 +0000 7924) QualType PointeeTy;
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7925) const PointerType *PointerTy = Ty->getAs<PointerType>();
+f2afc804c32bc (Fariborz Jahanian 2010-08-21 17:11:09 +0000 7926) bool buildObjCPtr = false;
+e4151b590ef4b (Fariborz Jahanian 2010-08-21 00:10:36 +0000 7927) if (!PointerTy) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7928) const ObjCObjectPointerType *PTy = Ty->castAs<ObjCObjectPointerType>();
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7929) PointeeTy = PTy->getPointeeType();
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7930) buildObjCPtr = true;
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7931) } else {
+e4151b590ef4b (Fariborz Jahanian 2010-08-21 00:10:36 +0000 7932) PointeeTy = PointerTy->getPointeeType();
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7933) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7934)
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7935) // Don't add qualified variants of arrays. For one, they're not allowed
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7936) // (the qualifier would sink to the element type), and for another, the
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7937) // only overload situation where it matters is subscript or pointer +- int,
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7938) // and those shouldn't have qualifier variants anyway.
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7939) if (PointeeTy->isArrayType())
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7940) return true;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7941)
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7942) unsigned BaseCVR = PointeeTy.getCVRQualifiers();
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 7943) bool hasVolatile = VisibleQuals.hasVolatile();
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 7944) bool hasRestrict = VisibleQuals.hasRestrict();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 7945)
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7946) // Iterate through all strict supersets of BaseCVR.
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7947) for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7948) if ((CVR | BaseCVR) != CVR) continue;
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7949) // Skip over volatile if no volatile found anywhere in the types.
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 7950) if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7951)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7952) // Skip over restrict if no restrict found anywhere in the types, or if
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7953) // the type cannot be restrict-qualified.
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7954) if ((CVR & Qualifiers::Restrict) &&
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7955) (!hasRestrict ||
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7956) (!(PointeeTy->isAnyPointerType() || PointeeTy->isReferenceType()))))
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7957) continue;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7958)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7959) // Build qualified pointee type.
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7960) QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7961)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7962) // Build qualified pointer type.
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7963) QualType QPointerTy;
+f2afc804c32bc (Fariborz Jahanian 2010-08-21 17:11:09 +0000 7964) if (!buildObjCPtr)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7965) QPointerTy = Context.getPointerType(QPointeeTy);
+f2afc804c32bc (Fariborz Jahanian 2010-08-21 17:11:09 +0000 7966) else
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7967) QPointerTy = Context.getObjCObjectPointerType(QPointeeTy);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 7968)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7969) // Insert qualified pointer type.
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 7970) PointerTypes.insert(QPointerTy);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7971) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7972)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7973) return true;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7974) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 7975)
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7976) /// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7977) /// to the set of pointer types along with any more-qualified variants of
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7978) /// that type. For example, if @p Ty is "int const *", this routine
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7979) /// will add "int const *", "int const volatile *", "int const
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7980) /// restrict *", and "int const volatile restrict *" to the set of
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7981) /// pointer types. Returns true if the add of @p Ty itself succeeded,
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7982) /// false otherwise.
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7983) ///
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7984) /// FIXME: what to do about extended qualifiers?
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7985) bool
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7986) BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants(
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7987) QualType Ty) {
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7988) // Insert this type.
+95853077c3f3f (Richard Smith 2016-03-25 00:08:53 +0000 7989) if (!MemberPointerTypes.insert(Ty))
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7990) return false;
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 7991)
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7992) const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>();
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7993) assert(PointerTy && "type was not a member pointer type!");
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7994)
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 7995) QualType PointeeTy = PointerTy->getPointeeType();
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7996) // Don't add qualified variants of arrays. For one, they're not allowed
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7997) // (the qualifier would sink to the element type), and for another, the
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7998) // only overload situation where it matters is subscript or pointer +- int,
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 7999) // and those shouldn't have qualifier variants anyway.
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 8000) if (PointeeTy->isArrayType())
+4990a6347a3a8 (Sebastian Redl 2009-11-18 20:39:26 +0000 8001) return true;
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8002) const Type *ClassTy = PointerTy->getClass();
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8003)
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8004) // Iterate through all strict supersets of the pointee type's CVR
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8005) // qualifiers.
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8006) unsigned BaseCVR = PointeeTy.getCVRQualifiers();
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8007) for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) {
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8008) if ((CVR | BaseCVR) != CVR) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 8009)
+8ccfcb51ee020 (John McCall 2009-09-24 19:53:00 +0000 8010) QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR);
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 8011) MemberPointerTypes.insert(
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 8012) Context.getMemberPointerType(QPointeeTy, ClassTy));
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8013) }
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8014)
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8015) return true;
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8016) }
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8017)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8018) /// AddTypesConvertedFrom - Add each of the types to which the type @p
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8019) /// Ty can be implicit converted to the given set of @p Types. We're
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8020) /// primarily interested in pointer types and enumeration types. We also
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8021) /// take member pointer types, for the conditional operator.
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 8022) /// AllowUserConversions is true if we should look at the conversion
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 8023) /// functions of a class type, and AllowExplicitConversions if we
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 8024) /// should also include the explicit conversion functions of a class
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 8025) /// type.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8026) void
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 8027) BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
+c02cfe2a55e13 (Douglas Gregor 2009-10-21 23:19:44 +0000 8028) SourceLocation Loc,
+5fb53972380f5 (Douglas Gregor 2009-01-14 15:45:31 +0000 8029) bool AllowUserConversions,
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8030) bool AllowExplicitConversions,
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8031) const Qualifiers &VisibleQuals) {
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8032) // Only deal with canonical types.
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8033) Ty = Context.getCanonicalType(Ty);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8034)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8035) // Look through reference types; they aren't part of the type of an
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8036) // expression for the purposes of conversions.
+c23c7e6a51927 (Ted Kremenek 2009-07-29 21:53:49 +0000 8037) if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>())
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8038) Ty = RefTy->getPointeeType();
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8039)
+33ddac05bba47 (John McCall 2011-01-19 10:06:00 +0000 8040) // If we're dealing with an array type, decay to the pointer.
+33ddac05bba47 (John McCall 2011-01-19 10:06:00 +0000 8041) if (Ty->isArrayType())
+33ddac05bba47 (John McCall 2011-01-19 10:06:00 +0000 8042) Ty = SemaRef.Context.getArrayDecayedType(Ty);
+33ddac05bba47 (John McCall 2011-01-19 10:06:00 +0000 8043)
+33ddac05bba47 (John McCall 2011-01-19 10:06:00 +0000 8044) // Otherwise, we don't care about qualifiers on the type.
+1b8fe5b716b8b (Douglas Gregor 2009-11-16 21:35:15 +0000 8045) Ty = Ty.getLocalUnqualifiedType();
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8046)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8047) // Flag if we ever add a non-record type.
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8048) const RecordType *TyRec = Ty->getAs<RecordType>();
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8049) HasNonRecordTypes = HasNonRecordTypes || !TyRec;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8050)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8051) // Flag if we encounter an arithmetic type.
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8052) HasArithmeticOrEnumeralTypes =
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8053) HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8054)
+e4151b590ef4b (Fariborz Jahanian 2010-08-21 00:10:36 +0000 8055) if (Ty->isObjCIdType() || Ty->isObjCClassType())
+e4151b590ef4b (Fariborz Jahanian 2010-08-21 00:10:36 +0000 8056) PointerTypes.insert(Ty);
+e4151b590ef4b (Fariborz Jahanian 2010-08-21 00:10:36 +0000 8057) else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8058) // Insert our type, and its more-qualified variants, into the set
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8059) // of types.
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 8060) if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8061) return;
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8062) } else if (Ty->isMemberPointerType()) {
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8063) // Member pointers are far easier, since the pointee can't be converted.
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8064) if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty))
+8ce189f9cefc4 (Sebastian Redl 2009-04-19 21:53:20 +0000 8065) return;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8066) } else if (Ty->isEnumeralType()) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8067) HasArithmeticOrEnumeralTypes = true;
+a59a3e2d10626 (Chris Lattner 2009-03-29 00:04:01 +0000 8068) EnumerationTypes.insert(Ty);
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8069) } else if (Ty->isVectorType()) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8070) // We treat vector types as arithmetic types in many contexts as an
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8071) // extension.
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8072) HasArithmeticOrEnumeralTypes = true;
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8073) VectorTypes.insert(Ty);
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8074) } else if (Ty->isMatrixType()) {
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8075) // Similar to vector types, we treat vector types as arithmetic types in
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8076) // many contexts as an extension.
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8077) HasArithmeticOrEnumeralTypes = true;
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8078) MatrixTypes.insert(Ty);
+80af31397acee (Douglas Gregor 2011-05-21 23:15:46 +0000 8079) } else if (Ty->isNullPtrType()) {
+80af31397acee (Douglas Gregor 2011-05-21 23:15:46 +0000 8080) HasNullPtrType = true;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8081) } else if (AllowUserConversions && TyRec) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8082) // No conversion functions in incomplete types.
+db0ac5572fcf7 (Richard Smith 2015-12-18 22:40:25 +0000 8083) if (!SemaRef.isCompleteType(Loc, Ty))
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8084) return;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8085)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8086) CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 8087) for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8088) if (isa<UsingShadowDecl>(D))
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8089) D = cast<UsingShadowDecl>(D)->getTargetDecl();
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 8090)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8091) // Skip conversion function templates; they don't tell us anything
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8092) // about which builtin types we can convert to.
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8093) if (isa<FunctionTemplateDecl>(D))
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8094) continue;
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 8095)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8096) CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8097) if (AllowExplicitConversions || !Conv->isExplicit()) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8098) AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false,
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8099) VisibleQuals);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8100) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8101) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8102) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8103) }
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8104) /// Helper function for adjusting address spaces for the pointer or reference
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8105) /// operands of builtin operators depending on the argument.
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8106) static QualType AdjustAddressSpaceForBuiltinOperandType(Sema &S, QualType T,
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8107) Expr *Arg) {
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8108) return S.Context.getAddrSpaceQualType(T, Arg->getType().getAddressSpace());
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8109) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8110)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 8111) /// Helper function for AddBuiltinOperatorCandidates() that adds
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8112) /// the volatile- and non-volatile-qualified assignment operators for the
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8113) /// given type to the candidate set.
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8114) static void AddBuiltinAssignmentOperatorCandidates(Sema &S,
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8115) QualType T,
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8116) ArrayRef<Expr *> Args,
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8117) OverloadCandidateSet &CandidateSet) {
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8118) QualType ParamTypes[2];
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8119)
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8120) // T& operator=(T&, T)
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8121) ParamTypes[0] = S.Context.getLValueReferenceType(
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8122) AdjustAddressSpaceForBuiltinOperandType(S, T, Args[0]));
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8123) ParamTypes[1] = T;
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8124) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8125) /*IsAssignmentOperator=*/true);
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8126)
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8127) if (!S.Context.getCanonicalType(T).isVolatileQualified()) {
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8128) // volatile T& operator=(volatile T&, T)
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8129) ParamTypes[0] = S.Context.getLValueReferenceType(
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8130) AdjustAddressSpaceForBuiltinOperandType(S, S.Context.getVolatileType(T),
+27e5c212ee42b (Anastasia Stulova 2019-03-07 16:43:41 +0000 8131) Args[0]));
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8132) ParamTypes[1] = T;
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8133) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8134) /*IsAssignmentOperator=*/true);
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8135) }
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8136) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8137)
+1054faed320dd (Sebastian Redl 2009-10-25 17:03:50 +0000 8138) /// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers,
+1054faed320dd (Sebastian Redl 2009-10-25 17:03:50 +0000 8139) /// if any, found in visible type conversion functions found in ArgExpr's type.
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8140) static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) {
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8141) Qualifiers VRQuals;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8142) const RecordType *TyRec;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8143) if (const MemberPointerType *RHSMPType =
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8144) ArgExpr->getType()->getAs<MemberPointerType>())
+d0ace024965bb (Douglas Gregor 2010-04-25 00:55:24 +0000 8145) TyRec = RHSMPType->getClass()->getAs<RecordType>();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8146) else
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8147) TyRec = ArgExpr->getType()->getAs<RecordType>();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8148) if (!TyRec) {
+b06ec054fc550 (Fariborz Jahanian 2009-10-16 22:08:05 +0000 8149) // Just to be safe, assume the worst case.
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8150) VRQuals.addVolatile();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8151) VRQuals.addRestrict();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8152) return VRQuals;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8153) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 8154)
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8155) CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl());
+67da35c832e66 (John McCall 2010-02-04 22:26:26 +0000 8156) if (!ClassDecl->hasDefinition())
+67da35c832e66 (John McCall 2010-02-04 22:26:26 +0000 8157) return VRQuals;
+67da35c832e66 (John McCall 2010-02-04 22:26:26 +0000 8158)
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 8159) for (NamedDecl *D : ClassDecl->getVisibleConversionFunctions()) {
+da4458e98f54c (John McCall 2010-03-31 01:36:47 +0000 8160) if (isa<UsingShadowDecl>(D))
+da4458e98f54c (John McCall 2010-03-31 01:36:47 +0000 8161) D = cast<UsingShadowDecl>(D)->getTargetDecl();
+da4458e98f54c (John McCall 2010-03-31 01:36:47 +0000 8162) if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) {
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8163) QualType CanTy = Context.getCanonicalType(Conv->getConversionType());
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8164) if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>())
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8165) CanTy = ResTypeRef->getPointeeType();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8166) // Need to go down the pointer/mempointer chain and add qualifiers
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8167) // as see them.
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8168) bool done = false;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8169) while (!done) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8170) if (CanTy.isRestrictQualified())
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8171) VRQuals.addRestrict();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8172) if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>())
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8173) CanTy = ResTypePtr->getPointeeType();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 8174) else if (const MemberPointerType *ResTypeMPtr =
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8175) CanTy->getAs<MemberPointerType>())
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8176) CanTy = ResTypeMPtr->getPointeeType();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8177) else
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8178) done = true;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8179) if (CanTy.isVolatileQualified())
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8180) VRQuals.addVolatile();
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8181) if (VRQuals.hasRestrict() && VRQuals.hasVolatile())
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8182) return VRQuals;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8183) }
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8184) }
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8185) }
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8186) return VRQuals;
+3b937fa298ce6 (Fariborz Jahanian 2009-10-15 17:14:05 +0000 8187) }
+528729872ed9c (John McCall 2010-11-13 05:51:15 +0000 8188)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8189) namespace {
+528729872ed9c (John McCall 2010-11-13 05:51:15 +0000 8190)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 8191) /// Helper class to manage the addition of builtin operator overload
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8192) /// candidates. It provides shared state and utility methods used throughout
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8193) /// the process, as well as a helper method to add each group of builtin
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8194) /// operator overloads from the standard to a candidate set.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8195) class BuiltinOperatorOverloadBuilder {
+c6586e52a9640 (Chandler Carruth 2010-12-12 10:35:00 +0000 8196) // Common instance state available to all overload candidate addition methods.
+c6586e52a9640 (Chandler Carruth 2010-12-12 10:35:00 +0000 8197) Sema &S;
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8198) ArrayRef<Expr *> Args;
+c6586e52a9640 (Chandler Carruth 2010-12-12 10:35:00 +0000 8199) Qualifiers VisibleTypeConversionsQuals;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8200) bool HasArithmeticOrEnumeralCandidateType;
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 8201) SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes;
+c6586e52a9640 (Chandler Carruth 2010-12-12 10:35:00 +0000 8202) OverloadCandidateSet &CandidateSet;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8203)
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8204) static constexpr int ArithmeticTypesCap = 24;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8205) SmallVector<CanQualType, ArithmeticTypesCap> ArithmeticTypes;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8206)
+f64918d092c07 (Nico Weber 2019-08-21 15:49:21 +0000 8207) // Define some indices used to iterate over the arithmetic types in
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8208) // ArithmeticTypes. The "promoted arithmetic types" are the arithmetic
+528729872ed9c (John McCall 2010-11-13 05:51:15 +0000 8209) // types are that preserved by promotion (C++ [over.built]p2).
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8210) unsigned FirstIntegralType,
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8211) LastIntegralType;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8212) unsigned FirstPromotedIntegralType,
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8213) LastPromotedIntegralType;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8214) unsigned FirstPromotedArithmeticType,
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8215) LastPromotedArithmeticType;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8216) unsigned NumArithmeticTypes;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8217)
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8218) void InitArithmeticTypes() {
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8219) // Start of promoted types.
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8220) FirstPromotedArithmeticType = 0;
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8221) ArithmeticTypes.push_back(S.Context.FloatTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8222) ArithmeticTypes.push_back(S.Context.DoubleTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8223) ArithmeticTypes.push_back(S.Context.LongDoubleTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8224) if (S.Context.getTargetInfo().hasFloat128Type())
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8225) ArithmeticTypes.push_back(S.Context.Float128Ty);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8226)
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8227) // Start of integral types.
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8228) FirstIntegralType = ArithmeticTypes.size();
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8229) FirstPromotedIntegralType = ArithmeticTypes.size();
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8230) ArithmeticTypes.push_back(S.Context.IntTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8231) ArithmeticTypes.push_back(S.Context.LongTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8232) ArithmeticTypes.push_back(S.Context.LongLongTy);
+f8d5b49c786f5 (Jennifer Yu 2020-12-04 14:54:12 -0800 8233) if (S.Context.getTargetInfo().hasInt128Type() ||
+f8d5b49c786f5 (Jennifer Yu 2020-12-04 14:54:12 -0800 8234) (S.Context.getAuxTargetInfo() &&
+f8d5b49c786f5 (Jennifer Yu 2020-12-04 14:54:12 -0800 8235) S.Context.getAuxTargetInfo()->hasInt128Type()))
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8236) ArithmeticTypes.push_back(S.Context.Int128Ty);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8237) ArithmeticTypes.push_back(S.Context.UnsignedIntTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8238) ArithmeticTypes.push_back(S.Context.UnsignedLongTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8239) ArithmeticTypes.push_back(S.Context.UnsignedLongLongTy);
+f8d5b49c786f5 (Jennifer Yu 2020-12-04 14:54:12 -0800 8240) if (S.Context.getTargetInfo().hasInt128Type() ||
+f8d5b49c786f5 (Jennifer Yu 2020-12-04 14:54:12 -0800 8241) (S.Context.getAuxTargetInfo() &&
+f8d5b49c786f5 (Jennifer Yu 2020-12-04 14:54:12 -0800 8242) S.Context.getAuxTargetInfo()->hasInt128Type()))
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8243) ArithmeticTypes.push_back(S.Context.UnsignedInt128Ty);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8244) LastPromotedIntegralType = ArithmeticTypes.size();
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8245) LastPromotedArithmeticType = ArithmeticTypes.size();
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8246) // End of promoted types.
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8247)
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8248) ArithmeticTypes.push_back(S.Context.BoolTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8249) ArithmeticTypes.push_back(S.Context.CharTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8250) ArithmeticTypes.push_back(S.Context.WCharTy);
+3a8244df6fb88 (Richard Smith 2018-05-01 05:02:45 +0000 8251) if (S.Context.getLangOpts().Char8)
+3a8244df6fb88 (Richard Smith 2018-05-01 05:02:45 +0000 8252) ArithmeticTypes.push_back(S.Context.Char8Ty);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8253) ArithmeticTypes.push_back(S.Context.Char16Ty);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8254) ArithmeticTypes.push_back(S.Context.Char32Ty);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8255) ArithmeticTypes.push_back(S.Context.SignedCharTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8256) ArithmeticTypes.push_back(S.Context.ShortTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8257) ArithmeticTypes.push_back(S.Context.UnsignedCharTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8258) ArithmeticTypes.push_back(S.Context.UnsignedShortTy);
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8259) LastIntegralType = ArithmeticTypes.size();
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8260) NumArithmeticTypes = ArithmeticTypes.size();
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8261) // End of integral types.
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8262) // FIXME: What about complex? What about half?
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8263)
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8264) assert(ArithmeticTypes.size() <= ArithmeticTypesCap &&
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8265) "Enough inline storage for all arithmetic types.");
+c6586e52a9640 (Chandler Carruth 2010-12-12 10:35:00 +0000 8266) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8267)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 8268) /// Helper method to factor out the common pattern of adding overloads
+5659c0c480d4b (Chandler Carruth 2010-12-12 09:22:45 +0000 8269) /// for '++' and '--' builtin operators.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8270) void addPlusPlusMinusMinusStyleOverloads(QualType CandidateTy,
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8271) bool HasVolatile,
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8272) bool HasRestrict) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8273) QualType ParamTypes[2] = {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8274) S.Context.getLValueReferenceType(CandidateTy),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8275) S.Context.IntTy
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8276) };
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8277)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8278) // Non-volatile version.
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8279) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8280)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8281) // Use a heuristic to reduce number of builtin candidates in the set:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8282) // add volatile version only if there are conversions to a volatile type.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8283) if (HasVolatile) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8284) ParamTypes[0] =
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8285) S.Context.getLValueReferenceType(
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8286) S.Context.getVolatileType(CandidateTy));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8287) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8288) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 8289)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8290) // Add restrict version only if there are conversions to a restrict type
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8291) // and our candidate type is a non-restrict-qualified pointer.
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8292) if (HasRestrict && CandidateTy->isAnyPointerType() &&
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8293) !CandidateTy.isRestrictQualified()) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8294) ParamTypes[0]
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8295) = S.Context.getLValueReferenceType(
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8296) S.Context.getCVRQualifiedType(CandidateTy, Qualifiers::Restrict));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8297) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 8298)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8299) if (HasVolatile) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8300) ParamTypes[0]
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8301) = S.Context.getLValueReferenceType(
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8302) S.Context.getCVRQualifiedType(CandidateTy,
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8303) (Qualifiers::Volatile |
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8304) Qualifiers::Restrict)));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8305) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8306) }
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8307) }
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8308)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8309) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8310)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8311) /// Helper to add an overload candidate for a binary builtin with types \p L
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8312) /// and \p R.
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8313) void AddCandidate(QualType L, QualType R) {
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8314) QualType LandR[2] = {L, R};
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8315) S.AddBuiltinCandidate(LandR, Args, CandidateSet);
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8316) }
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8317)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8318) public:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8319) BuiltinOperatorOverloadBuilder(
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8320) Sema &S, ArrayRef<Expr *> Args,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8321) Qualifiers VisibleTypeConversionsQuals,
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8322) bool HasArithmeticOrEnumeralCandidateType,
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 8323) SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8324) OverloadCandidateSet &CandidateSet)
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8325) : S(S), Args(Args),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8326) VisibleTypeConversionsQuals(VisibleTypeConversionsQuals),
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8327) HasArithmeticOrEnumeralCandidateType(
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8328) HasArithmeticOrEnumeralCandidateType),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8329) CandidateTypes(CandidateTypes),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8330) CandidateSet(CandidateSet) {
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8331)
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8332) InitArithmeticTypes();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8333) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8334)
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8335) // Increment is deprecated for bool since C++17.
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8336) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8337) // C++ [over.built]p3:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8338) //
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8339) // For every pair (T, VQ), where T is an arithmetic type other
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8340) // than bool, and VQ is either volatile or empty, there exist
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8341) // candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8342) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8343) // VQ T& operator++(VQ T&);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8344) // T operator++(VQ T&, int);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8345) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8346) // C++ [over.built]p4:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8347) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8348) // For every pair (T, VQ), where T is an arithmetic type other
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8349) // than bool, and VQ is either volatile or empty, there exist
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8350) // candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8351) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8352) // VQ T& operator--(VQ T&);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8353) // T operator--(VQ T&, int);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8354) void addPlusPlusMinusMinusArithmeticOverloads(OverloadedOperatorKind Op) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8355) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8356) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8357)
+d74ebe22db891 (Jan Korous 2018-04-11 13:36:29 +0000 8358) for (unsigned Arith = 0; Arith < NumArithmeticTypes; ++Arith) {
+d74ebe22db891 (Jan Korous 2018-04-11 13:36:29 +0000 8359) const auto TypeOfT = ArithmeticTypes[Arith];
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8360) if (TypeOfT == S.Context.BoolTy) {
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8361) if (Op == OO_MinusMinus)
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8362) continue;
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8363) if (Op == OO_PlusPlus && S.getLangOpts().CPlusPlus17)
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8364) continue;
+536d2e30721e2 (Jan Korous 2018-04-18 13:38:39 +0000 8365) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8366) addPlusPlusMinusMinusStyleOverloads(
+d74ebe22db891 (Jan Korous 2018-04-11 13:36:29 +0000 8367) TypeOfT,
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8368) VisibleTypeConversionsQuals.hasVolatile(),
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8369) VisibleTypeConversionsQuals.hasRestrict());
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8370) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8371) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8372)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8373) // C++ [over.built]p5:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8374) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8375) // For every pair (T, VQ), where T is a cv-qualified or
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8376) // cv-unqualified object type, and VQ is either volatile or
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8377) // empty, there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8378) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8379) // T*VQ& operator++(T*VQ&);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8380) // T*VQ& operator--(T*VQ&);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8381) // T* operator++(T*VQ&, int);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8382) // T* operator--(T*VQ&, int);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8383) void addPlusPlusMinusMinusPointerOverloads() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8384) for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8385) // Skip pointer types that aren't pointers to object types.
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8386) if (!PtrTy->getPointeeType()->isObjectType())
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8387) continue;
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8388)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8389) addPlusPlusMinusMinusStyleOverloads(
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8390) PtrTy,
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8391) (!PtrTy.isVolatileQualified() &&
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8392) VisibleTypeConversionsQuals.hasVolatile()),
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8393) (!PtrTy.isRestrictQualified() &&
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8394) VisibleTypeConversionsQuals.hasRestrict()));
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8395) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8396) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8397)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8398) // C++ [over.built]p6:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8399) // For every cv-qualified or cv-unqualified object type T, there
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8400) // exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8401) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8402) // T& operator*(T*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8403) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8404) // C++ [over.built]p7:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 8405) // For every function type T that does not have cv-qualifiers or a
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 8406) // ref-qualifier, there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8407) // T& operator*(T*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8408) void addUnaryStarPointerOverloads() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8409) for (QualType ParamTy : CandidateTypes[0].pointer_types()) {
+421ad5e1e67bb (Argyrios Kyrtzidis 2010-08-23 07:12:16 +0000 8410) QualType PointeeTy = ParamTy->getPointeeType();
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 8411) if (!PointeeTy->isObjectType() && !PointeeTy->isFunctionType())
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 8412) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 8413)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 8414) if (const FunctionProtoType *Proto =PointeeTy->getAs<FunctionProtoType>())
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 8415) if (Proto->getMethodQuals() || Proto->getRefQualifier())
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 8416) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 8417)
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8418) S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8419) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8420) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8421)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8422) // C++ [over.built]p9:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8423) // For every promoted arithmetic type T, there exist candidate
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8424) // operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8425) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8426) // T operator+(T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8427) // T operator-(T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8428) void addUnaryPlusOrMinusArithmeticOverloads() {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8429) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8430) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8431)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8432) for (unsigned Arith = FirstPromotedArithmeticType;
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8433) Arith < LastPromotedArithmeticType; ++Arith) {
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8434) QualType ArithTy = ArithmeticTypes[Arith];
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8435) S.AddBuiltinCandidate(&ArithTy, Args, CandidateSet);
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8436) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8437)
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8438) // Extension: We also add these operators for vector types.
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8439) for (QualType VecTy : CandidateTypes[0].vector_types())
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8440) S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8441) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8442)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8443) // C++ [over.built]p8:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8444) // For every type T, there exist candidate operator functions of
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8445) // the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8446) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8447) // T* operator+(T*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8448) void addUnaryPlusPointerOverloads() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8449) for (QualType ParamTy : CandidateTypes[0].pointer_types())
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8450) S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8451) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8452)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8453) // C++ [over.built]p10:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8454) // For every promoted integral type T, there exist candidate
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8455) // operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8456) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8457) // T operator~(T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8458) void addUnaryTildePromotedIntegralOverloads() {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8459) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8460) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8461)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8462) for (unsigned Int = FirstPromotedIntegralType;
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8463) Int < LastPromotedIntegralType; ++Int) {
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8464) QualType IntTy = ArithmeticTypes[Int];
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8465) S.AddBuiltinCandidate(&IntTy, Args, CandidateSet);
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8466) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8467)
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8468) // Extension: We also add this operator for vector types.
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8469) for (QualType VecTy : CandidateTypes[0].vector_types())
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8470) S.AddBuiltinCandidate(&VecTy, Args, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8471) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8472)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8473) // C++ [over.match.oper]p16:
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8474) // For every pointer to member type T or type std::nullptr_t, there
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8475) // exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8476) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8477) // bool operator==(T,T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8478) // bool operator!=(T,T);
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8479) void addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads() {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8480) /// Set of (canonical) types that we've already handled.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8481) llvm::SmallPtrSet<QualType, 8> AddedTypes;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8482)
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8483) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8484) for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8485) // Don't add the same builtin candidate twice.
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8486) if (!AddedTypes.insert(S.Context.getCanonicalType(MemPtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8487) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8488)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8489) QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8490) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8491) }
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8492)
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8493) if (CandidateTypes[ArgIdx].hasNullPtrType()) {
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8494) CanQualType NullPtrTy = S.Context.getCanonicalType(S.Context.NullPtrTy);
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8495) if (AddedTypes.insert(NullPtrTy).second) {
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8496) QualType ParamTypes[2] = { NullPtrTy, NullPtrTy };
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8497) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8498) }
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8499) }
+84605aeac90e0 (Douglas Gregor 2009-08-24 13:43:27 +0000 8500) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8501) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8502)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8503) // C++ [over.built]p15:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8504) //
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8505) // For every T, where T is an enumeration type or a pointer type,
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 8506) // there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8507) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8508) // bool operator<(T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8509) // bool operator>(T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8510) // bool operator<=(T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8511) // bool operator>=(T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8512) // bool operator==(T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8513) // bool operator!=(T, T);
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8514) // R operator<=>(T, T)
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8515) void addGenericBinaryPointerOrEnumeralOverloads() {
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8516) // C++ [over.match.oper]p3:
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8517) // [...]the built-in candidates include all of the candidate operator
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8518) // functions defined in 13.6 that, compared to the given operator, [...]
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8519) // do not have the same parameter-type-list as any non-template non-member
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8520) // candidate.
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8521) //
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8522) // Note that in practice, this only affects enumeration types because there
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8523) // aren't any built-in candidates of record type, and a user-defined operator
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8524) // must have an operand of record or enumeration type. Also, the only other
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8525) // overloaded operator with enumeration arguments, operator=,
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8526) // cannot be overloaded for enumeration types, so this is the only place
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8527) // where we must suppress candidates like this.
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8528) llvm::DenseSet<std::pair<CanQualType, CanQualType> >
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8529) UserDefinedBinaryOperators;
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8530)
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8531) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8532) if (!CandidateTypes[ArgIdx].enumeration_types().empty()) {
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8533) for (OverloadCandidateSet::iterator C = CandidateSet.begin(),
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8534) CEnd = CandidateSet.end();
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8535) C != CEnd; ++C) {
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8536) if (!C->Viable || !C->Function || C->Function->getNumParams() != 2)
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8537) continue;
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8538)
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8539) if (C->Function->isFunctionTemplateSpecialization())
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8540) continue;
+14f082b69d730 (Eli Friedman 2012-09-18 21:52:24 +0000 8541)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8542) // We interpret "same parameter-type-list" as applying to the
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8543) // "synthesized candidate, with the order of the two parameters
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8544) // reversed", not to the original function.
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 8545) bool Reversed = C->isReversed();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8546) QualType FirstParamType = C->Function->getParamDecl(Reversed ? 1 : 0)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8547) ->getType()
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8548) .getUnqualifiedType();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8549) QualType SecondParamType = C->Function->getParamDecl(Reversed ? 0 : 1)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8550) ->getType()
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 8551) .getUnqualifiedType();
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8552)
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8553) // Skip if either parameter isn't of enumeral type.
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8554) if (!FirstParamType->isEnumeralType() ||
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8555) !SecondParamType->isEnumeralType())
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8556) continue;
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8557)
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8558) // Add this operator to the set of known user-defined operators.
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8559) UserDefinedBinaryOperators.insert(
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8560) std::make_pair(S.Context.getCanonicalType(FirstParamType),
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8561) S.Context.getCanonicalType(SecondParamType)));
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8562) }
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8563) }
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8564) }
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8565)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8566) /// Set of (canonical) types that we've already handled.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8567) llvm::SmallPtrSet<QualType, 8> AddedTypes;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8568)
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 8569) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8570) for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8571) // Don't add the same builtin candidate twice.
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8572) if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8573) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8574)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8575) QualType ParamTypes[2] = {PtrTy, PtrTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8576) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8577) }
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8578) for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8579) CanQualType CanonType = S.Context.getCanonicalType(EnumTy);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8580)
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8581) // Don't add the same builtin candidate twice, or if a user defined
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8582) // candidate exists.
+82e95a3c79d67 (David Blaikie 2014-11-19 07:49:47 +0000 8583) if (!AddedTypes.insert(CanonType).second ||
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8584) UserDefinedBinaryOperators.count(std::make_pair(CanonType,
+c02db8cfb3dad (Chandler Carruth 2010-12-12 09:14:11 +0000 8585) CanonType)))
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8586) continue;
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8587) QualType ParamTypes[2] = {EnumTy, EnumTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8588) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8589) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8590) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8591) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8592)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8593) // C++ [over.built]p13:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8594) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8595) // For every cv-qualified or cv-unqualified object type T
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8596) // there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8597) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8598) // T* operator+(T*, ptr
diff _t);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8599) // T& operator[](T*, ptr
diff _t); [BELOW]
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8600) // T* operator-(T*, ptr
diff _t);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8601) // T* operator+(ptr
diff _t, T*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8602) // T& operator[](ptr
diff _t, T*); [BELOW]
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8603) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8604) // C++ [over.built]p14:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8605) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8606) // For every T, where T is a pointer to object type, there
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8607) // exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8608) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8609) // ptr
diff _t operator-(T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8610) void addBinaryPlusOrMinusPointerOverloads(OverloadedOperatorKind Op) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8611) /// Set of (canonical) types that we've already handled.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8612) llvm::SmallPtrSet<QualType, 8> AddedTypes;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8613)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8614) for (int Arg = 0; Arg < 2; ++Arg) {
+9207a52bc525f (Eric Christopher 2015-08-21 16:24:01 +0000 8615) QualType AsymmetricParamTypes[2] = {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8616) S.Context.getPointerDiffType(),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8617) S.Context.getPointerDiffType(),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8618) };
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8619) for (QualType PtrTy : CandidateTypes[Arg].pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8620) QualType PointeeTy = PtrTy->getPointeeType();
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 8621) if (!PointeeTy->isObjectType())
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 8622) continue;
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 8623)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8624) AsymmetricParamTypes[Arg] = PtrTy;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8625) if (Arg == 0 || Op == OO_Plus) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8626) // operator+(T*, ptr
diff _t) or operator-(T*, ptr
diff _t)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8627) // T* operator+(ptr
diff _t, T*);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8628) S.AddBuiltinCandidate(AsymmetricParamTypes, Args, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8629) }
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8630) if (Op == OO_Minus) {
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8631) // ptr
diff _t operator-(T, T);
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8632) if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8633) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8634)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8635) QualType ParamTypes[2] = {PtrTy, PtrTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8636) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8637) }
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8638) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8639) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8640) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8641)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8642) // C++ [over.built]p12:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8643) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8644) // For every pair of promoted arithmetic types L and R, there
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8645) // exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8646) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8647) // LR operator*(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8648) // LR operator/(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8649) // LR operator+(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8650) // LR operator-(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8651) // bool operator<(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8652) // bool operator>(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8653) // bool operator<=(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8654) // bool operator>=(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8655) // bool operator==(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8656) // bool operator!=(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8657) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8658) // where LR is the result of the usual arithmetic conversions
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8659) // between types L and R.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8660) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8661) // C++ [over.built]p24:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8662) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8663) // For every pair of promoted arithmetic types L and R, there exist
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8664) // candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8665) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8666) // LR operator?(bool, L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8667) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8668) // where LR is the result of the usual arithmetic conversions
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8669) // between types L and R.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8670) // Our candidates ignore the first parameter.
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8671) void addGenericBinaryArithmeticOverloads() {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8672) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8673) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8674)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8675) for (unsigned Left = FirstPromotedArithmeticType;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8676) Left < LastPromotedArithmeticType; ++Left) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8677) for (unsigned Right = FirstPromotedArithmeticType;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8678) Right < LastPromotedArithmeticType; ++Right) {
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8679) QualType LandR[2] = { ArithmeticTypes[Left],
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8680) ArithmeticTypes[Right] };
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8681) S.AddBuiltinCandidate(LandR, Args, CandidateSet);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8682) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8683) }
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8684)
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8685) // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8686) // conditional operator for vector types.
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8687) for (QualType Vec1Ty : CandidateTypes[0].vector_types())
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8688) for (QualType Vec2Ty : CandidateTypes[1].vector_types()) {
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8689) QualType LandR[2] = {Vec1Ty, Vec2Ty};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8690) S.AddBuiltinCandidate(LandR, Args, CandidateSet);
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8691) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8692) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8693)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8694) /// Add binary operator overloads for each candidate matrix type M1, M2:
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8695) /// * (M1, M1) -> M1
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8696) /// * (M1, M1.getElementType()) -> M1
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8697) /// * (M2.getElementType(), M2) -> M2
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8698) /// * (M2, M2) -> M2 // Only if M2 is not part of CandidateTypes[0].
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8699) void addMatrixBinaryArithmeticOverloads() {
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8700) if (!HasArithmeticOrEnumeralCandidateType)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8701) return;
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8702)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8703) for (QualType M1 : CandidateTypes[0].matrix_types()) {
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8704) AddCandidate(M1, cast<MatrixType>(M1)->getElementType());
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8705) AddCandidate(M1, M1);
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8706) }
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8707)
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8708) for (QualType M2 : CandidateTypes[1].matrix_types()) {
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8709) AddCandidate(cast<MatrixType>(M2)->getElementType(), M2);
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8710) if (!CandidateTypes[0].containsMatrixType(M2))
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8711) AddCandidate(M2, M2);
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8712) }
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8713) }
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 8714)
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8715) // C++2a [over.built]p14:
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8716) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8717) // For every integral type T there exists a candidate operator function
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8718) // of the form
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8719) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8720) // std::strong_ordering operator<=>(T, T)
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8721) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8722) // C++2a [over.built]p15:
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8723) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8724) // For every pair of floating-point types L and R, there exists a candidate
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8725) // operator function of the form
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8726) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8727) // std::partial_ordering operator<=>(L, R);
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8728) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8729) // FIXME: The current specification for integral types doesn't play nice with
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8730) // the direction of p0946r0, which allows mixed integral and unscoped-enum
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8731) // comparisons. Under the current spec this can lead to ambiguity during
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8732) // overload resolution. For example:
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8733) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8734) // enum A : int {a};
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8735) // auto x = (a <=> (long)42);
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8736) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8737) // error: call is ambiguous for arguments 'A' and 'long'.
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8738) // note: candidate operator<=>(int, int)
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8739) // note: candidate operator<=>(long, long)
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8740) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8741) // To avoid this error, this function deviates from the specification and adds
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8742) // the mixed overloads `operator<=>(L, R)` where L and R are promoted
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8743) // arithmetic types (the same as the generic relational overloads).
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8744) //
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8745) // For now this function acts as a placeholder.
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8746) void addThreeWayArithmeticOverloads() {
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8747) addGenericBinaryArithmeticOverloads();
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8748) }
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 8749)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8750) // C++ [over.built]p17:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8751) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8752) // For every pair of promoted integral types L and R, there
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8753) // exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8754) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8755) // LR operator%(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8756) // LR operator&(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8757) // LR operator^(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8758) // LR operator|(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8759) // L operator<<(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8760) // L operator>>(L, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8761) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8762) // where LR is the result of the usual arithmetic conversions
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8763) // between types L and R.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8764) void addBinaryBitwiseArithmeticOverloads(OverloadedOperatorKind Op) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8765) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8766) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8767)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8768) for (unsigned Left = FirstPromotedIntegralType;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8769) Left < LastPromotedIntegralType; ++Left) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8770) for (unsigned Right = FirstPromotedIntegralType;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8771) Right < LastPromotedIntegralType; ++Right) {
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8772) QualType LandR[2] = { ArithmeticTypes[Left],
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8773) ArithmeticTypes[Right] };
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8774) S.AddBuiltinCandidate(LandR, Args, CandidateSet);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8775) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8776) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8777) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8778)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8779) // C++ [over.built]p20:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8780) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8781) // For every pair (T, VQ), where T is an enumeration or
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8782) // pointer to member type and VQ is either volatile or
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8783) // empty, there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8784) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8785) // VQ T& operator=(VQ T&, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8786) void addAssignmentMemberPointerOrEnumeralOverloads() {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8787) /// Set of (canonical) types that we've already handled.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8788) llvm::SmallPtrSet<QualType, 8> AddedTypes;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8789)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8790) for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8791) for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8792) if (!AddedTypes.insert(S.Context.getCanonicalType(EnumTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8793) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8794)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8795) AddBuiltinAssignmentOperatorCandidates(S, EnumTy, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8796) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8797)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8798) for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8799) if (!AddedTypes.insert(S.Context.getCanonicalType(MemPtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8800) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8801)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8802) AddBuiltinAssignmentOperatorCandidates(S, MemPtrTy, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8803) }
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8804) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8805) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8806)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8807) // C++ [over.built]p19:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8808) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8809) // For every pair (T, VQ), where T is any type and VQ is either
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8810) // volatile or empty, there exist candidate operator functions
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8811) // of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8812) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8813) // T*VQ& operator=(T*VQ&, T*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8814) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8815) // C++ [over.built]p21:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8816) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8817) // For every pair (T, VQ), where T is a cv-qualified or
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8818) // cv-unqualified object type and VQ is either volatile or
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8819) // empty, there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8820) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8821) // T*VQ& operator+=(T*VQ&, ptr
diff _t);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8822) // T*VQ& operator-=(T*VQ&, ptr
diff _t);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8823) void addAssignmentPointerOverloads(bool isEqualOp) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8824) /// Set of (canonical) types that we've already handled.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8825) llvm::SmallPtrSet<QualType, 8> AddedTypes;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8826)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8827) for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8828) // If this is operator=, keep track of the builtin candidates we added.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8829) if (isEqualOp)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8830) AddedTypes.insert(S.Context.getCanonicalType(PtrTy));
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8831) else if (!PtrTy->getPointeeType()->isObjectType())
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 8832) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8833)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8834) // non-volatile version
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8835) QualType ParamTypes[2] = {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8836) S.Context.getLValueReferenceType(PtrTy),
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8837) isEqualOp ? PtrTy : S.Context.getPointerDiffType(),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8838) };
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8839) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8840) /*IsAssignmentOperator=*/ isEqualOp);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8841)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8842) bool NeedVolatile = !PtrTy.isVolatileQualified() &&
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8843) VisibleTypeConversionsQuals.hasVolatile();
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8844) if (NeedVolatile) {
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8845) // volatile version
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8846) ParamTypes[0] =
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8847) S.Context.getLValueReferenceType(S.Context.getVolatileType(PtrTy));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8848) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8849) /*IsAssignmentOperator=*/isEqualOp);
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 8850) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 8851)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8852) if (!PtrTy.isRestrictQualified() &&
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8853) VisibleTypeConversionsQuals.hasRestrict()) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8854) // restrict version
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8855) ParamTypes[0] =
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8856) S.Context.getLValueReferenceType(S.Context.getRestrictType(PtrTy));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8857) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8858) /*IsAssignmentOperator=*/isEqualOp);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 8859)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8860) if (NeedVolatile) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8861) // volatile restrict version
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8862) ParamTypes[0] =
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8863) S.Context.getLValueReferenceType(S.Context.getCVRQualifiedType(
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8864) PtrTy, (Qualifiers::Volatile | Qualifiers::Restrict)));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8865) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8866) /*IsAssignmentOperator=*/isEqualOp);
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8867) }
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8868) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8869) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8870)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8871) if (isEqualOp) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8872) for (QualType PtrTy : CandidateTypes[1].pointer_types()) {
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8873) // Make sure we don't add the same candidate twice.
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8874) if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8875) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8876)
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 8877) QualType ParamTypes[2] = {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8878) S.Context.getLValueReferenceType(PtrTy),
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8879) PtrTy,
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 8880) };
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8881)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8882) // non-volatile version
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8883) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8884) /*IsAssignmentOperator=*/true);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8885)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8886) bool NeedVolatile = !PtrTy.isVolatileQualified() &&
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8887) VisibleTypeConversionsQuals.hasVolatile();
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8888) if (NeedVolatile) {
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8889) // volatile version
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8890) ParamTypes[0] = S.Context.getLValueReferenceType(
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8891) S.Context.getVolatileType(PtrTy));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8892) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8893) /*IsAssignmentOperator=*/true);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8894) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 8895)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8896) if (!PtrTy.isRestrictQualified() &&
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8897) VisibleTypeConversionsQuals.hasRestrict()) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8898) // restrict version
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8899) ParamTypes[0] = S.Context.getLValueReferenceType(
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8900) S.Context.getRestrictType(PtrTy));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8901) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8902) /*IsAssignmentOperator=*/true);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 8903)
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8904) if (NeedVolatile) {
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8905) // volatile restrict version
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8906) ParamTypes[0] =
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8907) S.Context.getLValueReferenceType(S.Context.getCVRQualifiedType(
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 8908) PtrTy, (Qualifiers::Volatile | Qualifiers::Restrict)));
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8909) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8910) /*IsAssignmentOperator=*/true);
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8911) }
+5bee25884b9b7 (Douglas Gregor 2012-06-04 00:15:09 +0000 8912) }
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8913) }
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 8914) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8915) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8916)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8917) // C++ [over.built]p18:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8918) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8919) // For every triple (L, VQ, R), where L is an arithmetic type,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8920) // VQ is either volatile or empty, and R is a promoted
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8921) // arithmetic type, there exist candidate operator functions of
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8922) // the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8923) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8924) // VQ L& operator=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8925) // VQ L& operator*=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8926) // VQ L& operator/=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8927) // VQ L& operator+=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8928) // VQ L& operator-=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8929) void addAssignmentArithmeticOverloads(bool isEqualOp) {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8930) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8931) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8932)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8933) for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8934) for (unsigned Right = FirstPromotedArithmeticType;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8935) Right < LastPromotedArithmeticType; ++Right) {
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8936) QualType ParamTypes[2];
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8937) ParamTypes[1] = ArithmeticTypes[Right];
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8938) auto LeftBaseTy = AdjustAddressSpaceForBuiltinOperandType(
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8939) S, ArithmeticTypes[Left], Args[0]);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8940) // Add this built-in operator as a candidate (VQ is empty).
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8941) ParamTypes[0] = S.Context.getLValueReferenceType(LeftBaseTy);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8942) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8943) /*IsAssignmentOperator=*/isEqualOp);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8944)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8945) // Add this built-in operator as a candidate (VQ is 'volatile').
+b9e8c42ee6aea (Fariborz Jahanian 2009-10-19 21:30:45 +0000 8946) if (VisibleTypeConversionsQuals.hasVolatile()) {
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8947) ParamTypes[0] = S.Context.getVolatileType(LeftBaseTy);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8948) ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8949) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8950) /*IsAssignmentOperator=*/isEqualOp);
+b9e8c42ee6aea (Fariborz Jahanian 2009-10-19 21:30:45 +0000 8951) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8952) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8953) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8954)
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8955) // Extension: Add the binary operators =, +=, -=, *=, /= for vector types.
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8956) for (QualType Vec1Ty : CandidateTypes[0].vector_types())
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8957) for (QualType Vec2Ty : CandidateTypes[0].vector_types()) {
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8958) QualType ParamTypes[2];
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8959) ParamTypes[1] = Vec2Ty;
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8960) // Add this built-in operator as a candidate (VQ is empty).
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8961) ParamTypes[0] = S.Context.getLValueReferenceType(Vec1Ty);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8962) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8963) /*IsAssignmentOperator=*/isEqualOp);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8964)
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8965) // Add this built-in operator as a candidate (VQ is 'volatile').
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8966) if (VisibleTypeConversionsQuals.hasVolatile()) {
+714e84be4615d (Florian Hahn 2020-06-04 20:15:21 +0100 8967) ParamTypes[0] = S.Context.getVolatileType(Vec1Ty);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8968) ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 8969) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 8970) /*IsAssignmentOperator=*/isEqualOp);
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8971) }
+cbfbca14d0a2b (Douglas Gregor 2010-05-19 03:21:00 +0000 8972) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8973) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8974)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8975) // C++ [over.built]p22:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8976) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8977) // For every triple (L, VQ, R), where L is an integral type, VQ
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8978) // is either volatile or empty, and R is a promoted integral
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8979) // type, there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8980) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8981) // VQ L& operator%=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8982) // VQ L& operator<<=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8983) // VQ L& operator>>=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8984) // VQ L& operator&=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8985) // VQ L& operator^=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8986) // VQ L& operator|=(VQ L&, R);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 8987) void addAssignmentIntegralOverloads() {
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8988) if (!HasArithmeticOrEnumeralCandidateType)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8989) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 8990)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8991) for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) {
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 8992) for (unsigned Right = FirstPromotedIntegralType;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8993) Right < LastPromotedIntegralType; ++Right) {
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8994) QualType ParamTypes[2];
+8237141be1d45 (Hans Wennborg 2017-11-15 17:11:53 +0000 8995) ParamTypes[1] = ArithmeticTypes[Right];
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8996) auto LeftBaseTy = AdjustAddressSpaceForBuiltinOperandType(
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8997) S, ArithmeticTypes[Left], Args[0]);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 8998) // Add this built-in operator as a candidate (VQ is empty).
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 8999) ParamTypes[0] = S.Context.getLValueReferenceType(LeftBaseTy);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9000) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+a4a9334a5013a (Fariborz Jahanian 2009-10-20 00:04:40 +0000 9001) if (VisibleTypeConversionsQuals.hasVolatile()) {
+a4a9334a5013a (Fariborz Jahanian 2009-10-20 00:04:40 +0000 9002) // Add this built-in operator as a candidate (VQ is 'volatile').
+4ce581e5a9f90 (Anastasia Stulova 2019-03-19 16:50:21 +0000 9003) ParamTypes[0] = LeftBaseTy;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9004) ParamTypes[0] = S.Context.getVolatileType(ParamTypes[0]);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9005) ParamTypes[0] = S.Context.getLValueReferenceType(ParamTypes[0]);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9006) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+a4a9334a5013a (Fariborz Jahanian 2009-10-20 00:04:40 +0000 9007) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9008) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9009) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 9010) }
+d08452f60a273 (Douglas Gregor 2008-11-19 15:42:04 +0000 9011)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9012) // C++ [over.operator]p23:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9013) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9014) // There also exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9015) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9016) // bool operator!(bool);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9017) // bool operator&&(bool, bool);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9018) // bool operator||(bool, bool);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9019) void addExclaimOverload() {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9020) QualType ParamTy = S.Context.BoolTy;
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9021) S.AddBuiltinCandidate(&ParamTy, Args, CandidateSet,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9022) /*IsAssignmentOperator=*/false,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9023) /*NumContextualBoolArguments=*/1);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9024) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9025) void addAmpAmpOrPipePipeOverload() {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9026) QualType ParamTypes[2] = { S.Context.BoolTy, S.Context.BoolTy };
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9027) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9028) /*IsAssignmentOperator=*/false,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9029) /*NumContextualBoolArguments=*/2);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9030) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9031)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9032) // C++ [over.built]p13:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9033) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9034) // For every cv-qualified or cv-unqualified object type T there
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9035) // exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9036) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9037) // T* operator+(T*, ptr
diff _t); [ABOVE]
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9038) // T& operator[](T*, ptr
diff _t);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9039) // T* operator-(T*, ptr
diff _t); [ABOVE]
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9040) // T* operator+(ptr
diff _t, T*); [ABOVE]
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9041) // T& operator[](ptr
diff _t, T*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9042) void addSubscriptOverloads() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9043) for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9044) QualType ParamTypes[2] = {PtrTy, S.Context.getPointerDiffType()};
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9045) QualType PointeeType = PtrTy->getPointeeType();
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 9046) if (!PointeeType->isObjectType())
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 9047) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 9048)
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9049) // T& operator[](T*, ptr
diff _t)
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9050) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9051) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9052)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9053) for (QualType PtrTy : CandidateTypes[1].pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9054) QualType ParamTypes[2] = {S.Context.getPointerDiffType(), PtrTy};
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9055) QualType PointeeType = PtrTy->getPointeeType();
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 9056) if (!PointeeType->isObjectType())
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 9057) continue;
+66990031e2951 (Douglas Gregor 2011-01-05 00:13:17 +0000 9058)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9059) // T& operator[](ptr
diff _t, T*)
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9060) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9061) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9062) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9063)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9064) // C++ [over.built]p11:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9065) // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9066) // C1 is the same type as C2 or is a derived class of C2, T is an object
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9067) // type or a function type, and CV1 and CV2 are cv-qualifier-seqs,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9068) // there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9069) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9070) // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9071) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9072) // where CV12 is the union of CV1 and CV2.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9073) void addArrowStarOverloads() {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9074) for (QualType PtrTy : CandidateTypes[0].pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9075) QualType C1Ty = PtrTy;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9076) QualType C1;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9077) QualifierCollector Q1;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9078) C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9079) if (!isa<RecordType>(C1))
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9080) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9081) // heuristic to reduce number of builtin candidates in the set.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9082) // Add volatile/restrict version only if there are conversions to a
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9083) // volatile/restrict type.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9084) if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile())
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9085) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9086) if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict())
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9087) continue;
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9088) for (QualType MemPtrTy : CandidateTypes[1].member_pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9089) const MemberPointerType *mptr = cast<MemberPointerType>(MemPtrTy);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9090) QualType C2 = QualType(mptr->getClass(), 0);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9091) C2 = C2.getUnqualifiedType();
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 9092) if (C1 != C2 && !S.IsDerivedFrom(CandidateSet.getLocation(), C1, C2))
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9093) break;
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9094) QualType ParamTypes[2] = {PtrTy, MemPtrTy};
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9095) // build CV12 T&
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9096) QualType T = mptr->getPointeeType();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9097) if (!VisibleTypeConversionsQuals.hasVolatile() &&
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9098) T.isVolatileQualified())
+421ad5e1e67bb (Argyrios Kyrtzidis 2010-08-23 07:12:16 +0000 9099) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9100) if (!VisibleTypeConversionsQuals.hasRestrict() &&
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9101) T.isRestrictQualified())
+421ad5e1e67bb (Argyrios Kyrtzidis 2010-08-23 07:12:16 +0000 9102) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9103) T = Q1.apply(S.Context, T);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9104) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+34d93dcddde71 (Fariborz Jahanian 2009-10-06 23:08:05 +0000 9105) }
+34d93dcddde71 (Fariborz Jahanian 2009-10-06 23:08:05 +0000 9106) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9107) }
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 9108)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9109) // Note that we don't consider the first argument, since it has been
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9110) // contextually converted to bool long ago. The candidates below are
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9111) // therefore added as binary.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9112) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9113) // C++ [over.built]p25:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9114) // For every type T, where T is a pointer, pointer-to-member, or scoped
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9115) // enumeration type, there exist candidate operator functions of the form
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9116) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9117) // T operator?(bool, T, T);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9118) //
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9119) void addConditionalOperatorOverloads() {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9120) /// Set of (canonical) types that we've already handled.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9121) llvm::SmallPtrSet<QualType, 8> AddedTypes;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9122)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9123) for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9124) for (QualType PtrTy : CandidateTypes[ArgIdx].pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9125) if (!AddedTypes.insert(S.Context.getCanonicalType(PtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9126) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9127)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9128) QualType ParamTypes[2] = {PtrTy, PtrTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9129) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9130) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9131)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9132) for (QualType MemPtrTy : CandidateTypes[ArgIdx].member_pointer_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9133) if (!AddedTypes.insert(S.Context.getCanonicalType(MemPtrTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9134) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9135)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9136) QualType ParamTypes[2] = {MemPtrTy, MemPtrTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9137) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9138) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9139)
+2bf7fdb723fc5 (Richard Smith 2013-01-02 11:42:31 +0000 9140) if (S.getLangOpts().CPlusPlus11) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9141) for (QualType EnumTy : CandidateTypes[ArgIdx].enumeration_types()) {
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9142) if (!EnumTy->castAs<EnumType>()->getDecl()->isScoped())
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9143) continue;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9144)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9145) if (!AddedTypes.insert(S.Context.getCanonicalType(EnumTy)).second)
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9146) continue;
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9147)
+fd14a2753368b (Richard Sandiford 2020-12-07 18:34:53 +0000 9148) QualType ParamTypes[2] = {EnumTy, EnumTy};
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9149) S.AddBuiltinCandidate(ParamTypes, Args, CandidateSet);
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9150) }
+b37c9af75dae4 (Douglas Gregor 2010-11-03 17:00:07 +0000 9151) }
+8a8e0313bfb01 (Douglas Gregor 2010-10-15 00:50:56 +0000 9152) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9153) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9154) };
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9155)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9156) } // end anonymous namespace
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9157)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9158) /// AddBuiltinOperatorCandidates - Add the appropriate built-in
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9159) /// operator overloads to the candidate set (C++ [over.built]), based
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9160) /// on the operator @p Op and the arguments given. For example, if the
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9161) /// operator is a binary '+', this routine might add "int
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9162) /// operator+(int, int)" to cover integer addition.
+16e94b91ef4d5 (Robert Wilhelm 2013-08-09 18:02:13 +0000 9163) void Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op,
+16e94b91ef4d5 (Robert Wilhelm 2013-08-09 18:02:13 +0000 9164) SourceLocation OpLoc,
+16e94b91ef4d5 (Robert Wilhelm 2013-08-09 18:02:13 +0000 9165) ArrayRef<Expr *> Args,
+16e94b91ef4d5 (Robert Wilhelm 2013-08-09 18:02:13 +0000 9166) OverloadCandidateSet &CandidateSet) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9167) // Find all of the types that the arguments can convert to, but only
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9168) // if the operator we're looking at has built-in operator candidates
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9169) // that make use of these types. Also record whether we encounter non-record
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9170) // candidate types or either arithmetic or enumeral candidate types.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9171) Qualifiers VisibleTypeConversionsQuals;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9172) VisibleTypeConversionsQuals.addConst();
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9173) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9174) VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]);
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9175)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9176) bool HasNonRecordCandidateType = false;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9177) bool HasArithmeticOrEnumeralCandidateType = false;
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 9178) SmallVector<BuiltinCandidateTypeSet, 2> CandidateTypes;
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9179) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+57dddd4840bac (Benjamin Kramer 2015-02-17 21:55:18 +0000 9180) CandidateTypes.emplace_back(*this);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9181) CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9182) OpLoc,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9183) true,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9184) (Op == OO_Exclaim ||
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9185) Op == OO_AmpAmp ||
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9186) Op == OO_PipePipe),
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9187) VisibleTypeConversionsQuals);
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9188) HasNonRecordCandidateType = HasNonRecordCandidateType ||
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9189) CandidateTypes[ArgIdx].hasNonRecordTypes();
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9190) HasArithmeticOrEnumeralCandidateType =
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9191) HasArithmeticOrEnumeralCandidateType ||
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9192) CandidateTypes[ArgIdx].hasArithmeticOrEnumeralTypes();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9193) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9194)
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9195) // Exit early when no non-record types have been added to the candidate set
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9196) // for any of the arguments to the operator.
+877d4ebba49cc (Douglas Gregor 2011-10-10 14:05:31 +0000 9197) //
+877d4ebba49cc (Douglas Gregor 2011-10-10 14:05:31 +0000 9198) // We can't exit early for !, ||, or &&, since there we have always have
+877d4ebba49cc (Douglas Gregor 2011-10-10 14:05:31 +0000 9199) // 'bool' overloads.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9200) if (!HasNonRecordCandidateType &&
+877d4ebba49cc (Douglas Gregor 2011-10-10 14:05:31 +0000 9201) !(Op == OO_Exclaim || Op == OO_AmpAmp || Op == OO_PipePipe))
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9202) return;
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9203)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9204) // Setup an object to manage the common state for building overloads.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9205) BuiltinOperatorOverloadBuilder OpBuilder(*this, Args,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9206) VisibleTypeConversionsQuals,
+00a383363859a (Chandler Carruth 2010-12-13 01:44:01 +0000 9207) HasArithmeticOrEnumeralCandidateType,
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9208) CandidateTypes, CandidateSet);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9209)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9210) // Dispatch over the operation to add in only those overloads which apply.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9211) switch (Op) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9212) case OO_None:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9213) case NUM_OVERLOADED_OPERATORS:
+83d382b1cad13 (David Blaikie 2011-09-23 05:06:16 +0000 9214) llvm_unreachable("Expected an overloaded operator");
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9215)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9216) case OO_New:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9217) case OO_Delete:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9218) case OO_Array_New:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9219) case OO_Array_Delete:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9220) case OO_Call:
+83d382b1cad13 (David Blaikie 2011-09-23 05:06:16 +0000 9221) llvm_unreachable(
+83d382b1cad13 (David Blaikie 2011-09-23 05:06:16 +0000 9222) "Special operators don't use AddBuiltinOperatorCandidates");
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9223)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9224) case OO_Comma:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9225) case OO_Arrow:
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 9226) case OO_Coawait:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9227) // C++ [over.match.oper]p3:
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 9228) // -- For the operator ',', the unary operator '&', the
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 9229) // operator '->', or the operator 'co_await', the
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 9230) // built-in candidates set is empty.
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9231) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9232)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9233) case OO_Plus: // '+' is either unary or binary
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9234) if (Args.size() == 1)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9235) OpBuilder.addUnaryPlusPointerOverloads();
+f3b3ccda590c1 (Adrian Prantl 2017-12-19 22:06:11 +0000 9236) LLVM_FALLTHROUGH;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9237)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9238) case OO_Minus: // '-' is either unary or binary
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9239) if (Args.size() == 1) {
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9240) OpBuilder.addUnaryPlusOrMinusArithmeticOverloads();
+f9802446a58e5 (Chandler Carruth 2010-12-12 08:39:38 +0000 9241) } else {
+f9802446a58e5 (Chandler Carruth 2010-12-12 08:39:38 +0000 9242) OpBuilder.addBinaryPlusOrMinusPointerOverloads(Op);
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9243) OpBuilder.addGenericBinaryArithmeticOverloads();
+6f6e91d193373 (Florian Hahn 2020-05-29 20:42:22 +0100 9244) OpBuilder.addMatrixBinaryArithmeticOverloads();
+f9802446a58e5 (Chandler Carruth 2010-12-12 08:39:38 +0000 9245) }
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9246) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9247)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9248) case OO_Star: // '*' is either unary or binary
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9249) if (Args.size() == 1)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9250) OpBuilder.addUnaryStarPointerOverloads();
+4affc444b499b (Florian Hahn 2020-06-07 11:11:27 +0100 9251) else {
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9252) OpBuilder.addGenericBinaryArithmeticOverloads();
+4affc444b499b (Florian Hahn 2020-06-07 11:11:27 +0100 9253) OpBuilder.addMatrixBinaryArithmeticOverloads();
+4affc444b499b (Florian Hahn 2020-06-07 11:11:27 +0100 9254) }
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9255) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9256)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9257) case OO_Slash:
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9258) OpBuilder.addGenericBinaryArithmeticOverloads();
+9de23cdb45e56 (Chandler Carruth 2010-12-12 08:45:02 +0000 9259) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9260)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9261) case OO_PlusPlus:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9262) case OO_MinusMinus:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9263) OpBuilder.addPlusPlusMinusMinusArithmeticOverloads(Op);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9264) OpBuilder.addPlusPlusMinusMinusPointerOverloads();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9265) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9266)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9267) case OO_EqualEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9268) case OO_ExclaimEqual:
+5e9746f520e6b (Richard Smith 2016-10-21 22:00:42 +0000 9269) OpBuilder.addEqualEqualOrNotEqualMemberPointerOrNullptrOverloads();
+f3b3ccda590c1 (Adrian Prantl 2017-12-19 22:06:11 +0000 9270) LLVM_FALLTHROUGH;
+9de23cdb45e56 (Chandler Carruth 2010-12-12 08:45:02 +0000 9271)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9272) case OO_Less:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9273) case OO_Greater:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9274) case OO_LessEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9275) case OO_GreaterEqual:
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 9276) OpBuilder.addGenericBinaryPointerOrEnumeralOverloads();
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9277) OpBuilder.addGenericBinaryArithmeticOverloads();
+0375e954468f1 (Chandler Carruth 2010-12-12 08:32:28 +0000 9278) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9279)
+d30b23d6a54b3 (Richard Smith 2017-12-01 02:13:10 +0000 9280) case OO_Spaceship:
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 9281) OpBuilder.addGenericBinaryPointerOrEnumeralOverloads();
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 9282) OpBuilder.addThreeWayArithmeticOverloads();
+0683c0e68d31d (Eric Fiselier 2018-05-07 21:07:10 +0000 9283) break;
+d30b23d6a54b3 (Richard Smith 2017-12-01 02:13:10 +0000 9284)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9285) case OO_Percent:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9286) case OO_Caret:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9287) case OO_Pipe:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9288) case OO_LessLess:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9289) case OO_GreaterGreater:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9290) OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9291) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9292)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9293) case OO_Amp: // '&' is either unary or binary
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 9294) if (Args.size() == 1)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9295) // C++ [over.match.oper]p3:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9296) // -- For the operator ',', the unary operator '&', or the
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9297) // operator '->', the built-in candidates set is empty.
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9298) break;
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9299)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9300) OpBuilder.addBinaryBitwiseArithmeticOverloads(Op);
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9301) break;
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9302)
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9303) case OO_Tilde:
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9304) OpBuilder.addUnaryTildePromotedIntegralOverloads();
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9305) break;
+5184de0aff61b (Chandler Carruth 2010-12-12 08:51:33 +0000 9306)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9307) case OO_Equal:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9308) OpBuilder.addAssignmentMemberPointerOrEnumeralOverloads();
+f3b3ccda590c1 (Adrian Prantl 2017-12-19 22:06:11 +0000 9309) LLVM_FALLTHROUGH;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9310)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9311) case OO_PlusEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9312) case OO_MinusEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9313) OpBuilder.addAssignmentPointerOverloads(Op == OO_Equal);
+f3b3ccda590c1 (Adrian Prantl 2017-12-19 22:06:11 +0000 9314) LLVM_FALLTHROUGH;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9315)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9316) case OO_StarEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9317) case OO_SlashEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9318) OpBuilder.addAssignmentArithmeticOverloads(Op == OO_Equal);
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9319) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9320)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9321) case OO_PercentEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9322) case OO_LessLessEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9323) case OO_GreaterGreaterEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9324) case OO_AmpEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9325) case OO_CaretEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9326) case OO_PipeEqual:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9327) OpBuilder.addAssignmentIntegralOverloads();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9328) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9329)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9330) case OO_Exclaim:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9331) OpBuilder.addExclaimOverload();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9332) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9333)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9334) case OO_AmpAmp:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9335) case OO_PipePipe:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9336) OpBuilder.addAmpAmpOrPipePipeOverload();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9337) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9338)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9339) case OO_Subscript:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9340) OpBuilder.addSubscriptOverloads();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9341) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9342)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9343) case OO_ArrowStar:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9344) OpBuilder.addArrowStarOverloads();
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9345) break;
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9346)
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9347) case OO_Conditional:
+85c2d09a5a43a (Chandler Carruth 2010-12-12 08:11:30 +0000 9348) OpBuilder.addConditionalOperatorOverloads();
+c07c389a94bb4 (George Burgess IV 2017-06-08 18:19:25 +0000 9349) OpBuilder.addGenericBinaryArithmeticOverloads();
+f9802446a58e5 (Chandler Carruth 2010-12-12 08:39:38 +0000 9350) break;
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9351) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9352) }
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 9353)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 9354) /// Add function candidates found via argument-dependent lookup
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9355) /// to the set of overloading candidates.
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9356) ///
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9357) /// This routine performs argument-dependent name lookup based on the
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9358) /// given function name (which may also be an operator name) and adds
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9359) /// all of the overload candidates found by ADL to the overload
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9360) /// candidate set (C++ [basic.lookup.argdep]).
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 9361) void
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9362) Sema::AddArgumentDependentLookupCandidates(DeclarationName Name,
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 9363) SourceLocation Loc,
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 9364) ArrayRef<Expr *> Args,
+739b107af8003 (Douglas Gregor 2011-03-03 02:41:12 +0000 9365) TemplateArgumentListInfo *ExplicitTemplateArgs,
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 9366) OverloadCandidateSet& CandidateSet,
+b6626748c2e50 (Richard Smith 2012-10-18 17:56:02 +0000 9367) bool PartialOverloading) {
+8fe6808de0d1b (John McCall 2010-01-26 07:16:45 +0000 9368) ADLResult Fns;
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9369)
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9370) // FIXME: This approach for uniquing ADL results (and removing
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9371) // redundant candidates from the set) relies on pointer-equality,
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9372) // which means we need to key off the canonical decl. However,
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9373) // always going back to the canonical decl might not get us the
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9374) // right set of default arguments. What default arguments are
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9375) // we supposed to consider on ADL candidates, anyway?
+91f61fc921e4a (John McCall 2010-01-26 06:04:06 +0000 9376)
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 9377) // FIXME: Pass in the explicit template arguments?
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 9378) ArgumentDependentLookup(Name, Loc, Args, Fns);
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9379)
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9380) // Erase all of the candidates we already knew about.
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9381) for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(),
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9382) CandEnd = CandidateSet.end();
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9383) Cand != CandEnd; ++Cand)
+15448f8d238c5 (Douglas Gregor 2009-06-27 21:05:07 +0000 9384) if (Cand->Function) {
+8fe6808de0d1b (John McCall 2010-01-26 07:16:45 +0000 9385) Fns.erase(Cand->Function);
+15448f8d238c5 (Douglas Gregor 2009-06-27 21:05:07 +0000 9386) if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate())
+8fe6808de0d1b (John McCall 2010-01-26 07:16:45 +0000 9387) Fns.erase(FunTmpl);
+15448f8d238c5 (Douglas Gregor 2009-06-27 21:05:07 +0000 9388) }
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9389)
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9390) // For each of the ADL candidates we found, add it to the overload
+d2b7ef6ecea96 (Douglas Gregor 2009-03-13 00:33:25 +0000 9391) // set.
+8fe6808de0d1b (John McCall 2010-01-26 07:16:45 +0000 9392) for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 9393) DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none);
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 9394)
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 9395) if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
+6b51f28e82646 (John McCall 2009-11-23 01:53:49 +0000 9396) if (ExplicitTemplateArgs)
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 9397) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 9398)
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9399) AddOverloadCandidate(
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9400) FD, FoundDecl, Args, CandidateSet, /*SuppressUserConversions=*/false,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9401) PartialOverloading, /*AllowExplicit=*/true,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9402) /*AllowExplicitConversions=*/false, ADLCallKind::UsesADL);
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9403) if (CandidateSet.getRewriteInfo().shouldAddReversed(Context, FD)) {
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9404) AddOverloadCandidate(
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9405) FD, FoundDecl, {Args[1], Args[0]}, CandidateSet,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9406) /*SuppressUserConversions=*/false, PartialOverloading,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9407) /*AllowExplicit=*/true, /*AllowExplicitConversions=*/false,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9408) ADLCallKind::UsesADL, None, OverloadCandidateParamOrder::Reversed);
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9409) }
+743ae6045d413 (Eric Fiselier 2018-12-11 16:53:25 +0000 9410) } else {
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9411) auto *FTD = cast<FunctionTemplateDecl>(*I);
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 9412) AddTemplateOverloadCandidate(
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9413) FTD, FoundDecl, ExplicitTemplateArgs, Args, CandidateSet,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 9414) /*SuppressUserConversions=*/false, PartialOverloading,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9415) /*AllowExplicit=*/true, ADLCallKind::UsesADL);
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9416) if (CandidateSet.getRewriteInfo().shouldAddReversed(
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9417) Context, FTD->getTemplatedDecl())) {
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9418) AddTemplateOverloadCandidate(
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9419) FTD, FoundDecl, ExplicitTemplateArgs, {Args[1], Args[0]},
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9420) CandidateSet, /*SuppressUserConversions=*/false, PartialOverloading,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9421) /*AllowExplicit=*/true, ADLCallKind::UsesADL,
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9422) OverloadCandidateParamOrder::Reversed);
+1db66e705f4db (Richard Smith 2020-01-30 18:40:53 -0800 9423) }
+743ae6045d413 (Eric Fiselier 2018-12-11 16:53:25 +0000 9424) }
+15448f8d238c5 (Douglas Gregor 2009-06-27 21:05:07 +0000 9425) }
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9426) }
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 9427)
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9428) namespace {
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9429) enum class Comparison { Equal, Better, Worse };
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9430) }
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9431)
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9432) /// Compares the enable_if attributes of two FunctionDecls, for the purposes of
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9433) /// overload resolution.
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9434) ///
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9435) /// Cand1's set of enable_if attributes are said to be "better" than Cand2's iff
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9436) /// Cand1's first N enable_if attributes have precisely the same conditions as
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9437) /// Cand2's first N enable_if attributes (where N = the number of enable_if
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9438) /// attributes on Cand2), and Cand1 has more than N enable_if attributes.
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9439) ///
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9440) /// Note that you can have a pair of candidates such that Cand1's enable_if
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9441) /// attributes are worse than Cand2's, and Cand2's enable_if attributes are
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9442) /// worse than Cand1's.
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9443) static Comparison compareEnableIfAttrs(const Sema &S, const FunctionDecl *Cand1,
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9444) const FunctionDecl *Cand2) {
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9445) // Common case: One (or both) decls don't have enable_if attrs.
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9446) bool Cand1Attr = Cand1->hasAttr<EnableIfAttr>();
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9447) bool Cand2Attr = Cand2->hasAttr<EnableIfAttr>();
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9448) if (!Cand1Attr || !Cand2Attr) {
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9449) if (Cand1Attr == Cand2Attr)
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9450) return Comparison::Equal;
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9451) return Cand1Attr ? Comparison::Better : Comparison::Worse;
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9452) }
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9453)
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 9454) auto Cand1Attrs = Cand1->specific_attrs<EnableIfAttr>();
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 9455) auto Cand2Attrs = Cand2->specific_attrs<EnableIfAttr>();
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9456)
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9457) llvm::FoldingSetNodeID Cand1ID, Cand2ID;
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9458) for (auto Pair : zip_longest(Cand1Attrs, Cand2Attrs)) {
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9459) Optional<EnableIfAttr *> Cand1A = std::get<0>(Pair);
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9460) Optional<EnableIfAttr *> Cand2A = std::get<1>(Pair);
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9461)
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 9462) // It's impossible for Cand1 to be better than (or equal to) Cand2 if Cand1
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9463) // has fewer enable_if attributes than Cand2, and vice versa.
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9464) if (!Cand1A)
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 9465) return Comparison::Worse;
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9466) if (!Cand2A)
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9467) return Comparison::Better;
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9468)
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9469) Cand1ID.clear();
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9470) Cand2ID.clear();
+dc5ce72afada3 (Michael Kruse 2018-08-03 01:21:16 +0000 9471)
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9472) (*Cand1A)->getCond()->Profile(Cand1ID, S.getASTContext(), true);
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9473) (*Cand2A)->getCond()->Profile(Cand2ID, S.getASTContext(), true);
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9474) if (Cand1ID != Cand2ID)
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9475) return Comparison::Worse;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9476) }
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9477)
+157a355f3b3e7 (Michael Kruse 2018-12-10 15:16:37 +0000 9478) return Comparison::Equal;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9479) }
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 9480)
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9481) static Comparison
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9482) isBetterMultiversionCandidate(const OverloadCandidate &Cand1,
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9483) const OverloadCandidate &Cand2) {
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9484) if (!Cand1.Function || !Cand1.Function->isMultiVersion() || !Cand2.Function ||
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9485) !Cand2.Function->isMultiVersion())
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9486) return Comparison::Equal;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9487)
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9488) // If both are invalid, they are equal. If one of them is invalid, the other
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9489) // is better.
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9490) if (Cand1.Function->isInvalidDecl()) {
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9491) if (Cand2.Function->isInvalidDecl())
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9492) return Comparison::Equal;
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9493) return Comparison::Worse;
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9494) }
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9495) if (Cand2.Function->isInvalidDecl())
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9496) return Comparison::Better;
+414ff52d09f7a (Erich Keane 2019-01-04 15:24:06 +0000 9497)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9498) // If this is a cpu_dispatch/cpu_specific multiversion situation, prefer
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9499) // cpu_dispatch, else arbitrarily based on the identifiers.
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9500) bool Cand1CPUDisp = Cand1.Function->hasAttr<CPUDispatchAttr>();
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9501) bool Cand2CPUDisp = Cand2.Function->hasAttr<CPUDispatchAttr>();
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9502) const auto *Cand1CPUSpec = Cand1.Function->getAttr<CPUSpecificAttr>();
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9503) const auto *Cand2CPUSpec = Cand2.Function->getAttr<CPUSpecificAttr>();
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9504)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9505) if (!Cand1CPUDisp && !Cand2CPUDisp && !Cand1CPUSpec && !Cand2CPUSpec)
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9506) return Comparison::Equal;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9507)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9508) if (Cand1CPUDisp && !Cand2CPUDisp)
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9509) return Comparison::Better;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9510) if (Cand2CPUDisp && !Cand1CPUDisp)
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9511) return Comparison::Worse;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9512)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9513) if (Cand1CPUSpec && Cand2CPUSpec) {
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9514) if (Cand1CPUSpec->cpus_size() != Cand2CPUSpec->cpus_size())
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9515) return Cand1CPUSpec->cpus_size() < Cand2CPUSpec->cpus_size()
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9516) ? Comparison::Better
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9517) : Comparison::Worse;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9518)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9519) std::pair<CPUSpecificAttr::cpus_iterator, CPUSpecificAttr::cpus_iterator>
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9520) FirstDiff = std::mismatch(
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9521) Cand1CPUSpec->cpus_begin(), Cand1CPUSpec->cpus_end(),
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9522) Cand2CPUSpec->cpus_begin(),
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9523) [](const IdentifierInfo *LHS, const IdentifierInfo *RHS) {
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9524) return LHS->getName() == RHS->getName();
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9525) });
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9526)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9527) assert(FirstDiff.first != Cand1CPUSpec->cpus_end() &&
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9528) "Two
diff erent cpu-specific versions should not have the same "
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9529) "identifier list, otherwise they'd be the same decl!");
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9530) return (*FirstDiff.first)->getName() < (*FirstDiff.second)->getName()
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9531) ? Comparison::Better
+b3d10920e1344 (Fangrui Song 2020-06-10 22:32:43 -0700 9532) : Comparison::Worse;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9533) }
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9534) llvm_unreachable("No way to get here unless both had cpu_dispatch");
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9535) }
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9536)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9537) /// Compute the type of the implicit object parameter for the given function,
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9538) /// if any. Returns None if there is no implicit object parameter, and a null
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9539) /// QualType if there is a 'matches anything' implicit object parameter.
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9540) static Optional<QualType> getImplicitObjectParamType(ASTContext &Context,
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9541) const FunctionDecl *F) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9542) if (!isa<CXXMethodDecl>(F) || isa<CXXConstructorDecl>(F))
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9543) return llvm::None;
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9544)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9545) auto *M = cast<CXXMethodDecl>(F);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9546) // Static member functions' object parameters match all types.
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9547) if (M->isStatic())
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9548) return QualType();
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9549)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9550) QualType T = M->getThisObjectType();
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9551) if (M->getRefQualifier() == RQ_RValue)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9552) return Context.getRValueReferenceType(T);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9553) return Context.getLValueReferenceType(T);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9554) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9555)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9556) static bool haveSameParameterTypes(ASTContext &Context, const FunctionDecl *F1,
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9557) const FunctionDecl *F2, unsigned NumParams) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9558) if (declaresSameEntity(F1, F2))
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9559) return true;
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9560)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9561) auto NextParam = [&](const FunctionDecl *F, unsigned &I, bool First) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9562) if (First) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9563) if (Optional<QualType> T = getImplicitObjectParamType(Context, F))
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9564) return *T;
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9565) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9566) assert(I < F->getNumParams());
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9567) return F->getParamDecl(I++)->getType();
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9568) };
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9569)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9570) unsigned I1 = 0, I2 = 0;
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9571) for (unsigned I = 0; I != NumParams; ++I) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9572) QualType T1 = NextParam(F1, I1, I == 0);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9573) QualType T2 = NextParam(F2, I2, I == 0);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9574) if (!T1.isNull() && !T1.isNull() && !Context.hasSameUnqualifiedType(T1, T2))
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9575) return false;
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9576) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9577) return true;
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9578) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9579)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9580) /// isBetterOverloadCandidate - Determines whether the first overload
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9581) /// candidate is a better candidate than the second (C++ 13.3.3p1).
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9582) bool clang::isBetterOverloadCandidate(
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9583) Sema &S, const OverloadCandidate &Cand1, const OverloadCandidate &Cand2,
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9584) SourceLocation Loc, OverloadCandidateSet::CandidateSetKind Kind) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9585) // Define viable functions to be better candidates than non-viable
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9586) // functions.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9587) if (!Cand2.Viable)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9588) return Cand1.Viable;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9589) else if (!Cand1.Viable)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9590) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9591)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9592) // [CUDA] A function with 'never' preference is marked not viable, therefore
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9593) // is never shown up here. The worst preference shown up here is 'wrong side',
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9594) // e.g. an H function called by a HD function in device compilation. This is
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9595) // valid AST as long as the HD function is not emitted, e.g. it is an inline
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9596) // function which is called only by an H function. A deferred diagnostic will
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9597) // be triggered if it is emitted. However a wrong-sided function is still
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9598) // a viable candidate here.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9599) //
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9600) // If Cand1 can be emitted and Cand2 cannot be emitted in the current
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9601) // context, Cand1 is better than Cand2. If Cand1 can not be emitted and Cand2
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9602) // can be emitted, Cand1 is not better than Cand2. This rule should have
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9603) // precedence over other rules.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9604) //
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9605) // If both Cand1 and Cand2 can be emitted, or neither can be emitted, then
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9606) // other rules should be used to determine which is better. This is because
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9607) // host/device based overloading resolution is mostly for determining
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9608) // viability of a function. If two functions are both viable, other factors
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9609) // should take precedence in preference, e.g. the standard-defined preferences
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9610) // like argument conversion ranks or enable_if partial-ordering. The
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9611) // preference for pass-object-size parameters is probably most similar to a
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9612) // type-based-overloading decision and so should take priority.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9613) //
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9614) // If other rules cannot determine which is better, CUDA preference will be
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9615) // used again to determine which is better.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9616) //
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9617) // TODO: Currently IdentifyCUDAPreference does not return correct values
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9618) // for functions called in global variable initializers due to missing
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9619) // correct context about device/host. Therefore we can only enforce this
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9620) // rule when there is a caller. We should enforce this rule for functions
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9621) // in global variable initializers once proper context is added.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9622) //
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9623) // TODO: We can only enable the hostness based overloading resolution when
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9624) // -fgpu-exclude-wrong-side-overloads is on since this requires deferring
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9625) // overloading resolution diagnostics.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9626) if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function &&
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9627) S.getLangOpts().GPUExcludeWrongSideOverloads) {
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9628) if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext)) {
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9629) bool IsCallerImplicitHD = Sema::isCUDAImplicitHostDeviceFunction(Caller);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9630) bool IsCand1ImplicitHD =
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9631) Sema::isCUDAImplicitHostDeviceFunction(Cand1.Function);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9632) bool IsCand2ImplicitHD =
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9633) Sema::isCUDAImplicitHostDeviceFunction(Cand2.Function);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9634) auto P1 = S.IdentifyCUDAPreference(Caller, Cand1.Function);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9635) auto P2 = S.IdentifyCUDAPreference(Caller, Cand2.Function);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9636) assert(P1 != Sema::CFP_Never && P2 != Sema::CFP_Never);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9637) // The implicit HD function may be a function in a system header which
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9638) // is forced by pragma. In device compilation, if we prefer HD candidates
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9639) // over wrong-sided candidates, overloading resolution may change, which
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9640) // may result in non-deferrable diagnostics. As a workaround, we let
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9641) // implicit HD candidates take equal preference as wrong-sided candidates.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9642) // This will preserve the overloading resolution.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9643) // TODO: We still need special handling of implicit HD functions since
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9644) // they may incur other diagnostics to be deferred. We should make all
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9645) // host/device related diagnostics deferrable and remove special handling
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9646) // of implicit HD functions.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9647) auto EmitThreshold =
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9648) (S.getLangOpts().CUDAIsDevice && IsCallerImplicitHD &&
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9649) (IsCand1ImplicitHD || IsCand2ImplicitHD))
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9650) ? Sema::CFP_Never
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9651) : Sema::CFP_WrongSide;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9652) auto Cand1Emittable = P1 > EmitThreshold;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9653) auto Cand2Emittable = P2 > EmitThreshold;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9654) if (Cand1Emittable && !Cand2Emittable)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9655) return true;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9656) if (!Cand1Emittable && Cand2Emittable)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9657) return false;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9658) }
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9659) }
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9660)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9661) // C++ [over.match.best]p1:
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9662) //
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9663) // -- if F is a static member function, ICS1(F) is defined such
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9664) // that ICS1(F) is neither better nor worse than ICS1(G) for
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9665) // any function G, and, symmetrically, ICS1(G) is neither
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9666) // better nor worse than ICS1(F).
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9667) unsigned StartArg = 0;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9668) if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9669) StartArg = 1;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9670)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9671) auto IsIllFormedConversion = [&](const ImplicitConversionSequence &ICS) {
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9672) // We don't allow incompatible pointer conversions in C++.
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9673) if (!S.getLangOpts().CPlusPlus)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9674) return ICS.isStandard() &&
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9675) ICS.Standard.Second == ICK_Incompatible_Pointer_Conversion;
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9676)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9677) // The only ill-formed conversion we allow in C++ is the string literal to
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9678) // char* conversion, which is only considered ill-formed after C++11.
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9679) return S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9680) hasDeprecatedStringLiteralToCharPtrConversion(ICS);
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9681) };
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9682)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9683) // Define functions that don't require ill-formed conversions for a given
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9684) // argument to be better candidates than functions that do.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 9685) unsigned NumArgs = Cand1.Conversions.size();
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 9686) assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch");
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9687) bool HasBetterConversion = false;
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9688) for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9689) bool Cand1Bad = IsIllFormedConversion(Cand1.Conversions[ArgIdx]);
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9690) bool Cand2Bad = IsIllFormedConversion(Cand2.Conversions[ArgIdx]);
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9691) if (Cand1Bad != Cand2Bad) {
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9692) if (Cand1Bad)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9693) return false;
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9694) HasBetterConversion = true;
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9695) }
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9696) }
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9697)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9698) if (HasBetterConversion)
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9699) return true;
+fbad5b2f1b7df (George Burgess IV 2016-09-07 20:03:19 +0000 9700)
+d3cb356d14680 (Douglas Gregor 2009-07-07 23:38:56 +0000 9701) // C++ [over.match.best]p1:
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 9702) // A viable function F1 is defined to be a better function than another
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 9703) // viable function F2 if for all arguments i, ICSi(F1) is not a worse
+d3cb356d14680 (Douglas Gregor 2009-07-07 23:38:56 +0000 9704) // conversion sequence than ICSi(F2), and then...
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9705) bool HasWorseConversion = false;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 9706) for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 9707) switch (CompareImplicitConversionSequences(S, Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 9708) Cand1.Conversions[ArgIdx],
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9709) Cand2.Conversions[ArgIdx])) {
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9710) case ImplicitConversionSequence::Better:
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9711) // Cand1 has a better conversion sequence.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9712) HasBetterConversion = true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9713) break;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9714)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9715) case ImplicitConversionSequence::Worse:
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9716) if (Cand1.Function && Cand2.Function &&
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9717) Cand1.isReversed() != Cand2.isReversed() &&
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9718) haveSameParameterTypes(S.Context, Cand1.Function, Cand2.Function,
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9719) NumArgs)) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9720) // Work around large-scale breakage caused by considering reversed
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9721) // forms of operator== in C++20:
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9722) //
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9723) // When comparing a function against a reversed function with the same
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9724) // parameter types, if we have a better conversion for one argument and
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9725) // a worse conversion for the other, the implicit conversion sequences
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9726) // are treated as being equally good.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9727) //
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9728) // This prevents a comparison function from being considered ambiguous
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9729) // with a reversed form that is written in the same way.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9730) //
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9731) // We diagnose this as an extension from CreateOverloadedBinOp.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9732) HasWorseConversion = true;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9733) break;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9734) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9735)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9736) // Cand1 can't be better than Cand2.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9737) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9738)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9739) case ImplicitConversionSequence::Indistinguishable:
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9740) // Do nothing.
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9741) break;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9742) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9743) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9744)
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 9745) // -- for some argument j, ICSj(F1) is a better conversion sequence than
+d3cb356d14680 (Douglas Gregor 2009-07-07 23:38:56 +0000 9746) // ICSj(F2), or, if not that,
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 9747) if (HasBetterConversion && !HasWorseConversion)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9748) return true;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9749)
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9750) // -- the context is an initialization by user-defined conversion
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9751) // (see 8.5, 13.3.1.5) and the standard conversion sequence
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9752) // from the return type of F1 to the destination type (i.e.,
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9753) // the type of the entity being initialized) is a better
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9754) // conversion sequence than the standard conversion sequence
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9755) // from the return type of F2 to the destination type.
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9756) if (Kind == OverloadCandidateSet::CSK_InitByUserDefinedConversion &&
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9757) Cand1.Function && Cand2.Function &&
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 9758) isa<CXXConversionDecl>(Cand1.Function) &&
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9759) isa<CXXConversionDecl>(Cand2.Function)) {
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 9760) // First check whether we prefer one of the conversion functions over the
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 9761) // other. This only distinguishes the results in non-standard, extension
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 9762) // cases such as the conversion from a lambda closure type to a function
+2837aa2932710 (Douglas Gregor 2012-02-22 17:32:19 +0000 9763) // pointer or block.
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9764) ImplicitConversionSequence::CompareKind Result =
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9765) compareConversionFunctions(S, Cand1.Function, Cand2.Function);
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9766) if (Result == ImplicitConversionSequence::Indistinguishable)
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 9767) Result = CompareStandardConversionSequences(S, Loc,
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9768) Cand1.FinalConversion,
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9769) Cand2.FinalConversion);
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9770)
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9771) if (Result != ImplicitConversionSequence::Indistinguishable)
+ec2748a8ad627 (Richard Smith 2014-05-17 04:36:39 +0000 9772) return Result == ImplicitConversionSequence::Better;
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9773)
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9774) // FIXME: Compare kind of reference binding if conversion functions
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9775) // convert to a reference type used in direct reference binding, per
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9776) // C++14 [over.match.best]p1 section 2 bullet 3.
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9777) }
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9778)
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9779) // FIXME: Work around a defect in the C++17 guaranteed copy elision wording,
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9780) // as combined with the resolution to CWG issue 243.
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9781) //
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9782) // When the context is initialization by constructor ([over.match.ctor] or
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9783) // either phase of [over.match.list]), a constructor is preferred over
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9784) // a conversion function.
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9785) if (Kind == OverloadCandidateSet::CSK_InitByConstructor && NumArgs == 1 &&
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9786) Cand1.Function && Cand2.Function &&
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9787) isa<CXXConstructorDecl>(Cand1.Function) !=
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9788) isa<CXXConstructorDecl>(Cand2.Function))
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9789) return isa<CXXConstructorDecl>(Cand1.Function);
+5173136a96854 (Richard Smith 2017-11-01 01:37:11 +0000 9790)
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9791) // -- F1 is a non-template function and F2 is a function template
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9792) // specialization, or, if not that,
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9793) bool Cand1IsSpecialization = Cand1.Function &&
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9794) Cand1.Function->getPrimaryTemplate();
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9795) bool Cand2IsSpecialization = Cand2.Function &&
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9796) Cand2.Function->getPrimaryTemplate();
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9797) if (Cand1IsSpecialization != Cand2IsSpecialization)
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9798) return Cand2IsSpecialization;
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9799)
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9800) // -- F1 and F2 are function template specializations, and the function
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9801) // template for F1 is more specialized than the template for F2
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9802) // according to the partial ordering rules described in 14.5.5.2, or,
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9803) // if not that,
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9804) if (Cand1IsSpecialization && Cand2IsSpecialization) {
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9805) if (FunctionTemplateDecl *BetterTemplate = S.getMoreSpecializedTemplate(
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9806) Cand1.Function->getPrimaryTemplate(),
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9807) Cand2.Function->getPrimaryTemplate(), Loc,
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9808) isa<CXXConversionDecl>(Cand1.Function) ? TPOC_Conversion
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9809) : TPOC_Call,
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9810) Cand1.ExplicitCallArguments, Cand2.ExplicitCallArguments,
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 9811) Cand1.isReversed() ^ Cand2.isReversed()))
+6fdeaabda9f7d (Richard Smith 2014-05-17 01:58:45 +0000 9812) return BetterTemplate == Cand1.Function->getPrimaryTemplate();
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9813) }
+a1f013e8edb82 (Douglas Gregor 2008-11-07 22:36:19 +0000 9814)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9815) // -— F1 and F2 are non-template functions with the same
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9816) // parameter-type-lists, and F1 is more constrained than F2 [...],
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9817) if (Cand1.Function && Cand2.Function && !Cand1IsSpecialization &&
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9818) !Cand2IsSpecialization && Cand1.Function->hasPrototype() &&
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9819) Cand2.Function->hasPrototype()) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9820) auto *PT1 = cast<FunctionProtoType>(Cand1.Function->getFunctionType());
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9821) auto *PT2 = cast<FunctionProtoType>(Cand2.Function->getFunctionType());
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9822) if (PT1->getNumParams() == PT2->getNumParams() &&
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9823) PT1->isVariadic() == PT2->isVariadic() &&
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9824) S.FunctionParamTypesAreEqual(PT1, PT2)) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9825) Expr *RC1 = Cand1.Function->getTrailingRequiresClause();
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9826) Expr *RC2 = Cand2.Function->getTrailingRequiresClause();
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9827) if (RC1 && RC2) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9828) bool AtLeastAsConstrained1, AtLeastAsConstrained2;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9829) if (S.IsAtLeastAsConstrained(Cand1.Function, {RC1}, Cand2.Function,
+cfacf9ae20b8c (Richard Smith 2020-02-04 12:20:34 -0800 9830) {RC2}, AtLeastAsConstrained1) ||
+cfacf9ae20b8c (Richard Smith 2020-02-04 12:20:34 -0800 9831) S.IsAtLeastAsConstrained(Cand2.Function, {RC2}, Cand1.Function,
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9832) {RC1}, AtLeastAsConstrained2))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9833) return false;
+cfacf9ae20b8c (Richard Smith 2020-02-04 12:20:34 -0800 9834) if (AtLeastAsConstrained1 != AtLeastAsConstrained2)
+cfacf9ae20b8c (Richard Smith 2020-02-04 12:20:34 -0800 9835) return AtLeastAsConstrained1;
+cfacf9ae20b8c (Richard Smith 2020-02-04 12:20:34 -0800 9836) } else if (RC1 || RC2) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9837) return RC1 != nullptr;
+cfacf9ae20b8c (Richard Smith 2020-02-04 12:20:34 -0800 9838) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9839) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9840) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 9841)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9842) // -- F1 is a constructor for a class D, F2 is a constructor for a base
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9843) // class B of D, and for all arguments the corresponding parameters of
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9844) // F1 and F2 have the same type.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9845) // FIXME: Implement the "all parameters have the same type" check.
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9846) bool Cand1IsInherited =
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9847) dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand1.FoundDecl.getDecl());
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9848) bool Cand2IsInherited =
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9849) dyn_cast_or_null<ConstructorUsingShadowDecl>(Cand2.FoundDecl.getDecl());
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9850) if (Cand1IsInherited != Cand2IsInherited)
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9851) return Cand2IsInherited;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9852) else if (Cand1IsInherited) {
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9853) assert(Cand2IsInherited);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9854) auto *Cand1Class = cast<CXXRecordDecl>(Cand1.Function->getDeclContext());
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9855) auto *Cand2Class = cast<CXXRecordDecl>(Cand2.Function->getDeclContext());
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9856) if (Cand1Class->isDerivedFrom(Cand2Class))
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9857) return true;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9858) if (Cand2Class->isDerivedFrom(Cand1Class))
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9859) return false;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9860) // Inherited from sibling base classes: still ambiguous.
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9861) }
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 9862)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9863) // -- F2 is a rewritten candidate (12.4.1.2) and F1 is not
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9864) // -- F1 and F2 are rewritten candidates, and F2 is a synthesized candidate
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9865) // with reversed order of parameters and F1 is not
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9866) //
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9867) // We rank reversed +
diff erent operator as worse than just reversed, but
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9868) // that comparison can never happen, because we only consider reversing for
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9869) // the maximally-rewritten operator (== or <=>).
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9870) if (Cand1.RewriteKind != Cand2.RewriteKind)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9871) return Cand1.RewriteKind < Cand2.RewriteKind;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 9872)
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9873) // Check C++17 tie-breakers for deduction guides.
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9874) {
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9875) auto *Guide1 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand1.Function);
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9876) auto *Guide2 = dyn_cast_or_null<CXXDeductionGuideDecl>(Cand2.Function);
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9877) if (Guide1 && Guide2) {
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9878) // -- F1 is generated from a deduction-guide and F2 is not
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9879) if (Guide1->isImplicit() != Guide2->isImplicit())
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9880) return Guide2->isImplicit();
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9881)
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9882) // -- F1 is the copy deduction candidate(16.3.1.8) and F2 is not
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9883) if (Guide1->isCopyDeductionCandidate())
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9884) return true;
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9885) }
+81b756e6a3e49 (Faisal Vali 2017-10-22 14:45:08 +0000 9886) }
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9887)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 9888) // Check for enable_if value-based overload resolution.
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9889) if (Cand1.Function && Cand2.Function) {
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9890) Comparison Cmp = compareEnableIfAttrs(S, Cand1.Function, Cand2.Function);
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9891) if (Cmp != Comparison::Equal)
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9892) return Cmp == Comparison::Better;
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 9893) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 9894)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 9895) bool HasPS1 = Cand1.Function != nullptr &&
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 9896) functionHasPassObjectSizeParams(Cand1.Function);
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 9897) bool HasPS2 = Cand2.Function != nullptr &&
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 9898) functionHasPassObjectSizeParams(Cand2.Function);
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9899) if (HasPS1 != HasPS2 && HasPS1)
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9900) return true;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 9901)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9902) auto MV = isBetterMultiversionCandidate(Cand1, Cand2);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9903) if (MV == Comparison::Better)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9904) return true;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9905) if (MV == Comparison::Worse)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9906) return false;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9907)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9908) // If other rules cannot determine which is better, CUDA preference is used
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9909) // to determine which is better.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9910) if (S.getLangOpts().CUDA && Cand1.Function && Cand2.Function) {
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9911) FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9912) return S.IdentifyCUDAPreference(Caller, Cand1.Function) >
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9913) S.IdentifyCUDAPreference(Caller, Cand2.Function);
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9914) }
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9915)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 9916) return false;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9917) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 9918)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9919) /// Determine whether two declarations are "equivalent" for the purposes of
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9920) /// name lookup and overload resolution. This applies when the same internal/no
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9921) /// linkage entity is defined by two modules (probably by textually including
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9922) /// the same header). In such a case, we don't consider the declarations to
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9923) /// declare the same entity, but we also don't want lookups with both
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9924) /// declarations visible to be ambiguous in some cases (this happens when using
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9925) /// a modularized libstdc++).
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9926) bool Sema::isEquivalentInternalLinkageDeclaration(const NamedDecl *A,
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9927) const NamedDecl *B) {
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9928) auto *VA = dyn_cast_or_null<ValueDecl>(A);
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9929) auto *VB = dyn_cast_or_null<ValueDecl>(B);
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9930) if (!VA || !VB)
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9931) return false;
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9932)
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9933) // The declarations must be declaring the same name as an internal linkage
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9934) // entity in
diff erent modules.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9935) if (!VA->getDeclContext()->getRedeclContext()->Equals(
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9936) VB->getDeclContext()->getRedeclContext()) ||
+7af67259cdd66 (Simon Pilgrim 2020-01-13 14:28:49 +0000 9937) getOwningModule(VA) == getOwningModule(VB) ||
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9938) VA->isExternallyVisible() || VB->isExternallyVisible())
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9939) return false;
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9940)
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9941) // Check that the declarations appear to be equivalent.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9942) //
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9943) // FIXME: Checking the type isn't really enough to resolve the ambiguity.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9944) // For constants and functions, we should check the initializer or body is
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9945) // the same. For non-constant variables, we shouldn't allow it at all.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9946) if (Context.hasSameType(VA->getType(), VB->getType()))
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9947) return true;
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9948)
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9949) // Enum constants within unnamed enumerations will have
diff erent types, but
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9950) // may still be similar enough to be interchangeable for our purposes.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9951) if (auto *EA = dyn_cast<EnumConstantDecl>(VA)) {
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9952) if (auto *EB = dyn_cast<EnumConstantDecl>(VB)) {
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9953) // Only handle anonymous enums. If the enumerations were named and
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9954) // equivalent, they would have been merged to the same type.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9955) auto *EnumA = cast<EnumDecl>(EA->getDeclContext());
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9956) auto *EnumB = cast<EnumDecl>(EB->getDeclContext());
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9957) if (EnumA->hasNameForLinkage() || EnumB->hasNameForLinkage() ||
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9958) !Context.hasSameType(EnumA->getIntegerType(),
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9959) EnumB->getIntegerType()))
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9960) return false;
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9961) // Allow this only if the value is the same for both enumerators.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9962) return llvm::APSInt::isSameValue(EA->getInitVal(), EB->getInitVal());
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9963) }
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9964) }
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9965)
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9966) // Nothing else is sufficiently similar.
+26210db67f218 (Richard Smith 2015-11-13 03:52:13 +0000 9967) return false;
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9968) }
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9969)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9970) void Sema::diagnoseEquivalentInternalLinkageDeclarations(
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9971) SourceLocation Loc, const NamedDecl *D, ArrayRef<const NamedDecl *> Equiv) {
+feb0b4ec0a448 (Simon Pilgrim 2021-01-26 15:51:49 +0000 9972) assert(D && "Unknown declaration");
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9973) Diag(Loc, diag::ext_equivalent_internal_linkage_decl_in_modules) << D;
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9974)
+7af67259cdd66 (Simon Pilgrim 2020-01-13 14:28:49 +0000 9975) Module *M = getOwningModule(D);
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9976) Diag(D->getLocation(), diag::note_equivalent_internal_linkage_decl)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9977) << !M << (M ? M->getFullModuleName() : "");
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9978)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9979) for (auto *E : Equiv) {
+7af67259cdd66 (Simon Pilgrim 2020-01-13 14:28:49 +0000 9980) Module *M = getOwningModule(E);
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9981) Diag(E->getLocation(), diag::note_equivalent_internal_linkage_decl)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9982) << !M << (M ? M->getFullModuleName() : "");
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 9983) }
+896c66ecc64e9 (Richard Smith 2015-10-21 07:13:52 +0000 9984) }
+896c66ecc64e9 (Richard Smith 2015-10-21 07:13:52 +0000 9985)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 9986) /// Computes the best viable function (C++ 13.3.3)
+c9c02ed8f499f (Douglas Gregor 2009-06-19 23:52:42 +0000 9987) /// within an overload candidate set.
+c9c02ed8f499f (Douglas Gregor 2009-06-19 23:52:42 +0000 9988) ///
+ffad8b75e53ff (James Dennett 2012-06-22 08:10:18 +0000 9989) /// \param Loc The location of the function name (or operator symbol) for
+c9c02ed8f499f (Douglas Gregor 2009-06-19 23:52:42 +0000 9990) /// which overload resolution occurs.
+c9c02ed8f499f (Douglas Gregor 2009-06-19 23:52:42 +0000 9991) ///
+ffad8b75e53ff (James Dennett 2012-06-22 08:10:18 +0000 9992) /// \param Best If overload resolution was successful or found a deleted
+ffad8b75e53ff (James Dennett 2012-06-22 08:10:18 +0000 9993) /// function, \p Best points to the candidate function found.
+c9c02ed8f499f (Douglas Gregor 2009-06-19 23:52:42 +0000 9994) ///
+c9c02ed8f499f (Douglas Gregor 2009-06-19 23:52:42 +0000 9995) /// \returns The result of overload resolution.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 9996) OverloadingResult
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 9997) OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc,
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 9998) iterator &Best) {
+186091094ae7c (Artem Belevich 2016-02-12 18:29:18 +0000 9999) llvm::SmallVector<OverloadCandidate *, 16> Candidates;
+186091094ae7c (Artem Belevich 2016-02-12 18:29:18 +0000 10000) std::transform(begin(), end(), std::back_inserter(Candidates),
+186091094ae7c (Artem Belevich 2016-02-12 18:29:18 +0000 10001) [](OverloadCandidate &Cand) { return &Cand; });
+186091094ae7c (Artem Belevich 2016-02-12 18:29:18 +0000 10002)
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10003) // [CUDA] HD->H or HD->D calls are technically not allowed by CUDA but
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10004) // are accepted by both clang and NVCC. However, during a particular
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10005) // compilation mode only one call variant is viable. We need to
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10006) // exclude non-viable overload candidates from consideration based
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10007) // only on their host/device attributes. Specifically, if one
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10008) // candidate call is WrongSide and the other is SameSide, we ignore
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10009) // the WrongSide candidate.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 10010) // We only need to remove wrong-sided candidates here if
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 10011) // -fgpu-exclude-wrong-side-overloads is off. When
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 10012) // -fgpu-exclude-wrong-side-overloads is on, all candidates are compared
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 10013) // uniformly in isBetterOverloadCandidate.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 10014) if (S.getLangOpts().CUDA && !S.getLangOpts().GPUExcludeWrongSideOverloads) {
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10015) const FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext);
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10016) bool ContainsSameSideCandidate =
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10017) llvm::any_of(Candidates, [&](OverloadCandidate *Cand) {
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10018) // Check viable function only.
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10019) return Cand->Viable && Cand->Function &&
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10020) S.IdentifyCUDAPreference(Caller, Cand->Function) ==
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10021) Sema::CFP_SameSide;
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10022) });
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10023) if (ContainsSameSideCandidate) {
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10024) auto IsWrongSideCandidate = [&](OverloadCandidate *Cand) {
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10025) // Check viable function only to avoid unnecessary data copying/moving.
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10026) return Cand->Viable && Cand->Function &&
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10027) S.IdentifyCUDAPreference(Caller, Cand->Function) ==
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10028) Sema::CFP_WrongSide;
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10029) };
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10030) llvm::erase_if(Candidates, IsWrongSideCandidate);
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10031) }
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10032) }
+dfc0d9475556c (Fangrui Song 2020-06-10 17:40:04 -0700 10033)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10034) // Find the best viable function.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10035) Best = end();
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10036) for (auto *Cand : Candidates) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10037) Cand->Best = false;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10038) if (Cand->Viable)
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 10039) if (Best == end() ||
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 10040) isBetterOverloadCandidate(S, *Cand, *Best, Loc, Kind))
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10041) Best = Cand;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10042) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10043)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10044) // If we didn't find any viable functions, abort.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10045) if (Best == end())
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10046) return OR_No_Viable_Function;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10047)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 10048) llvm::SmallVector<const NamedDecl *, 4> EquivalentCands;
+896c66ecc64e9 (Richard Smith 2015-10-21 07:13:52 +0000 10049)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10050) llvm::SmallVector<OverloadCandidate*, 4> PendingBest;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10051) PendingBest.push_back(&*Best);
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10052) Best->Best = true;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10053)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10054) // Make sure that this function is better than every other viable
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10055) // function. If not, we have an ambiguity.
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10056) while (!PendingBest.empty()) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10057) auto *Curr = PendingBest.pop_back_val();
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10058) for (auto *Cand : Candidates) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10059) if (Cand->Viable && !Cand->Best &&
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10060) !isBetterOverloadCandidate(S, *Curr, *Cand, Loc, Kind)) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10061) PendingBest.push_back(Cand);
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10062) Cand->Best = true;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10063)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10064) if (S.isEquivalentInternalLinkageDeclaration(Cand->Function,
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10065) Curr->Function))
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10066) EquivalentCands.push_back(Cand->Function);
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10067) else
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10068) Best = end();
+896c66ecc64e9 (Richard Smith 2015-10-21 07:13:52 +0000 10069) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 10070) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10071) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 10072)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10073) // If we found more than one best candidate, this is ambiguous.
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10074) if (Best == end())
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10075) return OR_Ambiguous;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 10076)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10077) // Best is the best viable function.
+13ee62f7d7eed (Erik Pilkington 2019-03-20 19:26:33 +0000 10078) if (Best->Function && Best->Function->isDeleted())
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 10079) return OR_Deleted;
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 10080)
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 10081) if (!EquivalentCands.empty())
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 10082) S.diagnoseEquivalentInternalLinkageDeclarations(Loc, Best->Function,
+2dbe4043e8f54 (Richard Smith 2015-11-04 19:26:32 +0000 10083) EquivalentCands);
+896c66ecc64e9 (Richard Smith 2015-10-21 07:13:52 +0000 10084)
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10085) return OR_Success;
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10086) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 10087)
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10088) namespace {
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10089)
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10090) enum OverloadCandidateKind {
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10091) oc_function,
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10092) oc_method,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10093) oc_reversed_binary_operator,
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10094) oc_constructor,
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10095) oc_implicit_default_constructor,
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10096) oc_implicit_copy_constructor,
+119c10ef231ee (Alexis Hunt 2011-05-25 23:16:36 +0000 10097) oc_implicit_move_constructor,
+0890502f44a1f (Sebastian Redl 2011-02-05 19:23:19 +0000 10098) oc_implicit_copy_assignment,
+119c10ef231ee (Alexis Hunt 2011-05-25 23:16:36 +0000 10099) oc_implicit_move_assignment,
+bc24014b9765a (Richard Smith 2019-12-10 16:45:02 -0800 10100) oc_implicit_equality_comparison,
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10101) oc_inherited_constructor
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10102) };
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10103)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10104) enum OverloadCandidateSelect {
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10105) ocs_non_template,
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10106) ocs_template,
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10107) ocs_described_template,
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10108) };
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10109)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10110) static std::pair<OverloadCandidateKind, OverloadCandidateSelect>
+d66d37cbd96f3 (George Burgess IV 2016-10-28 21:42:06 +0000 10111) ClassifyOverloadCandidate(Sema &S, NamedDecl *Found, FunctionDecl *Fn,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10112) OverloadCandidateRewriteKind CRK,
+d66d37cbd96f3 (George Burgess IV 2016-10-28 21:42:06 +0000 10113) std::string &Description) {
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10114)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10115) bool isTemplate = Fn->isTemplateDecl() || Found->isTemplateDecl();
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10116) if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) {
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10117) isTemplate = true;
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10118) Description = S.getTemplateArgumentBindingsText(
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10119) FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs());
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10120) }
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10121)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10122) OverloadCandidateSelect Select = [&]() {
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10123) if (!Description.empty())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10124) return ocs_described_template;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10125) return isTemplate ? ocs_template : ocs_non_template;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10126) }();
+0890502f44a1f (Sebastian Redl 2011-02-05 19:23:19 +0000 10127)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10128) OverloadCandidateKind Kind = [&]() {
+bc24014b9765a (Richard Smith 2019-12-10 16:45:02 -0800 10129) if (Fn->isImplicit() && Fn->getOverloadedOperator() == OO_EqualEqual)
+bc24014b9765a (Richard Smith 2019-12-10 16:45:02 -0800 10130) return oc_implicit_equality_comparison;
+bc24014b9765a (Richard Smith 2019-12-10 16:45:02 -0800 10131)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10132) if (CRK & CRK_Reversed)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10133) return oc_reversed_binary_operator;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10134)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10135) if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) {
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10136) if (!Ctor->isImplicit()) {
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10137) if (isa<ConstructorUsingShadowDecl>(Found))
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10138) return oc_inherited_constructor;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10139) else
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10140) return oc_constructor;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10141) }
+119c10ef231ee (Alexis Hunt 2011-05-25 23:16:36 +0000 10142)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10143) if (Ctor->isDefaultConstructor())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10144) return oc_implicit_default_constructor;
+119c10ef231ee (Alexis Hunt 2011-05-25 23:16:36 +0000 10145)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10146) if (Ctor->isMoveConstructor())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10147) return oc_implicit_move_constructor;
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10148)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10149) assert(Ctor->isCopyConstructor() &&
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10150) "unexpected sort of implicit constructor");
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10151) return oc_implicit_copy_constructor;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10152) }
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10153)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10154) if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) {
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10155) // This actually gets spelled 'candidate function' for now, but
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10156) // it doesn't hurt to split it out.
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10157) if (!Meth->isImplicit())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10158) return oc_method;
+119c10ef231ee (Alexis Hunt 2011-05-25 23:16:36 +0000 10159)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10160) if (Meth->isMoveAssignmentOperator())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10161) return oc_implicit_move_assignment;
+12695101ec453 (Douglas Gregor 2012-02-10 08:36:38 +0000 10162)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10163) if (Meth->isCopyAssignmentOperator())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10164) return oc_implicit_copy_assignment;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10165)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10166) assert(isa<CXXConversionDecl>(Meth) && "expected conversion");
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10167) return oc_method;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10168) }
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10169)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10170) return oc_function;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10171) }();
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10172)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10173) return std::make_pair(Kind, Select);
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10174) }
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10175)
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10176) void MaybeEmitInheritedConstructorNote(Sema &S, Decl *FoundDecl) {
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10177) // FIXME: It'd be nice to only emit a note once per using-decl per overload
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10178) // set.
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10179) if (auto *Shadow = dyn_cast<ConstructorUsingShadowDecl>(FoundDecl))
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10180) S.Diag(FoundDecl->getLocation(),
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10181) diag::note_ovl_candidate_inherited_constructor)
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10182) << Shadow->getNominatedBaseClass();
+0890502f44a1f (Sebastian Redl 2011-02-05 19:23:19 +0000 10183) }
+0890502f44a1f (Sebastian Redl 2011-02-05 19:23:19 +0000 10184)
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10185) } // end anonymous namespace
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10186)
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10187) static bool isFunctionAlwaysEnabled(const ASTContext &Ctx,
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10188) const FunctionDecl *FD) {
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10189) for (auto *EnableIf : FD->specific_attrs<EnableIfAttr>()) {
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10190) bool AlwaysTrue;
+04323c24a1ac9 (Dmitri Gribenko 2019-05-17 17:16:53 +0000 10191) if (EnableIf->getCond()->isValueDependent() ||
+04323c24a1ac9 (Dmitri Gribenko 2019-05-17 17:16:53 +0000 10192) !EnableIf->getCond()->EvaluateAsBooleanCondition(AlwaysTrue, Ctx))
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10193) return false;
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10194) if (!AlwaysTrue)
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10195) return false;
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10196) }
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10197) return true;
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10198) }
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10199)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 10200) /// Returns true if we can take the address of the function.
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10201) ///
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10202) /// \param Complain - If true, we'll emit a diagnostic
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10203) /// \param InOverloadResolution - For the purposes of emitting a diagnostic, are
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10204) /// we in overload resolution?
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10205) /// \param Loc - The location of the statement we're complaining about. Ignored
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10206) /// if we're not complaining, or if we're in overload resolution.
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10207) static bool checkAddressOfFunctionIsAvailable(Sema &S, const FunctionDecl *FD,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10208) bool Complain,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10209) bool InOverloadResolution,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10210) SourceLocation Loc) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10211) if (!isFunctionAlwaysEnabled(S.Context, FD)) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10212) if (Complain) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10213) if (InOverloadResolution)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 10214) S.Diag(FD->getBeginLoc(),
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10215) diag::note_addrof_ovl_candidate_disabled_by_enable_if_attr);
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10216) else
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10217) S.Diag(Loc, diag::err_addrof_function_disabled_by_enable_if_attr) << FD;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10218) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10219) return false;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10220) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10221)
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 10222) if (FD->getTrailingRequiresClause()) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10223) ConstraintSatisfaction Satisfaction;
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 10224) if (S.CheckFunctionConstraints(FD, Satisfaction, Loc))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10225) return false;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10226) if (!Satisfaction.IsSatisfied) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10227) if (Complain) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10228) if (InOverloadResolution)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10229) S.Diag(FD->getBeginLoc(),
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10230) diag::note_ovl_candidate_unsatisfied_constraints);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10231) else
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10232) S.Diag(Loc, diag::err_addrof_function_constraints_not_satisfied)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10233) << FD;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10234) S.DiagnoseUnsatisfiedConstraint(Satisfaction);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10235) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10236) return false;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10237) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10238) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10239)
+21081364f84dc (George Burgess IV 2016-07-24 23:12:40 +0000 10240) auto I = llvm::find_if(FD->parameters(), [](const ParmVarDecl *P) {
+21081364f84dc (George Burgess IV 2016-07-24 23:12:40 +0000 10241) return P->hasAttr<PassObjectSizeAttr>();
+21081364f84dc (George Burgess IV 2016-07-24 23:12:40 +0000 10242) });
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10243) if (I == FD->param_end())
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10244) return true;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10245)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10246) if (Complain) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10247) // Add one to ParamNo because it's user-facing
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10248) unsigned ParamNo = std::distance(FD->param_begin(), I) + 1;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10249) if (InOverloadResolution)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10250) S.Diag(FD->getLocation(),
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10251) diag::note_ovl_candidate_has_pass_object_size_params)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10252) << ParamNo;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10253) else
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10254) S.Diag(Loc, diag::err_address_of_function_with_pass_object_size_params)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10255) << FD << ParamNo;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10256) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10257) return false;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10258) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10259)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10260) static bool checkAddressOfCandidateIsAvailable(Sema &S,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10261) const FunctionDecl *FD) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10262) return checkAddressOfFunctionIsAvailable(S, FD, /*Complain=*/true,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10263) /*InOverloadResolution=*/true,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10264) /*Loc=*/SourceLocation());
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10265) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10266)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10267) bool Sema::checkAddressOfFunctionIsAvailable(const FunctionDecl *Function,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10268) bool Complain,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10269) SourceLocation Loc) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10270) return ::checkAddressOfFunctionIsAvailable(*this, Function, Complain,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10271) /*InOverloadResolution=*/false,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10272) Loc);
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10273) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10274)
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10275) // Don't print candidates other than the one that matches the calling
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10276) // convention of the call operator, since that is guaranteed to exist.
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10277) static bool shouldSkipNotingLambdaConversionDecl(FunctionDecl *Fn) {
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10278) const auto *ConvD = dyn_cast<CXXConversionDecl>(Fn);
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10279)
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10280) if (!ConvD)
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10281) return false;
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10282) const auto *RD = cast<CXXRecordDecl>(Fn->getParent());
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10283) if (!RD->isLambda())
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10284) return false;
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10285)
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10286) CXXMethodDecl *CallOp = RD->getLambdaCallOperator();
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10287) CallingConv CallOpCC =
+2901dc7575873 (Simon Pilgrim 2021-04-06 12:04:01 +0100 10288) CallOp->getType()->castAs<FunctionType>()->getCallConv();
+2901dc7575873 (Simon Pilgrim 2021-04-06 12:04:01 +0100 10289) QualType ConvRTy = ConvD->getType()->castAs<FunctionType>()->getReturnType();
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10290) CallingConv ConvToCC =
+2901dc7575873 (Simon Pilgrim 2021-04-06 12:04:01 +0100 10291) ConvRTy->getPointeeType()->castAs<FunctionType>()->getCallConv();
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10292)
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10293) return ConvToCC != CallOpCC;
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10294) }
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10295)
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 10296) // Notes the location of an overload candidate.
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10297) void Sema::NoteOverloadCandidate(NamedDecl *Found, FunctionDecl *Fn,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10298) OverloadCandidateRewriteKind RewriteKind,
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10299) QualType DestType, bool TakingAddress) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10300) if (TakingAddress && !checkAddressOfCandidateIsAvailable(*this, Fn))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10301) return;
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 10302) if (Fn->isMultiVersion() && Fn->hasAttr<TargetAttr>() &&
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 10303) !Fn->getAttr<TargetAttr>()->isDefaultVersion())
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 10304) return;
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10305) if (shouldSkipNotingLambdaConversionDecl(Fn))
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 10306) return;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10307)
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10308) std::string FnDesc;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10309) std::pair<OverloadCandidateKind, OverloadCandidateSelect> KSPair =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10310) ClassifyOverloadCandidate(*this, Found, Fn, RewriteKind, FnDesc);
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 10311) PartialDiagnostic PD = PDiag(diag::note_ovl_candidate)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10312) << (unsigned)KSPair.first << (unsigned)KSPair.second
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10313) << Fn << FnDesc;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10314)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10315) HandleFunctionTypeMismatch(PD, Fn->getType(), DestType);
+caff247882fce (Richard Trieu 2011-11-23 22:32:32 +0000 10316) Diag(Fn->getLocation(), PD);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10317) MaybeEmitInheritedConstructorNote(*this, Found);
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10318) }
+fd0b2f8fe486f (John McCall 2010-01-06 09:43:14 +0000 10319)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10320) static void
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10321) MaybeDiagnoseAmbiguousConstraints(Sema &S, ArrayRef<OverloadCandidate> Cands) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10322) // Perhaps the ambiguity was caused by two atomic constraints that are
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10323) // 'identical' but not equivalent:
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10324) //
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10325) // void foo() requires (sizeof(T) > 4) { } // #1
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10326) // void foo() requires (sizeof(T) > 4) && T::value { } // #2
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10327) //
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10328) // The 'sizeof(T) > 4' constraints are seemingly equivalent and should cause
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10329) // #2 to subsume #1, but these constraint are not considered equivalent
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10330) // according to the subsumption rules because they are not the same
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10331) // source-level construct. This behavior is quite confusing and we should try
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10332) // to help the user figure out what happened.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10333)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10334) SmallVector<const Expr *, 3> FirstAC, SecondAC;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10335) FunctionDecl *FirstCand = nullptr, *SecondCand = nullptr;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10336) for (auto I = Cands.begin(), E = Cands.end(); I != E; ++I) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10337) if (!I->Function)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10338) continue;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10339) SmallVector<const Expr *, 3> AC;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10340) if (auto *Template = I->Function->getPrimaryTemplate())
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10341) Template->getAssociatedConstraints(AC);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10342) else
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10343) I->Function->getAssociatedConstraints(AC);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10344) if (AC.empty())
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10345) continue;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10346) if (FirstCand == nullptr) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10347) FirstCand = I->Function;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10348) FirstAC = AC;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10349) } else if (SecondCand == nullptr) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10350) SecondCand = I->Function;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10351) SecondAC = AC;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10352) } else {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10353) // We have more than one pair of constrained functions - this check is
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10354) // expensive and we'd rather not try to diagnose it.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10355) return;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10356) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10357) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10358) if (!SecondCand)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10359) return;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10360) // The diagnostic can only happen if there are associated constraints on
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10361) // both sides (there needs to be some identical atomic constraint).
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10362) if (S.MaybeEmitAmbiguousAtomicConstraintsDiagnostic(FirstCand, FirstAC,
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10363) SecondCand, SecondAC))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10364) // Just show the user one diagnostic, they'll probably figure it out
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10365) // from here.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10366) return;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10367) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 10368)
+ed4265c24e2b6 (Nick Lewycky 2013-09-22 10:06:01 +0000 10369) // Notes the location of all overload candidates designated through
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10370) // OverloadedExpr
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10371) void Sema::NoteAllOverloadCandidates(Expr *OverloadedExpr, QualType DestType,
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10372) bool TakingAddress) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10373) assert(OverloadedExpr->getType() == Context.OverloadTy);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10374)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10375) OverloadExpr::FindResult Ovl = OverloadExpr::find(OverloadedExpr);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10376) OverloadExpr *OvlExpr = Ovl.Expression;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10377)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10378) for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10379) IEnd = OvlExpr->decls_end();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10380) I != IEnd; ++I) {
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10381) if (FunctionTemplateDecl *FunTmpl =
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10382) dyn_cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()) ) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10383) NoteOverloadCandidate(*I, FunTmpl->getTemplatedDecl(), CRK_None, DestType,
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 10384) TakingAddress);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10385) } else if (FunctionDecl *Fun
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10386) = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()) ) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10387) NoteOverloadCandidate(*I, Fun, CRK_None, DestType, TakingAddress);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10388) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10389) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10390) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 10391)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 10392) /// Diagnoses an ambiguous conversion. The partial diagnostic is the
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 10393) /// "lead" diagnostic; it will be given two arguments, the source and
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 10394) /// target types of the conversion.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10395) void ImplicitConversionSequence::DiagnoseAmbiguousConversion(
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10396) Sema &S,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10397) SourceLocation CaretLoc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10398) const PartialDiagnostic &PDiag) const {
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10399) S.Diag(CaretLoc, PDiag)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 10400) << Ambiguous.getFromType() << Ambiguous.getToType();
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10401) unsigned CandsShown = 0;
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10402) AmbiguousConversionSequence::const_iterator I, E;
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10403) for (I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) {
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 10404) if (CandsShown >= S.Diags.getNumOverloadCandidatesToShow())
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10405) break;
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10406) ++CandsShown;
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10407) S.NoteOverloadCandidate(I->first, I->second);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 10408) }
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 10409) S.Diags.overloadCandidatesShown(CandsShown);
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10410) if (I != E)
+641bd89d6b5e7 (Matt Beaumont-Gay 2012-11-08 20:50:02 +0000 10411) S.Diag(SourceLocation(), diag::note_ovl_too_many_candidates) << int(E - I);
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 10412) }
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 10413)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10414) static void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10415) unsigned I, bool TakingCandidateAddress) {
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10416) const ImplicitConversionSequence &Conv = Cand->Conversions[I];
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10417) assert(Conv.isBad());
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10418) assert(Cand->Function && "for now, candidate must be a function");
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10419) FunctionDecl *Fn = Cand->Function;
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10420)
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10421) // There's a conversion slot for the object argument if this is a
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10422) // non-constructor method. Note that 'I' corresponds the
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10423) // conversion-slot index.
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10424) bool isObjectArgument = false;
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10425) if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) {
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10426) if (I == 0)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10427) isObjectArgument = true;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10428) else
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10429) I--;
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10430) }
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10431)
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10432) std::string FnDesc;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10433) std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 10434) ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn, Cand->getRewriteKind(),
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10435) FnDesc);
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10436)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10437) Expr *FromExpr = Conv.Bad.FromExpr;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10438) QualType FromTy = Conv.Bad.getFromType();
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10439) QualType ToTy = Conv.Bad.getToType();
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10440)
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10441) if (FromTy == S.Context.OverloadTy) {
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 10442) assert(FromExpr && "overload set argument came from implicit argument?");
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10443) Expr *E = FromExpr->IgnoreParens();
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10444) if (isa<UnaryOperator>(E))
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10445) E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens();
+1acbbb5a4c6e6 (John McCall 2010-02-02 06:20:04 +0000 10446) DeclarationName Name = cast<OverloadExpr>(E)->getName();
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10447)
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10448) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10449) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10450) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << ToTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10451) << Name << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10452) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10453) return;
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10454) }
+fb7ad0f57a0cb (John McCall 2010-02-02 02:42:52 +0000 10455)
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10456) // Do some hand-waving analysis to see if the non-viability is due
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10457) // to a qualifier mismatch.
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10458) CanQualType CFromTy = S.Context.getCanonicalType(FromTy);
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10459) CanQualType CToTy = S.Context.getCanonicalType(ToTy);
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10460) if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>())
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10461) CToTy = RT->getPointeeType();
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10462) else {
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10463) // TODO: detect and diagnose the full richness of const mismatches.
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10464) if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>())
+cc3949d99af2b (Richard Trieu 2016-02-18 22:34:54 +0000 10465) if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) {
+cc3949d99af2b (Richard Trieu 2016-02-18 22:34:54 +0000 10466) CFromTy = FromPT->getPointeeType();
+cc3949d99af2b (Richard Trieu 2016-02-18 22:34:54 +0000 10467) CToTy = ToPT->getPointeeType();
+cc3949d99af2b (Richard Trieu 2016-02-18 22:34:54 +0000 10468) }
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10469) }
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10470)
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10471) if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() &&
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10472) !CToTy.isAtLeastAsQualifiedAs(CFromTy)) {
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10473) Qualifiers FromQs = CFromTy.getQualifiers();
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10474) Qualifiers ToQs = CToTy.getQualifiers();
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10475)
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10476) if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) {
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10477) if (isObjectArgument)
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10478) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace_this)
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10479) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10480) << FnDesc << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10481) << FromQs.getAddressSpace() << ToQs.getAddressSpace();
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10482) else
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10483) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace)
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10484) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10485) << FnDesc << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10486) << FromQs.getAddressSpace() << ToQs.getAddressSpace()
+ed8dadb37c7e1 (Anastasia Stulova 2019-12-13 12:30:59 +0000 10487) << ToTy->isReferenceType() << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10488) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10489) return;
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10490) }
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10491)
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 10492) if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
+cff00d9c127c7 (Argyrios Kyrtzidis 2011-06-24 00:08:59 +0000 10493) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_ownership)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10494) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10495) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10496) << FromQs.getObjCLifetime() << ToQs.getObjCLifetime()
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10497) << (unsigned)isObjectArgument << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10498) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 10499) return;
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 10500) }
+31168b077c368 (John McCall 2011-06-15 23:02:42 +0000 10501)
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 10502) if (FromQs.getObjCGCAttr() != ToQs.getObjCGCAttr()) {
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 10503) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_gc)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10504) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10505) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10506) << FromQs.getObjCGCAttr() << ToQs.getObjCGCAttr()
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10507) << (unsigned)isObjectArgument << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10508) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 10509) return;
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 10510) }
+aec25847606fd (Douglas Gregor 2011-04-26 23:16:46 +0000 10511)
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 10512) if (FromQs.hasUnaligned() != ToQs.hasUnaligned()) {
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 10513) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_unaligned)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10514) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10515) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10516) << FromQs.hasUnaligned() << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10517) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 10518) return;
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 10519) }
+45d413260e82b (Andrey Bokhanko 2016-05-11 18:38:21 +0000 10520)
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10521) unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10522) assert(CVR && "expected qualifiers mismatch");
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10523)
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10524) if (isObjectArgument) {
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10525) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10526) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10527) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10528) << (CVR - 1);
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10529) } else {
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10530) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10531) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10532) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10533) << (CVR - 1) << I + 1;
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10534) }
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10535) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10536) return;
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10537) }
+47000997193cf (John McCall 2010-01-14 03:28:57 +0000 10538)
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10539) if (Conv.Bad.Kind == BadConversionSequence::lvalue_ref_to_rvalue ||
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10540) Conv.Bad.Kind == BadConversionSequence::rvalue_ref_to_lvalue) {
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10541) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_value_category)
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10542) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10543) << (unsigned)isObjectArgument << I + 1
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10544) << (Conv.Bad.Kind == BadConversionSequence::rvalue_ref_to_lvalue)
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10545) << (FromExpr ? FromExpr->getSourceRange() : SourceRange());
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10546) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10547) return;
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10548) }
+6f84779674a97 (Aaron Puchert 2020-11-15 16:11:23 +0100 10549)
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10550) // Special diagnostic for failure to convert an initializer list, since
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10551) // telling the user that it has type void is not useful.
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10552) if (FromExpr && isa<InitListExpr>(FromExpr)) {
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10553) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_list_argument)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10554) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10555) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10556) << ToTy << (unsigned)isObjectArgument << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10557) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10558) return;
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10559) }
+a72462cdf43be (Sebastian Redl 2011-09-24 17:48:32 +0000 10560)
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10561) // Diagnose references or pointers to incomplete types
diff erently,
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10562) // since it's far from impossible that the incompleteness triggered
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10563) // the failure.
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10564) QualType TempFromTy = FromTy.getNonReferenceType();
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10565) if (const PointerType *PTy = TempFromTy->getAs<PointerType>())
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10566) TempFromTy = PTy->getPointeeType();
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10567) if (TempFromTy->isIncompleteType()) {
+ac92893a93618 (David Blaikie 2016-03-04 22:29:11 +0000 10568) // Emit the generic diagnostic and, optionally, add the hints to it.
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10569) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10570) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10571) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10572) << ToTy << (unsigned)isObjectArgument << I + 1
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10573) << (unsigned)(Cand->Fix.Kind);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10574)
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10575) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10576) return;
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10577) }
+6d174646dd1a8 (John McCall 2010-01-23 08:10:49 +0000 10578)
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10579) // Diagnose base -> derived pointer conversions.
+fb0c0d37b7f2d (Douglas Gregor 2010-07-01 02:14:45 +0000 10580) unsigned BaseToDerivedConversion = 0;
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10581) if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) {
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10582) if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) {
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10583) if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10584) FromPtrTy->getPointeeType()) &&
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10585) !FromPtrTy->getPointeeType()->isIncompleteType() &&
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10586) !ToPtrTy->getPointeeType()->isIncompleteType() &&
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 10587) S.IsDerivedFrom(SourceLocation(), ToPtrTy->getPointeeType(),
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10588) FromPtrTy->getPointeeType()))
+fb0c0d37b7f2d (Douglas Gregor 2010-07-01 02:14:45 +0000 10589) BaseToDerivedConversion = 1;
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10590) }
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10591) } else if (const ObjCObjectPointerType *FromPtrTy
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10592) = FromTy->getAs<ObjCObjectPointerType>()) {
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10593) if (const ObjCObjectPointerType *ToPtrTy
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10594) = ToTy->getAs<ObjCObjectPointerType>())
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10595) if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl())
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10596) if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl())
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10597) if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs(
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10598) FromPtrTy->getPointeeType()) &&
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10599) FromIface->isSuperClassOf(ToIface))
+fb0c0d37b7f2d (Douglas Gregor 2010-07-01 02:14:45 +0000 10600) BaseToDerivedConversion = 2;
+fb0c0d37b7f2d (Douglas Gregor 2010-07-01 02:14:45 +0000 10601) } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) {
+9ea8f7e6c53fa (Kaelyn Uhrain 2012-06-19 00:37:47 +0000 10602) if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) &&
+9ea8f7e6c53fa (Kaelyn Uhrain 2012-06-19 00:37:47 +0000 10603) !FromTy->isIncompleteType() &&
+9ea8f7e6c53fa (Kaelyn Uhrain 2012-06-19 00:37:47 +0000 10604) !ToRefTy->getPointeeType()->isIncompleteType() &&
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 10605) S.IsDerivedFrom(SourceLocation(), ToRefTy->getPointeeType(), FromTy)) {
+9ea8f7e6c53fa (Kaelyn Uhrain 2012-06-19 00:37:47 +0000 10606) BaseToDerivedConversion = 3;
+fb0c0d37b7f2d (Douglas Gregor 2010-07-01 02:14:45 +0000 10607) }
+9ea8f7e6c53fa (Kaelyn Uhrain 2012-06-19 00:37:47 +0000 10608) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10609)
+fb0c0d37b7f2d (Douglas Gregor 2010-07-01 02:14:45 +0000 10610) if (BaseToDerivedConversion) {
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10611) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_base_to_derived_conv)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10612) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10613) << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10614) << (BaseToDerivedConversion - 1) << FromTy << ToTy << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10615) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10616) return;
+56f2e34a6a081 (Douglas Gregor 2010-06-30 23:01:39 +0000 10617) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10618)
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10619) if (isa<ObjCObjectPointerType>(CFromTy) &&
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10620) isa<PointerType>(CToTy)) {
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10621) Qualifiers FromQs = CFromTy.getQualifiers();
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10622) Qualifiers ToQs = CToTy.getQualifiers();
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10623) if (FromQs.getObjCLifetime() != ToQs.getObjCLifetime()) {
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10624) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_arc_conv)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10625) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10626) << FnDesc << (FromExpr ? FromExpr->getSourceRange() : SourceRange())
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10627) << FromTy << ToTy << (unsigned)isObjectArgument << I + 1;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10628) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10629) return;
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10630) }
+a644f9cb73a1b (Fariborz Jahanian 2011-07-20 17:14:09 +0000 10631) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10632)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10633) if (TakingCandidateAddress &&
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10634) !checkAddressOfCandidateIsAvailable(S, Cand->Function))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10635) return;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10636)
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10637) // Emit the generic diagnostic and, optionally, add the hints to it.
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10638) PartialDiagnostic FDiag = S.PDiag(diag::note_ovl_candidate_bad_conv);
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10639) FDiag << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10640) << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) << FromTy
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10641) << ToTy << (unsigned)isObjectArgument << I + 1
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10642) << (unsigned)(Cand->Fix.Kind);
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10643)
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10644) // If we can fix the conversion, suggest the FixIts.
+490afa6b9d1b3 (Benjamin Kramer 2012-01-14 21:05:10 +0000 10645) for (std::vector<FixItHint>::iterator HI = Cand->Fix.Hints.begin(),
+490afa6b9d1b3 (Benjamin Kramer 2012-01-14 21:05:10 +0000 10646) HE = Cand->Fix.Hints.end(); HI != HE; ++HI)
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10647) FDiag << *HI;
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10648) S.Diag(Fn->getLocation(), FDiag);
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 10649)
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10650) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10651) }
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10652)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10653) /// Additional arity mismatch diagnosis specific to a function overload
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10654) /// candidates. This is not covered by the more general DiagnoseArityMismatch()
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10655) /// over a candidate in any candidate set.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10656) static bool CheckArityMismatch(Sema &S, OverloadCandidate *Cand,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10657) unsigned NumArgs) {
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10658) FunctionDecl *Fn = Cand->Function;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10659) unsigned MinParams = Fn->getMinRequiredArguments();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10660)
+1d33f8d8a0d7e (Douglas Gregor 2011-05-05 00:13:13 +0000 10661) // With invalid overloaded operators, it's possible that we think we
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10662) // have an arity mismatch when in fact it looks like we have the
+1d33f8d8a0d7e (Douglas Gregor 2011-05-05 00:13:13 +0000 10663) // right number of arguments, because only overloaded operators have
+1d33f8d8a0d7e (Douglas Gregor 2011-05-05 00:13:13 +0000 10664) // the weird behavior of overloading member and non-member functions.
+1d33f8d8a0d7e (Douglas Gregor 2011-05-05 00:13:13 +0000 10665) // Just don't report anything.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10666) if (Fn->isInvalidDecl() &&
+1d33f8d8a0d7e (Douglas Gregor 2011-05-05 00:13:13 +0000 10667) Fn->getDeclName().getNameKind() == DeclarationName::CXXOperatorName)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10668) return true;
+8d33da6d58f34 (Larisse Voufo 2013-07-19 22:34:32 +0000 10669)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10670) if (NumArgs < MinParams) {
+47c0845e0b388 (Larisse Voufo 2013-07-19 22:53:23 +0000 10671) assert((Cand->FailureKind == ovl_fail_too_few_arguments) ||
+47c0845e0b388 (Larisse Voufo 2013-07-19 22:53:23 +0000 10672) (Cand->FailureKind == ovl_fail_bad_deduction &&
+47c0845e0b388 (Larisse Voufo 2013-07-19 22:53:23 +0000 10673) Cand->DeductionFailure.Result == Sema::TDK_TooFewArguments));
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10674) } else {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10675) assert((Cand->FailureKind == ovl_fail_too_many_arguments) ||
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10676) (Cand->FailureKind == ovl_fail_bad_deduction &&
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10677) Cand->DeductionFailure.Result == Sema::TDK_TooManyArguments));
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10678) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10679)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10680) return false;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10681) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10682)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10683) /// General arity mismatch diagnosis over a candidate in a candidate set.
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10684) static void DiagnoseArityMismatch(Sema &S, NamedDecl *Found, Decl *D,
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10685) unsigned NumFormalArgs) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10686) assert(isa<FunctionDecl>(D) &&
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10687) "The templated declaration should at least be a function"
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10688) " when diagnosing bad template argument deduction due to too many"
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10689) " or too few arguments");
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10690)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10691) FunctionDecl *Fn = cast<FunctionDecl>(D);
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 10692)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10693) // TODO: treat calls to a missing default constructor as a special case
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 10694) const auto *FnTy = Fn->getType()->castAs<FunctionProtoType>();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10695) unsigned MinParams = Fn->getMinRequiredArguments();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10696)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10697) // at least / at most / exactly
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10698) unsigned mode, modeCount;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10699) if (NumFormalArgs < MinParams) {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 10700) if (MinParams != FnTy->getNumParams() || FnTy->isVariadic() ||
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 10701) FnTy->isTemplateVariadic())
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10702) mode = 0; // "at least"
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10703) else
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10704) mode = 2; // "exactly"
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10705) modeCount = MinParams;
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10706) } else {
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 10707) if (MinParams != FnTy->getNumParams())
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10708) mode = 1; // "at most"
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10709) else
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10710) mode = 2; // "exactly"
+9cacbabd33eea (Alp Toker 2014-01-20 20:26:09 +0000 10711) modeCount = FnTy->getNumParams();
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10712) }
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10713)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10714) std::string Description;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10715) std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 10716) ClassifyOverloadCandidate(S, Found, Fn, CRK_None, Description);
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 10717)
+10ff50d7d8d61 (Richard Smith 2012-05-11 05:16:41 +0000 10718) if (modeCount == 1 && Fn->getParamDecl(0)->getDeclName())
+10ff50d7d8d61 (Richard Smith 2012-05-11 05:16:41 +0000 10719) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity_one)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10720) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10721) << Description << mode << Fn->getParamDecl(0) << NumFormalArgs;
+10ff50d7d8d61 (Richard Smith 2012-05-11 05:16:41 +0000 10722) else
+10ff50d7d8d61 (Richard Smith 2012-05-11 05:16:41 +0000 10723) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10724) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10725) << Description << mode << modeCount << NumFormalArgs;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 10726)
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10727) MaybeEmitInheritedConstructorNote(S, Found);
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10728) }
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 10729)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10730) /// Arity mismatch diagnosis specific to a function overload candidate.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10731) static void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10732) unsigned NumFormalArgs) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10733) if (!CheckArityMismatch(S, Cand, NumFormalArgs))
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10734) DiagnoseArityMismatch(S, Cand->FoundDecl, Cand->Function, NumFormalArgs);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10735) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10736)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10737) static TemplateDecl *getDescribedTemplate(Decl *Templated) {
+7dcc97e7ac0a7 (Serge Pavlov 2016-04-19 06:19:52 +0000 10738) if (TemplateDecl *TD = Templated->getDescribedTemplate())
+7dcc97e7ac0a7 (Serge Pavlov 2016-04-19 06:19:52 +0000 10739) return TD;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10740) llvm_unreachable("Unsupported: Getting the described template declaration"
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10741) " for bad deduction diagnosis");
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10742) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10743)
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10744) /// Diagnose a failed template-argument deduction.
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10745) static void DiagnoseBadDeduction(Sema &S, NamedDecl *Found, Decl *Templated,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 10746) DeductionFailureInfo &DeductionFailure,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10747) unsigned NumArgs,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10748) bool TakingCandidateAddress) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10749) TemplateParameter Param = DeductionFailure.getTemplateParameter();
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10750) NamedDecl *ParamD;
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10751) (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) ||
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10752) (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) ||
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10753) (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>());
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10754) switch (DeductionFailure.Result) {
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10755) case Sema::TDK_Success:
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10756) llvm_unreachable("TDK_success while diagnosing bad deduction");
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10757)
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10758) case Sema::TDK_Incomplete: {
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10759) assert(ParamD && "no parameter found for incomplete deduction result");
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10760) S.Diag(Templated->getLocation(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10761) diag::note_ovl_candidate_incomplete_deduction)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10762) << ParamD->getDeclName();
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10763) MaybeEmitInheritedConstructorNote(S, Found);
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10764) return;
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10765) }
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 10766)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10767) case Sema::TDK_IncompletePack: {
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10768) assert(ParamD && "no parameter found for incomplete deduction result");
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10769) S.Diag(Templated->getLocation(),
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10770) diag::note_ovl_candidate_incomplete_deduction_pack)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10771) << ParamD->getDeclName()
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10772) << (DeductionFailure.getFirstArg()->pack_size() + 1)
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10773) << *DeductionFailure.getFirstArg();
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10774) MaybeEmitInheritedConstructorNote(S, Found);
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10775) return;
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10776) }
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 10777)
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10778) case Sema::TDK_Underqualified: {
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10779) assert(ParamD && "no parameter found for bad qualifiers deduction result");
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10780) TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD);
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10781)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10782) QualType Param = DeductionFailure.getFirstArg()->getAsType();
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10783)
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10784) // Param will have been canonicalized, but it should just be a
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10785) // qualified version of ParamD, so move the qualifiers to that.
+717d9b0e2f2a8 (John McCall 2010-12-10 11:01:00 +0000 10786) QualifierCollector Qs;
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10787) Qs.strip(Param);
+717d9b0e2f2a8 (John McCall 2010-12-10 11:01:00 +0000 10788) QualType NonCanonParam = Qs.apply(S.Context, TParam->getTypeForDecl());
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10789) assert(S.Context.hasSameType(Param, NonCanonParam));
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10790)
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10791) // Arg has also been canonicalized, but there's nothing we can do
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10792) // about that. It also doesn't matter as much, because it won't
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10793) // have any template parameters in it (because deduction isn't
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10794) // done on dependent types).
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10795) QualType Arg = DeductionFailure.getSecondArg()->getAsType();
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10796)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10797) S.Diag(Templated->getLocation(), diag::note_ovl_candidate_underqualified)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10798) << ParamD->getDeclName() << Arg << NonCanonParam;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10799) MaybeEmitInheritedConstructorNote(S, Found);
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10800) return;
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10801) }
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10802)
+42d7d19710d09 (John McCall 2010-08-05 09:05:08 +0000 10803) case Sema::TDK_Inconsistent: {
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 10804) assert(ParamD && "no parameter found for inconsistent deduction result");
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10805) int which = 0;
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10806) if (isa<TemplateTypeParmDecl>(ParamD))
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10807) which = 0;
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10808) else if (isa<NonTypeTemplateParmDecl>(ParamD)) {
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10809) // Deduction might have failed because we deduced arguments of two
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10810) //
diff erent types for a non-type template parameter.
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10811) // FIXME: Use a
diff erent TDK value for this.
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10812) QualType T1 =
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10813) DeductionFailure.getFirstArg()->getNonTypeTemplateArgumentType();
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10814) QualType T2 =
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10815) DeductionFailure.getSecondArg()->getNonTypeTemplateArgumentType();
+e54d9525ad594 (Richard Smith 2018-10-09 18:49:22 +0000 10816) if (!T1.isNull() && !T2.isNull() && !S.Context.hasSameType(T1, T2)) {
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10817) S.Diag(Templated->getLocation(),
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10818) diag::note_ovl_candidate_inconsistent_deduction_types)
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10819) << ParamD->getDeclName() << *DeductionFailure.getFirstArg() << T1
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10820) << *DeductionFailure.getSecondArg() << T2;
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10821) MaybeEmitInheritedConstructorNote(S, Found);
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10822) return;
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10823) }
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10824)
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10825) which = 1;
+593d6a168f457 (Richard Smith 2016-12-23 01:30:39 +0000 10826) } else {
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10827) which = 2;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10828) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10829)
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10830) // Tweak the diagnostic if the problem is that we deduced packs of
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10831) //
diff erent arities. We'll print the actual packs anyway in case that
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10832) // includes additional useful information.
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10833) if (DeductionFailure.getFirstArg()->getKind() == TemplateArgument::Pack &&
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10834) DeductionFailure.getSecondArg()->getKind() == TemplateArgument::Pack &&
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10835) DeductionFailure.getFirstArg()->pack_size() !=
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10836) DeductionFailure.getSecondArg()->pack_size()) {
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10837) which = 3;
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10838) }
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10839)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10840) S.Diag(Templated->getLocation(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10841) diag::note_ovl_candidate_inconsistent_deduction)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10842) << which << ParamD->getDeclName() << *DeductionFailure.getFirstArg()
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10843) << *DeductionFailure.getSecondArg();
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10844) MaybeEmitInheritedConstructorNote(S, Found);
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10845) return;
+3626a5cac2edf (Douglas Gregor 2010-05-08 17:41:32 +0000 10846) }
+02eb4835ce7da (Douglas Gregor 2010-05-08 18:13:28 +0000 10847)
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10848) case Sema::TDK_InvalidExplicitArguments:
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10849) assert(ParamD && "no parameter found for invalid explicit arguments");
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10850) if (ParamD->getDeclName())
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10851) S.Diag(Templated->getLocation(),
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10852) diag::note_ovl_candidate_explicit_arg_mismatch_named)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10853) << ParamD->getDeclName();
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10854) else {
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10855) int index = 0;
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10856) if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD))
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10857) index = TTP->getIndex();
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10858) else if (NonTypeTemplateParmDecl *NTTP
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10859) = dyn_cast<NonTypeTemplateParmDecl>(ParamD))
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10860) index = NTTP->getIndex();
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10861) else
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10862) index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10863) S.Diag(Templated->getLocation(),
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10864) diag::note_ovl_candidate_explicit_arg_mismatch_unnamed)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10865) << (index + 1);
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10866) }
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10867) MaybeEmitInheritedConstructorNote(S, Found);
+1d72edd7c55a8 (Douglas Gregor 2010-05-08 19:15:54 +0000 10868) return;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10869)
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10870) case Sema::TDK_ConstraintsNotSatisfied: {
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10871) // Format the template argument list into the argument string.
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10872) SmallString<128> TemplateArgString;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10873) TemplateArgumentList *Args = DeductionFailure.getTemplateArgumentList();
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10874) TemplateArgString = " ";
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10875) TemplateArgString += S.getTemplateArgumentBindingsText(
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10876) getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10877) if (TemplateArgString.size() == 1)
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10878) TemplateArgString.clear();
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10879) S.Diag(Templated->getLocation(),
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10880) diag::note_ovl_candidate_unsatisfied_constraints)
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10881) << TemplateArgString;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10882)
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10883) S.DiagnoseUnsatisfiedConstraint(
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10884) static_cast<CNSInfo*>(DeductionFailure.Data)->Satisfaction);
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10885) return;
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 10886) }
+02eb4835ce7da (Douglas Gregor 2010-05-08 18:13:28 +0000 10887) case Sema::TDK_TooManyArguments:
+02eb4835ce7da (Douglas Gregor 2010-05-08 18:13:28 +0000 10888) case Sema::TDK_TooFewArguments:
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 10889) DiagnoseArityMismatch(S, Found, Templated, NumArgs);
+02eb4835ce7da (Douglas Gregor 2010-05-08 18:13:28 +0000 10890) return;
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10891)
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10892) case Sema::TDK_InstantiationDepth:
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10893) S.Diag(Templated->getLocation(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10894) diag::note_ovl_candidate_instantiation_depth);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10895) MaybeEmitInheritedConstructorNote(S, Found);
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10896) return;
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10897)
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10898) case Sema::TDK_SubstitutionFailure: {
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10899) // Format the template argument list into the argument string.
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 10900) SmallString<128> TemplateArgString;
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10901) if (TemplateArgumentList *Args =
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10902) DeductionFailure.getTemplateArgumentList()) {
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10903) TemplateArgString = " ";
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10904) TemplateArgString += S.getTemplateArgumentBindingsText(
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10905) getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10906) if (TemplateArgString.size() == 1)
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10907) TemplateArgString.clear();
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10908) }
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10909)
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10910) // If this candidate was disabled by enable_if, say so.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10911) PartialDiagnosticAt *PDiag = DeductionFailure.getSFINAEDiagnostic();
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10912) if (PDiag && PDiag->second.getDiagID() ==
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10913) diag::err_typename_nested_not_found_enable_if) {
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10914) // FIXME: Use the source range of the condition, and the fully-qualified
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10915) // name of the enable_if template. These are both present in PDiag.
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10916) S.Diag(PDiag->first, diag::note_ovl_candidate_disabled_by_enable_if)
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10917) << "'enable_if'" << TemplateArgString;
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10918) return;
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10919) }
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10920)
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10921) // We found a specific requirement that disabled the enable_if.
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10922) if (PDiag && PDiag->second.getDiagID() ==
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10923) diag::err_typename_nested_not_found_requirement) {
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10924) S.Diag(Templated->getLocation(),
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10925) diag::note_ovl_candidate_disabled_by_requirement)
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10926) << PDiag->second.getStringArg(0) << TemplateArgString;
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10927) return;
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10928) }
+00fa10b43f25d (Douglas Gregor 2017-07-05 20:20:14 +0000 10929)
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10930) // Format the SFINAE diagnostic into the argument string.
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10931) // FIXME: Add a general mechanism to include a PartialDiagnostic *'s
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10932) // formatted message in another diagnostic.
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 10933) SmallString<128> SFINAEArgString;
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10934) SourceRange R;
+6f8d2c6c9c345 (Richard Smith 2012-05-09 05:17:00 +0000 10935) if (PDiag) {
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10936) SFINAEArgString = ": ";
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10937) R = SourceRange(PDiag->first, PDiag->first);
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10938) PDiag->second.EmitToString(S.getDiagnostics(), SFINAEArgString);
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10939) }
+9ca6461f5a9ac (Richard Smith 2012-05-07 09:03:25 +0000 10940)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10941) S.Diag(Templated->getLocation(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10942) diag::note_ovl_candidate_substitution_failure)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10943) << TemplateArgString << SFINAEArgString << R;
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 10944) MaybeEmitInheritedConstructorNote(S, Found);
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10945) return;
+d09efd43d3f84 (Douglas Gregor 2010-05-08 20:07:26 +0000 10946) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 10947)
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 10948) case Sema::TDK_DeducedMismatch:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 10949) case Sema::TDK_DeducedMismatchNested: {
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10950) // Format the template argument list into the argument string.
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10951) SmallString<128> TemplateArgString;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10952) if (TemplateArgumentList *Args =
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10953) DeductionFailure.getTemplateArgumentList()) {
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10954) TemplateArgString = " ";
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10955) TemplateArgString += S.getTemplateArgumentBindingsText(
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10956) getDescribedTemplate(Templated)->getTemplateParameters(), *Args);
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10957) if (TemplateArgString.size() == 1)
+907cefe721437 (Richard Smith 2020-01-06 17:16:29 -0800 10958) TemplateArgString.clear();
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10959) }
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10960)
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10961) S.Diag(Templated->getLocation(), diag::note_ovl_candidate_deduced_mismatch)
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10962) << (*DeductionFailure.getCallArgIndex() + 1)
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10963) << *DeductionFailure.getFirstArg() << *DeductionFailure.getSecondArg()
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 10964) << TemplateArgString
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 10965) << (DeductionFailure.Result == Sema::TDK_DeducedMismatchNested);
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10966) break;
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10967) }
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 10968)
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10969) case Sema::TDK_NonDeducedMismatch: {
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 10970) // FIXME: Provide a source location to indicate what we couldn't match.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10971) TemplateArgument FirstTA = *DeductionFailure.getFirstArg();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10972) TemplateArgument SecondTA = *DeductionFailure.getSecondArg();
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10973) if (FirstTA.getKind() == TemplateArgument::Template &&
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10974) SecondTA.getKind() == TemplateArgument::Template) {
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10975) TemplateName FirstTN = FirstTA.getAsTemplate();
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10976) TemplateName SecondTN = SecondTA.getAsTemplate();
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10977) if (FirstTN.getKind() == TemplateName::Template &&
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10978) SecondTN.getKind() == TemplateName::Template) {
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10979) if (FirstTN.getAsTemplateDecl()->getName() ==
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10980) SecondTN.getAsTemplateDecl()->getName()) {
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10981) // FIXME: This fixes a bad diagnostic where both templates are named
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10982) // the same. This particular case is a bit
diff icult since:
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10983) // 1) It is passed as a string to the diagnostic printer.
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10984) // 2) The diagnostic printer only attempts to find a better
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10985) // name for types, not decls.
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10986) // Ideally, this should folded into the diagnostic printer.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 10987) S.Diag(Templated->getLocation(),
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10988) diag::note_ovl_candidate_non_deduced_mismatch_qualified)
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10989) << FirstTN.getAsTemplateDecl() << SecondTN.getAsTemplateDecl();
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10990) return;
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10991) }
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10992) }
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 10993) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10994)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10995) if (TakingCandidateAddress && isa<FunctionDecl>(Templated) &&
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10996) !checkAddressOfCandidateIsAvailable(S, cast<FunctionDecl>(Templated)))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10997) return;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 10998)
+2b391ab7086b8 (Faisal Vali 2013-09-26 19:54:12 +0000 10999) // FIXME: For generic lambda parameters, check if the function is a lambda
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11000) // call operator, and if so, emit a prettier and more informative
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11001) // diagnostic that mentions 'auto' and lambda in addition to
+2b391ab7086b8 (Faisal Vali 2013-09-26 19:54:12 +0000 11002) // (or instead of?) the canonical template type parameters.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11003) S.Diag(Templated->getLocation(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11004) diag::note_ovl_candidate_non_deduced_mismatch)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11005) << FirstTA << SecondTA;
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 11006) return;
+e373235c7cf8e (Richard Trieu 2013-04-08 21:11:40 +0000 11007) }
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11008) // TODO: diagnose these individually, then kill off
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11009) // note_ovl_candidate_bad_deduction, which is uselessly vague.
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 11010) case Sema::TDK_MiscellaneousDeductionFailure:
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11011) S.Diag(Templated->getLocation(), diag::note_ovl_candidate_bad_deduction);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 11012) MaybeEmitInheritedConstructorNote(S, Found);
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11013) return;
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 11014) case Sema::TDK_CUDATargetMismatch:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 11015) S.Diag(Templated->getLocation(),
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 11016) diag::note_cuda_ovl_candidate_target_mismatch);
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 11017) return;
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11018) }
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11019) }
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11020)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11021) /// Diagnose a failed template-argument deduction, for function calls.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11022) static void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11023) unsigned NumArgs,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11024) bool TakingCandidateAddress) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11025) unsigned TDK = Cand->DeductionFailure.Result;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11026) if (TDK == Sema::TDK_TooFewArguments || TDK == Sema::TDK_TooManyArguments) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11027) if (CheckArityMismatch(S, Cand, NumArgs))
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11028) return;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11029) }
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 11030) DiagnoseBadDeduction(S, Cand->FoundDecl, Cand->Function, // pattern
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11031) Cand->DeductionFailure, NumArgs, TakingCandidateAddress);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11032) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11033)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11034) /// CUDA: diagnose an invalid call across targets.
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11035) static void DiagnoseBadTarget(Sema &S, OverloadCandidate *Cand) {
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11036) FunctionDecl *Caller = cast<FunctionDecl>(S.CurContext);
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11037) FunctionDecl *Callee = Cand->Function;
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11038)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11039) Sema::CUDAFunctionTarget CallerTarget = S.IdentifyCUDATarget(Caller),
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11040) CalleeTarget = S.IdentifyCUDATarget(Callee);
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11041)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11042) std::string FnDesc;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11043) std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11044) ClassifyOverloadCandidate(S, Cand->FoundDecl, Callee,
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11045) Cand->getRewriteKind(), FnDesc);
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11046)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11047) S.Diag(Callee->getLocation(), diag::note_ovl_candidate_bad_target)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11048) << (unsigned)FnKindPair.first << (unsigned)ocs_non_template
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11049) << FnDesc /* Ignored */
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11050) << CalleeTarget << CallerTarget;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11051)
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11052) // This could be an implicit constructor for which we could not infer the
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11053) // target due to a collsion. Diagnose that case.
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11054) CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Callee);
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11055) if (Meth != nullptr && Meth->isImplicit()) {
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11056) CXXRecordDecl *ParentClass = Meth->getParent();
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11057) Sema::CXXSpecialMember CSM;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11058)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11059) switch (FnKindPair.first) {
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11060) default:
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11061) return;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11062) case oc_implicit_default_constructor:
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11063) CSM = Sema::CXXDefaultConstructor;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11064) break;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11065) case oc_implicit_copy_constructor:
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11066) CSM = Sema::CXXCopyConstructor;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11067) break;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11068) case oc_implicit_move_constructor:
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11069) CSM = Sema::CXXMoveConstructor;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11070) break;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11071) case oc_implicit_copy_assignment:
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11072) CSM = Sema::CXXCopyAssignment;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11073) break;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11074) case oc_implicit_move_assignment:
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11075) CSM = Sema::CXXMoveAssignment;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11076) break;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11077) };
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11078)
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11079) bool ConstRHS = false;
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11080) if (Meth->getNumParams()) {
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11081) if (const ReferenceType *RT =
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11082) Meth->getParamDecl(0)->getType()->getAs<ReferenceType>()) {
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11083) ConstRHS = RT->getPointeeType().isConstQualified();
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11084) }
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11085) }
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11086)
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11087) S.inferCUDATargetForImplicitSpecialMember(ParentClass, CSM, Meth,
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11088) /* ConstRHS */ ConstRHS,
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11089) /* Diagnose */ true);
+9a220fca4a6f0 (Eli Bendersky 2014-09-29 20:38:29 +0000 11090) }
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11091) }
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11092)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11093) static void DiagnoseFailedEnableIfAttr(Sema &S, OverloadCandidate *Cand) {
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11094) FunctionDecl *Callee = Cand->Function;
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11095) EnableIfAttr *Attr = static_cast<EnableIfAttr*>(Cand->DeductionFailure.Data);
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11096)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11097) S.Diag(Callee->getLocation(),
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11098) diag::note_ovl_candidate_disabled_by_function_cond_attr)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11099) << Attr->getCond()->getSourceRange() << Attr->getMessage();
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11100) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11101)
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11102) static void DiagnoseFailedExplicitSpec(Sema &S, OverloadCandidate *Cand) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11103) ExplicitSpecifier ES = ExplicitSpecifier::getFromDecl(Cand->Function);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11104) assert(ES.isExplicit() && "not an explicit candidate");
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11105)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11106) unsigned Kind;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11107) switch (Cand->Function->getDeclKind()) {
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11108) case Decl::Kind::CXXConstructor:
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11109) Kind = 0;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11110) break;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11111) case Decl::Kind::CXXConversion:
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11112) Kind = 1;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11113) break;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11114) case Decl::Kind::CXXDeductionGuide:
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11115) Kind = Cand->Function->isImplicit() ? 0 : 2;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11116) break;
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11117) default:
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11118) llvm_unreachable("invalid Decl");
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11119) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11120)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11121) // Note the location of the first (in-class) declaration; a redeclaration
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11122) // (particularly an out-of-class definition) will typically lack the
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11123) // 'explicit' specifier.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11124) // FIXME: This is probably a good thing to do for all 'candidate' notes.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11125) FunctionDecl *First = Cand->Function->getFirstDecl();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11126) if (FunctionDecl *Pattern = First->getTemplateInstantiationPattern())
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11127) First = Pattern->getFirstDecl();
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11128)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11129) S.Diag(First->getLocation(),
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11130) diag::note_ovl_candidate_explicit)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11131) << Kind << (ES.getExpr() ? 1 : 0)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11132) << (ES.getExpr() ? ES.getExpr()->getSourceRange() : SourceRange());
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11133) }
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11134)
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11135) /// Generates a 'note' diagnostic for an overload candidate. We've
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11136) /// already generated a primary error at the call site.
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11137) ///
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11138) /// It really does need to be a single diagnostic with its caret
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11139) /// pointed at the candidate declaration. Yes, this creates some
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11140) /// major challenges of technical writing. Yes, this makes pointing
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11141) /// out problems with specific arguments quite awkward. It's still
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11142) /// better than generating twenty screens of text for every failed
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11143) /// overload.
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11144) ///
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11145) /// It would be great to be able to express per-candidate problems
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11146) /// more richly for those diagnostic clients that cared, but we'd
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11147) /// still have to be just as careful with the default diagnostics.
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11148) /// \param CtorDestAS Addr space of object being constructed (for ctor
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11149) /// candidates only).
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11150) static void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11151) unsigned NumArgs,
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11152) bool TakingCandidateAddress,
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11153) LangAS CtorDestAS = LangAS::Default) {
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 11154) FunctionDecl *Fn = Cand->Function;
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 11155) if (shouldSkipNotingLambdaConversionDecl(Fn))
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 11156) return;
+53262c96d9a90 (John McCall 2010-01-12 02:15:36 +0000 11157)
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11158) // Note deleted candidates, but only if they're viable.
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11159) if (Cand->Viable) {
+13ee62f7d7eed (Erik Pilkington 2019-03-20 19:26:33 +0000 11160) if (Fn->isDeleted()) {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11161) std::string FnDesc;
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11162) std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11163) ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn,
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11164) Cand->getRewriteKind(), FnDesc);
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11165)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11166) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11167) << (unsigned)FnKindPair.first << (unsigned)FnKindPair.second << FnDesc
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 11168) << (Fn->isDeleted() ? (Fn->isDeletedAsWritten() ? 1 : 2) : 0);
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11169) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11170) return;
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11171) }
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 11172)
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 11173) // We don't really have anything else to say about viable candidates.
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11174) S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11175) return;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11176) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11177)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11178) switch (Cand->FailureKind) {
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11179) case ovl_fail_too_many_arguments:
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11180) case ovl_fail_too_few_arguments:
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11181) return DiagnoseArityMismatch(S, Cand, NumArgs);
+e1ac8d1742209 (John McCall 2010-01-13 00:25:19 +0000 11182)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11183) case ovl_fail_bad_deduction:
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 11184) return DiagnoseBadDeduction(S, Cand, NumArgs,
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 11185) TakingCandidateAddress);
+8b9ed55bfbea0 (John McCall 2010-02-01 18:53:26 +0000 11186)
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 11187) case ovl_fail_illegal_constructor: {
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 11188) S.Diag(Fn->getLocation(), diag::note_ovl_candidate_illegal_constructor)
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 11189) << (Fn->getPrimaryTemplate() ? 1 : 0);
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 11190) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 11191) return;
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 11192) }
+578a1f8c6d275 (John McCall 2014-12-14 01:46:53 +0000 11193)
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11194) case ovl_fail_object_addrspace_mismatch: {
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11195) Qualifiers QualsForPrinting;
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11196) QualsForPrinting.setAddressSpace(CtorDestAS);
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11197) S.Diag(Fn->getLocation(),
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11198) diag::note_ovl_candidate_illegal_constructor_adrspace_mismatch)
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11199) << QualsForPrinting;
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11200) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11201) return;
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11202) }
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11203)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11204) case ovl_fail_trivial_conversion:
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11205) case ovl_fail_bad_final_conversion:
+2c326bce387c8 (Douglas Gregor 2010-04-12 23:42:09 +0000 11206) case ovl_fail_final_conversion_not_exact:
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11207) return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11208)
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 11209) case ovl_fail_bad_conversion: {
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 11210) unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11211) for (unsigned N = Cand->Conversions.size(); I != N; ++I)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11212) if (Cand->Conversions[I].isBad())
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11213) return DiagnoseBadConversion(S, Cand, I, TakingCandidateAddress);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 11214)
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11215) // FIXME: this currently happens when we're called from SemaInit
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11216) // when user-conversion overload fails. Figure out how to handle
+6a61b5203dc68 (John McCall 2010-01-13 09:16:55 +0000 11217) // those conditions and diagnose them well.
+56b5eab12970e (Richard Smith 2019-11-09 05:52:18 -0800 11218) return S.NoteOverloadCandidate(Cand->FoundDecl, Fn, Cand->getRewriteKind());
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11219) }
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11220)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11221) case ovl_fail_bad_target:
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 11222) return DiagnoseBadTarget(S, Cand);
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11223)
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11224) case ovl_fail_enable_if:
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 11225) return DiagnoseFailedEnableIfAttr(S, Cand);
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11226)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11227) case ovl_fail_explicit:
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11228) return DiagnoseFailedExplicitSpec(S, Cand);
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 11229)
+f9c59b71220ce (Richard Smith 2017-01-08 21:45:44 +0000 11230) case ovl_fail_inhctor_slice:
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 11231) // It's generally not interesting to note copy/move constructors here.
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 11232) if (cast<CXXConstructorDecl>(Fn)->isCopyOrMoveConstructor())
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 11233) return;
+f9c59b71220ce (Richard Smith 2017-01-08 21:45:44 +0000 11234) S.Diag(Fn->getLocation(),
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 11235) diag::note_ovl_candidate_inherited_constructor_slice)
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 11236) << (Fn->getPrimaryTemplate() ? 1 : 0)
+836a3b416d222 (Richard Smith 2017-01-13 20:46:54 +0000 11237) << Fn->getParamDecl(0)->getType()->isRValueReferenceType();
+f9c59b71220ce (Richard Smith 2017-01-08 21:45:44 +0000 11238) MaybeEmitInheritedConstructorNote(S, Cand->FoundDecl);
+f9c59b71220ce (Richard Smith 2017-01-08 21:45:44 +0000 11239) return;
+f9c59b71220ce (Richard Smith 2017-01-08 21:45:44 +0000 11240)
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11241) case ovl_fail_addr_not_available: {
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11242) bool Available = checkAddressOfCandidateIsAvailable(S, Cand->Function);
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11243) (void)Available;
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11244) assert(!Available);
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11245) break;
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 11246) }
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 11247) case ovl_non_default_multiversion_function:
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 11248) // Do nothing, these should simply be ignored.
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 11249) break;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11250)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11251) case ovl_fail_constraints_not_satisfied: {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11252) std::string FnDesc;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11253) std::pair<OverloadCandidateKind, OverloadCandidateSelect> FnKindPair =
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11254) ClassifyOverloadCandidate(S, Cand->FoundDecl, Fn,
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11255) Cand->getRewriteKind(), FnDesc);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11256)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11257) S.Diag(Fn->getLocation(),
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11258) diag::note_ovl_candidate_constraints_not_satisfied)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11259) << (unsigned)FnKindPair.first << (unsigned)ocs_non_template
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11260) << FnDesc /* Ignored */;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11261) ConstraintSatisfaction Satisfaction;
+713562f54858f (Saar Raz 2020-01-25 22:54:27 +0200 11262) if (S.CheckFunctionConstraints(Fn, Satisfaction))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11263) break;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11264) S.DiagnoseUnsatisfiedConstraint(Satisfaction);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11265) }
+65eb879d22cc9 (John McCall 2010-02-25 01:37:24 +0000 11266) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11267) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11268)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11269) static void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) {
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 11270) if (shouldSkipNotingLambdaConversionDecl(Cand->Surrogate))
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 11271) return;
+6976fef05b7e5 (Erich Keane 2020-11-16 15:26:22 -0800 11272)
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11273) // Desugar the type of the surrogate down to a function type,
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11274) // retaining as many typedefs as possible while still showing
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11275) // the function type (and, therefore, its parameter types).
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11276) QualType FnType = Cand->Surrogate->getConversionType();
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11277) bool isLValueReference = false;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11278) bool isRValueReference = false;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11279) bool isPointer = false;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11280) if (const LValueReferenceType *FnTypeRef =
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11281) FnType->getAs<LValueReferenceType>()) {
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11282) FnType = FnTypeRef->getPointeeType();
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11283) isLValueReference = true;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11284) } else if (const RValueReferenceType *FnTypeRef =
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11285) FnType->getAs<RValueReferenceType>()) {
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11286) FnType = FnTypeRef->getPointeeType();
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11287) isRValueReference = true;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11288) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11289) if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) {
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11290) FnType = FnTypePtr->getPointeeType();
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11291) isPointer = true;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11292) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11293) // Desugar down to a function type.
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11294) FnType = QualType(FnType->getAs<FunctionType>(), 0);
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11295) // Reconstruct the pointer/reference as appropriate.
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11296) if (isPointer) FnType = S.Context.getPointerType(FnType);
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11297) if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType);
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11298) if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType);
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11299)
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11300) S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand)
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11301) << FnType;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11302) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11303)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11304) static void NoteBuiltinOperatorCandidate(Sema &S, StringRef Opc,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11305) SourceLocation OpLoc,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11306) OverloadCandidate *Cand) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11307) assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11308) std::string TypeStr("operator");
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11309) TypeStr += Opc;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11310) TypeStr += "(";
+5f6ab9a8bf307 (George Burgess IV 2017-06-08 20:55:21 +0000 11311) TypeStr += Cand->BuiltinParamTypes[0].getAsString();
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11312) if (Cand->Conversions.size() == 1) {
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11313) TypeStr += ")";
+783fc95f3eedf (Sven van Haastregt 2019-09-09 14:39:20 +0000 11314) S.Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11315) } else {
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11316) TypeStr += ", ";
+5f6ab9a8bf307 (George Burgess IV 2017-06-08 20:55:21 +0000 11317) TypeStr += Cand->BuiltinParamTypes[1].getAsString();
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11318) TypeStr += ")";
+783fc95f3eedf (Sven van Haastregt 2019-09-09 14:39:20 +0000 11319) S.Diag(OpLoc, diag::note_ovl_builtin_candidate) << TypeStr;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11320) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11321) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11322)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11323) static void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc,
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11324) OverloadCandidate *Cand) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11325) for (const ImplicitConversionSequence &ICS : Cand->Conversions) {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11326) if (ICS.isBad()) break; // all meaningless after first invalid
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11327) if (!ICS.isAmbiguous()) continue;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11328)
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 11329) ICS.DiagnoseAmbiguousConversion(
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 11330) S, OpLoc, S.PDiag(diag::note_ambiguous_type_conversion));
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11331) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11332) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11333)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11334) static SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) {
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11335) if (Cand->Function)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11336) return Cand->Function->getLocation();
+982adb518c34b (John McCall 2010-01-16 03:50:16 +0000 11337) if (Cand->IsSurrogate)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11338) return Cand->Surrogate->getLocation();
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11339) return SourceLocation();
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11340) }
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11341)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11342) static unsigned RankDeductionFailure(const DeductionFailureInfo &DFI) {
+73fddfe1b0d51 (Chandler Carruth 2011-09-10 00:51:24 +0000 11343) switch ((Sema::TemplateDeductionResult)DFI.Result) {
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11344) case Sema::TDK_Success:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11345) case Sema::TDK_NonDependentConversionFailure:
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11346) llvm_unreachable("non-deduction failure while diagnosing bad deduction");
+8a8051f2cdfcc (Benjamin Kramer 2011-09-10 21:52:04 +0000 11347)
+c5c01a60c2e3f (Douglas Gregor 2012-09-13 21:01:57 +0000 11348) case Sema::TDK_Invalid:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11349) case Sema::TDK_Incomplete:
+4a8f3518cb144 (Richard Smith 2018-07-19 19:00:37 +0000 11350) case Sema::TDK_IncompletePack:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11351) return 1;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11352)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11353) case Sema::TDK_Underqualified:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11354) case Sema::TDK_Inconsistent:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11355) return 2;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11356)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11357) case Sema::TDK_SubstitutionFailure:
+9b534547250a3 (Richard Smith 2015-12-31 02:02:54 +0000 11358) case Sema::TDK_DeducedMismatch:
+fdf80e86a5284 (Saar Raz 2019-12-06 01:30:21 +0200 11359) case Sema::TDK_ConstraintsNotSatisfied:
+c92d206ce4419 (Richard Smith 2017-01-05 23:02:44 +0000 11360) case Sema::TDK_DeducedMismatchNested:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11361) case Sema::TDK_NonDeducedMismatch:
+44ecdbdc6134c (Richard Smith 2013-01-31 05:19:49 +0000 11362) case Sema::TDK_MiscellaneousDeductionFailure:
+13e9b4d76851d (Artem Belevich 2016-12-07 19:27:16 +0000 11363) case Sema::TDK_CUDATargetMismatch:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11364) return 3;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11365)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11366) case Sema::TDK_InstantiationDepth:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11367) return 4;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11368)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11369) case Sema::TDK_InvalidExplicitArguments:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11370) return 5;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11371)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11372) case Sema::TDK_TooManyArguments:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11373) case Sema::TDK_TooFewArguments:
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11374) return 6;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11375) }
+8a8051f2cdfcc (Benjamin Kramer 2011-09-10 21:52:04 +0000 11376) llvm_unreachable("Unhandled deduction result");
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11377) }
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11378)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11379) namespace {
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11380) struct CompareOverloadCandidatesForDisplay {
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11381) Sema &S;
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 11382) SourceLocation Loc;
+b96b3be8996bb (Kaelyn Takata 2014-05-01 21:15:24 +0000 11383) size_t NumArgs;
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11384) OverloadCandidateSet::CandidateSetKind CSK;
+b96b3be8996bb (Kaelyn Takata 2014-05-01 21:15:24 +0000 11385)
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11386) CompareOverloadCandidatesForDisplay(
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11387) Sema &S, SourceLocation Loc, size_t NArgs,
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11388) OverloadCandidateSet::CandidateSetKind CSK)
+fd54435b95922 (Richard Smith 2017-09-26 21:33:43 +0000 11389) : S(S), NumArgs(NArgs), CSK(CSK) {}
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11390)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11391) OverloadFailureKind EffectiveFailureKind(const OverloadCandidate *C) const {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11392) // If there are too many or too few arguments, that's the high-order bit we
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11393) // want to sort by, even if the immediate failure kind was something else.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11394) if (C->FailureKind == ovl_fail_too_many_arguments ||
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11395) C->FailureKind == ovl_fail_too_few_arguments)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11396) return static_cast<OverloadFailureKind>(C->FailureKind);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11397)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11398) if (C->Function) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11399) if (NumArgs > C->Function->getNumParams() && !C->Function->isVariadic())
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11400) return ovl_fail_too_many_arguments;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11401) if (NumArgs < C->Function->getMinRequiredArguments())
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11402) return ovl_fail_too_few_arguments;
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11403) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11404)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11405) return static_cast<OverloadFailureKind>(C->FailureKind);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11406) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11407)
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11408) bool operator()(const OverloadCandidate *L,
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11409) const OverloadCandidate *R) {
+982adb518c34b (John McCall 2010-01-16 03:50:16 +0000 11410) // Fast-path this check.
+982adb518c34b (John McCall 2010-01-16 03:50:16 +0000 11411) if (L == R) return false;
+982adb518c34b (John McCall 2010-01-16 03:50:16 +0000 11412)
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11413) // Order first by viability.
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11414) if (L->Viable) {
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11415) if (!R->Viable) return true;
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11416)
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11417) // TODO: introduce a tri-valued comparison for overload
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11418) // candidates. Would be more worthwhile if we had a sort
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11419) // that could exploit it.
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11420) if (isBetterOverloadCandidate(S, *L, *R, SourceLocation(), CSK))
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11421) return true;
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11422) if (isBetterOverloadCandidate(S, *R, *L, SourceLocation(), CSK))
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 11423) return false;
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11424) } else if (R->Viable)
+ad2587a394059 (John McCall 2010-01-12 00:48:53 +0000 11425) return false;
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11426)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11427) assert(L->Viable == R->Viable);
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11428)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11429) // Criteria by which we can sort non-viable candidates:
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11430) if (!L->Viable) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11431) OverloadFailureKind LFailureKind = EffectiveFailureKind(L);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11432) OverloadFailureKind RFailureKind = EffectiveFailureKind(R);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11433)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11434) // 1. Arity mismatches come after other candidates.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11435) if (LFailureKind == ovl_fail_too_many_arguments ||
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11436) LFailureKind == ovl_fail_too_few_arguments) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11437) if (RFailureKind == ovl_fail_too_many_arguments ||
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11438) RFailureKind == ovl_fail_too_few_arguments) {
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11439) int LDist = std::abs((int)L->getNumParams() - (int)NumArgs);
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11440) int RDist = std::abs((int)R->getNumParams() - (int)NumArgs);
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11441) if (LDist == RDist) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11442) if (LFailureKind == RFailureKind)
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11443) // Sort non-surrogates before surrogates.
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11444) return !L->IsSurrogate && R->IsSurrogate;
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11445) // Sort candidates requiring fewer parameters than there were
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11446) // arguments given after candidates requiring more parameters
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11447) // than there were arguments given.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11448) return LFailureKind == ovl_fail_too_many_arguments;
+50c4ffcca78e0 (Kaelyn Takata 2014-05-07 00:43:38 +0000 11449) }
+b96b3be8996bb (Kaelyn Takata 2014-05-01 21:15:24 +0000 11450) return LDist < RDist;
+b96b3be8996bb (Kaelyn Takata 2014-05-01 21:15:24 +0000 11451) }
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11452) return false;
+b96b3be8996bb (Kaelyn Takata 2014-05-01 21:15:24 +0000 11453) }
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11454) if (RFailureKind == ovl_fail_too_many_arguments ||
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11455) RFailureKind == ovl_fail_too_few_arguments)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11456) return true;
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11457)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11458) // 2. Bad conversions come first and are ordered by the number
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11459) // of bad conversions and quality of good conversions.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11460) if (LFailureKind == ovl_fail_bad_conversion) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11461) if (RFailureKind != ovl_fail_bad_conversion)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11462) return true;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11463)
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11464) // The conversion that can be fixed with a smaller number of changes,
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11465) // comes first.
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11466) unsigned numLFixes = L->Fix.NumConversionsFixed;
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11467) unsigned numRFixes = R->Fix.NumConversionsFixed;
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11468) numLFixes = (numLFixes == 0) ? UINT_MAX : numLFixes;
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11469) numRFixes = (numRFixes == 0) ? UINT_MAX : numRFixes;
+9ccf84e35dcf4 (Anna Zaks 2011-07-21 00:34:39 +0000 11470) if (numLFixes != numRFixes) {
+7a3cbb299772b (David Blaikie 2015-03-09 02:02:07 +0000 11471) return numLFixes < numRFixes;
+9ccf84e35dcf4 (Anna Zaks 2011-07-21 00:34:39 +0000 11472) }
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11473)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11474) // If there's any ordering between the defined conversions...
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11475) // FIXME: this might not be transitive.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11476) assert(L->Conversions.size() == R->Conversions.size());
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11477)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11478) int leftBetter = 0;
+21b57fa4e5f1b (John McCall 2010-02-25 10:46:05 +0000 11479) unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11480) for (unsigned E = L->Conversions.size(); I != E; ++I) {
+0f59cb38e7f31 (Richard Smith 2015-12-18 21:45:41 +0000 11481) switch (CompareImplicitConversionSequences(S, Loc,
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11482) L->Conversions[I],
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11483) R->Conversions[I])) {
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11484) case ImplicitConversionSequence::Better:
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11485) leftBetter++;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11486) break;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11487)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11488) case ImplicitConversionSequence::Worse:
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11489) leftBetter--;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11490) break;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11491)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11492) case ImplicitConversionSequence::Indistinguishable:
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11493) break;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11494) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11495) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11496) if (leftBetter > 0) return true;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11497) if (leftBetter < 0) return false;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11498)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11499) } else if (RFailureKind == ovl_fail_bad_conversion)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11500) return false;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11501)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11502) if (LFailureKind == ovl_fail_bad_deduction) {
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11503) if (RFailureKind != ovl_fail_bad_deduction)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11504) return true;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11505)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11506) if (L->DeductionFailure.Result != R->DeductionFailure.Result)
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11507) return RankDeductionFailure(L->DeductionFailure)
+1e7a0c6a1d4f5 (Eli Friedman 2011-10-14 23:10:30 +0000 11508) < RankDeductionFailure(R->DeductionFailure);
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11509) } else if (RFailureKind == ovl_fail_bad_deduction)
+e2c600cf4342a (Eli Friedman 2011-10-14 21:52:24 +0000 11510) return false;
+45e9370a24f15 (Kaelyn Uhrain 2011-09-09 21:58:49 +0000 11511)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11512) // TODO: others?
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11513) }
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11514)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11515) // Sort everything else by location.
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11516) SourceLocation LLoc = GetLocationForCandidate(L);
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11517) SourceLocation RLoc = GetLocationForCandidate(R);
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11518)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11519) // Put candidates without locations (e.g. builtins) at the end.
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11520) if (LLoc.isInvalid()) return false;
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11521) if (RLoc.isInvalid()) return true;
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11522)
+3712d9e391523 (John McCall 2010-01-15 23:32:50 +0000 11523) return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11524) }
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11525) };
+ab9db51042d1b (Alexander Kornienko 2015-06-22 23:07:51 +0000 11526) }
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11527)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11528) /// CompleteNonViableCandidate - Normally, overload resolution only
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11529) /// computes up to the first bad conversion. Produces the FixIt set if
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11530) /// possible.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11531) static void
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11532) CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11533) ArrayRef<Expr *> Args,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11534) OverloadCandidateSet::CandidateSetKind CSK) {
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11535) assert(!Cand->Viable);
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11536)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11537) // Don't do anything on failures other than bad conversion.
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11538) if (Cand->FailureKind != ovl_fail_bad_conversion)
+25195541349b1 (Richard Smith 2020-01-09 12:27:48 -0800 11539) return;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11540)
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11541) // We only want the FixIts if all the arguments can be corrected.
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11542) bool Unfixable = false;
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 11543) // Use a implicit copy initialization to check conversion fixes.
+1b06812f466f1 (Anna Zaks 2011-07-28 19:46:48 +0000 11544) Cand->Fix.setConversionChecker(TryCopyInitialization);
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11545)
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11546) // Attempt to fix the bad conversion.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11547) unsigned ConvCount = Cand->Conversions.size();
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11548) for (unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); /**/;
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11549) ++ConvIdx) {
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11550) assert(ConvIdx != ConvCount && "no bad conversion in candidate");
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11551) if (Cand->Conversions[ConvIdx].isInitialized() &&
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11552) Cand->Conversions[ConvIdx].isBad()) {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11553) Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11554) break;
+df92ddf8466bf (Anna Zaks 2011-07-19 19:49:12 +0000 11555) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11556) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11557)
+adc7a704d2a38 (Douglas Gregor 2010-04-16 17:45:54 +0000 11558) // FIXME: this should probably be preserved from the overload
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11559) // operation somehow.
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11560) bool SuppressUserConversions = false;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11561)
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11562) unsigned ConvIdx = 0;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11563) unsigned ArgIdx = 0;
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11564) ArrayRef<QualType> ParamTypes;
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 11565) bool Reversed = Cand->isReversed();
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11566)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11567) if (Cand->IsSurrogate) {
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11568) QualType ConvType
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11569) = Cand->Surrogate->getConversionType().getNonReferenceType();
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11570) if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11571) ConvType = ConvPtrType->getPointeeType();
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 11572) ParamTypes = ConvType->castAs<FunctionProtoType>()->getParamTypes();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11573) // Conversion 0 is 'this', which doesn't have a corresponding parameter.
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11574) ConvIdx = 1;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11575) } else if (Cand->Function) {
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11576) ParamTypes =
+ed3b68e0dc3c0 (Simon Pilgrim 2019-10-02 14:02:27 +0000 11577) Cand->Function->getType()->castAs<FunctionProtoType>()->getParamTypes();
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11578) if (isa<CXXMethodDecl>(Cand->Function) &&
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 11579) !isa<CXXConstructorDecl>(Cand->Function) && !Reversed) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11580) // Conversion 0 is 'this', which doesn't have a corresponding parameter.
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11581) ConvIdx = 1;
+52590319a2257 (Richard Smith 2019-10-29 13:06:34 -0700 11582) if (CSK == OverloadCandidateSet::CSK_Operator &&
+52590319a2257 (Richard Smith 2019-10-29 13:06:34 -0700 11583) Cand->Function->getDeclName().getCXXOverloadedOperator() != OO_Call)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11584) // Argument 0 is 'this', which doesn't have a corresponding parameter.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11585) ArgIdx = 1;
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11586) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11587) } else {
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11588) // Builtin operator.
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11589) assert(ConvCount <= 3);
+5f6ab9a8bf307 (George Burgess IV 2017-06-08 20:55:21 +0000 11590) ParamTypes = Cand->BuiltinParamTypes;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11591) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11592)
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11593) // Fill in the rest of the conversions.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11594) for (unsigned ParamIdx = Reversed ? ParamTypes.size() - 1 : 0;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11595) ConvIdx != ConvCount;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11596) ++ConvIdx, ++ArgIdx, ParamIdx += (Reversed ? -1 : 1)) {
+52590319a2257 (Richard Smith 2019-10-29 13:06:34 -0700 11597) assert(ArgIdx < Args.size() && "no argument for this arg conversion");
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11598) if (Cand->Conversions[ConvIdx].isInitialized()) {
+14ead30ab8bcd (Richard Smith 2017-01-10 20:19:21 +0000 11599) // We've already checked this conversion.
+52590319a2257 (Richard Smith 2019-10-29 13:06:34 -0700 11600) } else if (ParamIdx < ParamTypes.size()) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11601) if (ParamTypes[ParamIdx]->isDependentType())
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11602) Cand->Conversions[ConvIdx].setAsIdentityConversion(
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11603) Args[ArgIdx]->getType());
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11604) else {
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11605) Cand->Conversions[ConvIdx] =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 11606) TryCopyInitialization(S, Args[ArgIdx], ParamTypes[ParamIdx],
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11607) SuppressUserConversions,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11608) /*InOverloadResolution=*/true,
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11609) /*AllowObjCWritebackConversion=*/
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11610) S.getLangOpts().ObjCAutoRefCount);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11611) // Store the FixIt in the candidate if it exists.
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11612) if (!Unfixable && Cand->Conversions[ConvIdx].isBad())
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11613) Unfixable = !Cand->TryToFixBadConversion(ConvIdx, S);
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11614) }
+6eedfe77c15fa (Richard Smith 2017-01-09 08:01:21 +0000 11615) } else
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11616) Cand->Conversions[ConvIdx].setEllipsis();
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11617) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11618) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11619)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11620) SmallVector<OverloadCandidate *, 32> OverloadCandidateSet::CompleteCandidates(
+b2f0f05742130 (Richard Smith 2016-10-10 18:54:32 +0000 11621) Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11622) SourceLocation OpLoc,
+b2f0f05742130 (Richard Smith 2016-10-10 18:54:32 +0000 11623) llvm::function_ref<bool(OverloadCandidate &)> Filter) {
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11624) // Sort the candidates by viability and position. Sorting directly would
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11625) // be prohibitive, so we make a set of pointers and sort those.
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 11626) SmallVector<OverloadCandidate*, 32> Cands;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11627) if (OCD == OCD_AllCandidates) Cands.reserve(size());
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11628) for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
+b2f0f05742130 (Richard Smith 2016-10-10 18:54:32 +0000 11629) if (!Filter(*Cand))
+b2f0f05742130 (Richard Smith 2016-10-10 18:54:32 +0000 11630) continue;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11631) switch (OCD) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11632) case OCD_AllCandidates:
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11633) if (!Cand->Viable) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11634) if (!Cand->Function && !Cand->IsSurrogate) {
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11635) // This a non-viable builtin candidate. We do not, in general,
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11636) // want to list every possible builtin candidate.
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11637) continue;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11638) }
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11639) CompleteNonViableCandidate(S, Cand, Args, Kind);
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11640) }
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11641) break;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11642)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11643) case OCD_ViableCandidates:
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11644) if (!Cand->Viable)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11645) continue;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11646) break;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11647)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11648) case OCD_AmbiguousCandidates:
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11649) if (!Cand->Best)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11650) continue;
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11651) break;
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11652) }
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11653)
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 11654) Cands.push_back(Cand);
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11655) }
+fe796ddd5a76f (John McCall 2010-01-23 05:17:32 +0000 11656)
+899d13926df4b (Fangrui Song 2019-04-24 14:43:05 +0000 11657) llvm::stable_sort(
+899d13926df4b (Fangrui Song 2019-04-24 14:43:05 +0000 11658) Cands, CompareOverloadCandidatesForDisplay(S, OpLoc, Args.size(), Kind));
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 11659)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11660) return Cands;
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11661) }
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11662)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11663) bool OverloadCandidateSet::shouldDeferDiags(Sema &S, ArrayRef<Expr *> Args,
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11664) SourceLocation OpLoc) {
+52bcd691cb199 (Yaxun (Sam) Liu 2020-09-23 18:00:23 -0400 11665) bool DeferHint = false;
+52bcd691cb199 (Yaxun (Sam) Liu 2020-09-23 18:00:23 -0400 11666) if (S.getLangOpts().CUDA && S.getLangOpts().GPUDeferDiag) {
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11667) // Defer diagnostic for CUDA/HIP if there are wrong-sided candidates or
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11668) // host device candidates.
+52bcd691cb199 (Yaxun (Sam) Liu 2020-09-23 18:00:23 -0400 11669) auto WrongSidedCands =
+52bcd691cb199 (Yaxun (Sam) Liu 2020-09-23 18:00:23 -0400 11670) CompleteCandidates(S, OCD_AllCandidates, Args, OpLoc, [](auto &Cand) {
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11671) return (Cand.Viable == false &&
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11672) Cand.FailureKind == ovl_fail_bad_target) ||
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11673) (Cand.Function->template hasAttr<CUDAHostAttr>() &&
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11674) Cand.Function->template hasAttr<CUDADeviceAttr>());
+52bcd691cb199 (Yaxun (Sam) Liu 2020-09-23 18:00:23 -0400 11675) });
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11676) DeferHint = !WrongSidedCands.empty();
+52bcd691cb199 (Yaxun (Sam) Liu 2020-09-23 18:00:23 -0400 11677) }
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11678) return DeferHint;
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11679) }
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11680)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11681) /// When overload resolution fails, prints diagnostic messages containing the
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11682) /// candidates in the candidate set.
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11683) void OverloadCandidateSet::NoteCandidates(
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11684) PartialDiagnosticAt PD, Sema &S, OverloadCandidateDisplayKind OCD,
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11685) ArrayRef<Expr *> Args, StringRef Opc, SourceLocation OpLoc,
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11686) llvm::function_ref<bool(OverloadCandidate &)> Filter) {
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11687)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11688) auto Cands = CompleteCandidates(S, OCD, Args, OpLoc, Filter);
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11689)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11690) S.Diag(PD.first, PD.second, shouldDeferDiags(S, Args, OpLoc));
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11691)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11692) NoteCandidates(S, Args, Cands, Opc, OpLoc);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11693)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11694) if (OCD == OCD_AmbiguousCandidates)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 11695) MaybeDiagnoseAmbiguousConstraints(S, {begin(), end()});
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11696) }
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11697)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11698) void OverloadCandidateSet::NoteCandidates(Sema &S, ArrayRef<Expr *> Args,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11699) ArrayRef<OverloadCandidate *> Cands,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11700) StringRef Opc, SourceLocation OpLoc) {
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11701) bool ReportedAmbiguousConversions = false;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11702)
+7959178eb00e3 (Douglas Gregor 2012-10-23 23:11:23 +0000 11703) const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11704) unsigned CandsShown = 0;
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11705) auto I = Cands.begin(), E = Cands.end();
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 11706) for (; I != E; ++I) {
+12f97bc48ad40 (John McCall 2010-01-08 04:41:39 +0000 11707) OverloadCandidate *Cand = *I;
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11708)
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11709) if (CandsShown >= S.Diags.getNumOverloadCandidatesToShow() &&
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11710) ShowOverloads == Ovl_Best) {
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11711) break;
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11712) }
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11713) ++CandsShown;
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11714)
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11715) if (Cand->Function)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11716) NoteFunctionCandidate(S, Cand, Args.size(),
+c25ea86d43929 (Anastasia Stulova 2019-06-20 16:23:28 +0000 11717) /*TakingCandidateAddress=*/false, DestAS);
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11718) else if (Cand->IsSurrogate)
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11719) NoteSurrogateCandidate(S, Cand);
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11720) else {
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11721) assert(Cand->Viable &&
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11722) "Non-viable built-in candidates are not added to Cands.");
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11723) // Generally we only see ambiguities including viable builtin
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11724) // operators if overload resolution got screwed up by an
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11725) // ambiguous user-defined conversion.
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11726) //
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11727) // FIXME: It's quite possible for
diff erent conversions to see
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11728) //
diff erent ambiguities, though.
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11729) if (!ReportedAmbiguousConversions) {
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11730) NoteAmbiguousUserConversions(S, OpLoc, Cand);
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11731) ReportedAmbiguousConversions = true;
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11732) }
+d3224162336e1 (John McCall 2010-01-08 00:58:21 +0000 11733)
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 11734) // If this is a viable builtin, print it.
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 11735) NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand);
+a11693bc37b1b (Douglas Gregor 2008-11-12 17:17:38 +0000 11736) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 11737) }
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11738)
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11739) // Inform S.Diags that we've shown an overload set with N elements. This may
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11740) // inform the future value of S.Diags.getNumOverloadCandidatesToShow().
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11741) S.Diags.overloadCandidatesShown(CandsShown);
+c90dac27e94ec (Justin Lebar 2021-01-30 19:00:24 -0800 11742)
+2b99c6fc4f3e0 (Jeffrey Yasskin 2010-06-11 05:57:47 +0000 11743) if (I != E)
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11744) S.Diag(OpLoc, diag::note_ovl_too_many_candidates,
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11745) shouldDeferDiags(S, Args, OpLoc))
+acb6f80d96b74 (Yaxun (Sam) Liu 2020-11-25 10:33:18 -0500 11746) << int(E - I);
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 11747) }
+5251f1b28324a (Douglas Gregor 2008-10-21 16:13:35 +0000 11748)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11749) static SourceLocation
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11750) GetLocationForCandidate(const TemplateSpecCandidate *Cand) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11751) return Cand->Specialization ? Cand->Specialization->getLocation()
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11752) : SourceLocation();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11753) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11754)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11755) namespace {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11756) struct CompareTemplateSpecCandidatesForDisplay {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11757) Sema &S;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11758) CompareTemplateSpecCandidatesForDisplay(Sema &S) : S(S) {}
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11759)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11760) bool operator()(const TemplateSpecCandidate *L,
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11761) const TemplateSpecCandidate *R) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11762) // Fast-path this check.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11763) if (L == R)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11764) return false;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11765)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11766) // Assuming that both candidates are not matches...
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11767)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11768) // Sort by the ranking of deduction failures.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11769) if (L->DeductionFailure.Result != R->DeductionFailure.Result)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11770) return RankDeductionFailure(L->DeductionFailure) <
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11771) RankDeductionFailure(R->DeductionFailure);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11772)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11773) // Sort everything else by location.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11774) SourceLocation LLoc = GetLocationForCandidate(L);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11775) SourceLocation RLoc = GetLocationForCandidate(R);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11776)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11777) // Put candidates without locations (e.g. builtins) at the end.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11778) if (LLoc.isInvalid())
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11779) return false;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11780) if (RLoc.isInvalid())
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11781) return true;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11782)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11783) return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11784) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11785) };
+ab9db51042d1b (Alexander Kornienko 2015-06-22 23:07:51 +0000 11786) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11787)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11788) /// Diagnose a template argument deduction failure.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11789) /// We are treating these failures as overload failures due to bad
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11790) /// deductions.
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11791) void TemplateSpecCandidate::NoteDeductionFailure(Sema &S,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11792) bool ForTakingAddress) {
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 11793) DiagnoseBadDeduction(S, FoundDecl, Specialization, // pattern
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11794) DeductionFailure, /*NumArgs=*/0, ForTakingAddress);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11795) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11796)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11797) void TemplateSpecCandidateSet::destroyCandidates() {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11798) for (iterator i = begin(), e = end(); i != e; ++i) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11799) i->DeductionFailure.Destroy();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11800) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11801) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11802)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11803) void TemplateSpecCandidateSet::clear() {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11804) destroyCandidates();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11805) Candidates.clear();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11806) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11807)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11808) /// NoteCandidates - When no template specialization match is found, prints
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11809) /// diagnostic messages containing the non-matching specializations that form
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11810) /// the candidate set.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11811) /// This is analoguous to OverloadCandidateSet::NoteCandidates() with
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11812) /// OCD == OCD_AllCandidates and Cand->Viable == false.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11813) void TemplateSpecCandidateSet::NoteCandidates(Sema &S, SourceLocation Loc) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11814) // Sort the candidates by position (assuming no candidate is a match).
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11815) // Sorting directly would be prohibitive, so we make a set of pointers
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11816) // and sort those.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11817) SmallVector<TemplateSpecCandidate *, 32> Cands;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11818) Cands.reserve(size());
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11819) for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11820) if (Cand->Specialization)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11821) Cands.push_back(Cand);
+d473363876d4b (Alp Toker 2013-12-05 04:47:09 +0000 11822) // Otherwise, this is a non-matching builtin candidate. We do not,
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11823) // in general, want to list every possible builtin candidate.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11824) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11825)
+55fab260ca1c4 (Fangrui Song 2018-09-26 22:16:28 +0000 11826) llvm::sort(Cands, CompareTemplateSpecCandidatesForDisplay(S));
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11827)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11828) // FIXME: Perhaps rename OverloadsShown and getShowOverloads()
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11829) // for generalization purposes (?).
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11830) const OverloadsShown ShowOverloads = S.Diags.getShowOverloads();
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11831)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11832) SmallVectorImpl<TemplateSpecCandidate *>::iterator I, E;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11833) unsigned CandsShown = 0;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11834) for (I = Cands.begin(), E = Cands.end(); I != E; ++I) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11835) TemplateSpecCandidate *Cand = *I;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11836)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11837) // Set an arbitrary limit on the number of candidates we'll spam
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11838) // the user with. FIXME: This limit should depend on details of the
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11839) // candidate list.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11840) if (CandsShown >= 4 && ShowOverloads == Ovl_Best)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11841) break;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11842) ++CandsShown;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11843)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11844) assert(Cand->Specialization &&
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11845) "Non-matching built-in candidates are not added to Cands.");
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11846) Cand->NoteDeductionFailure(S, ForTakingAddress);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11847) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11848)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11849) if (I != E)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11850) S.Diag(Loc, diag::note_ovl_too_many_candidates) << int(E - I);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11851) }
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11852)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11853) // [PossiblyAFunctionType] --> [Return]
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11854) // NonFunctionType --> NonFunctionType
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11855) // R (A) --> R(A)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11856) // R (*)(A) --> R (A)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11857) // R (&)(A) --> R (A)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11858) // R (S::*)(A) --> R (A)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11859) QualType Sema::ExtractUnqualifiedFunctionType(QualType PossiblyAFunctionType) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11860) QualType Ret = PossiblyAFunctionType;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11861) if (const PointerType *ToTypePtr =
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11862) PossiblyAFunctionType->getAs<PointerType>())
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11863) Ret = ToTypePtr->getPointeeType();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11864) else if (const ReferenceType *ToTypeRef =
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11865) PossiblyAFunctionType->getAs<ReferenceType>())
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11866) Ret = ToTypeRef->getPointeeType();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11867) else if (const MemberPointerType *MemTypePtr =
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11868) PossiblyAFunctionType->getAs<MemberPointerType>())
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11869) Ret = MemTypePtr->getPointeeType();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11870) Ret =
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11871) Context.getCanonicalType(Ret).getUnqualifiedType();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11872) return Ret;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11873) }
+064fdb2fe844a (Douglas Gregor 2010-04-14 23:11:21 +0000 11874)
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11875) static bool completeFunctionType(Sema &S, FunctionDecl *FD, SourceLocation Loc,
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11876) bool Complain = true) {
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11877) if (S.getLangOpts().CPlusPlus14 && FD->getReturnType()->isUndeducedType() &&
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11878) S.DeduceReturnType(FD, Loc, Complain))
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11879) return true;
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11880)
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11881) auto *FPT = FD->getType()->castAs<FunctionProtoType>();
+c351fba69e24c (Aaron Ballman 2017-12-04 20:27:34 +0000 11882) if (S.getLangOpts().CPlusPlus17 &&
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11883) isUnresolvedExceptionSpec(FPT->getExceptionSpecType()) &&
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11884) !S.ResolveExceptionSpec(Loc, FPT))
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11885) return true;
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11886)
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11887) return false;
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11888) }
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 11889)
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11890) namespace {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11891) // A helper class to help with address of function resolution
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11892) // - allows us to avoid passing around all those ugly parameters
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 11893) class AddressOfFunctionResolver {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11894) Sema& S;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11895) Expr* SourceExpr;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11896) const QualType& TargetType;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11897) QualType TargetFunctionType; // Extracted function type from target type
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11898)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11899) bool Complain;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11900) //DeclAccessPair& ResultFunctionAccessPair;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11901) ASTContext& Context;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11902)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11903) bool TargetTypeIsNonStaticMemberFunction;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11904) bool FoundNonTemplateFunction;
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11905) bool StaticMemberFunctionFromBoundPointer;
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 11906) bool HasComplained;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11907)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11908) OverloadExpr::FindResult OvlExprInfo;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11909) OverloadExpr *OvlExpr;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11910) TemplateArgumentListInfo OvlExplicitTemplateArgs;
+0e62c1cc0b47c (Chris Lattner 2011-07-23 10:55:15 +0000 11911) SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11912) TemplateSpecCandidateSet FailedCandidates;
+24d189484b443 (John McCall 2010-08-24 22:52:39 +0000 11913)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11914) public:
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11915) AddressOfFunctionResolver(Sema &S, Expr *SourceExpr,
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11916) const QualType &TargetType, bool Complain)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11917) : S(S), SourceExpr(SourceExpr), TargetType(TargetType),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11918) Complain(Complain), Context(S.getASTContext()),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11919) TargetTypeIsNonStaticMemberFunction(
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11920) !!TargetType->getAs<MemberPointerType>()),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11921) FoundNonTemplateFunction(false),
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11922) StaticMemberFunctionFromBoundPointer(false),
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 11923) HasComplained(false),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11924) OvlExprInfo(OverloadExpr::find(SourceExpr)),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 11925) OvlExpr(OvlExprInfo.Expression),
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 11926) FailedCandidates(OvlExpr->getNameLoc(), /*ForTakingAddress=*/true) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11927) ExtractUnqualifiedFunctionTypeFromTargetType();
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11928)
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11929) if (TargetFunctionType->isFunctionType()) {
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11930) if (UnresolvedMemberExpr *UME = dyn_cast<UnresolvedMemberExpr>(OvlExpr))
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11931) if (!UME->isImplicitAccess() &&
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11932) !S.ResolveSingleFunctionTemplateSpecialization(UME))
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11933) StaticMemberFunctionFromBoundPointer = true;
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11934) } else if (OvlExpr->hasExplicitTemplateArgs()) {
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11935) DeclAccessPair dap;
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11936) if (FunctionDecl *Fn = S.ResolveSingleFunctionTemplateSpecialization(
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11937) OvlExpr, false, &dap)) {
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11938) if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn))
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11939) if (!Method->isStatic()) {
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11940) // If the target type is a non-function type and the function found
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11941) // is a non-static member function, pretend as if that was the
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11942) // target, it's the only possible type to end up with.
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11943) TargetTypeIsNonStaticMemberFunction = true;
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11944)
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11945) // And skip adding the function if its not in the proper form.
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11946) // We'll diagnose this due to an empty set of functions.
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11947) if (!OvlExprInfo.HasFormOfMemberPointer)
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11948) return;
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 11949) }
+ffce245700488 (Chandler Carruth 2011-03-29 08:08:18 +0000 11950)
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 11951) Matches.push_back(std::make_pair(dap, Fn));
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11952) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11953) return;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11954) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 11955)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11956) if (OvlExpr->hasExplicitTemplateArgs())
+04ec5bfad8ff4 (James Y Knight 2015-12-24 02:59:37 +0000 11957) OvlExpr->copyTemplateArgumentsInto(OvlExplicitTemplateArgs);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11958)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11959) if (FindAllFunctionsThatMatchTargetTypeExactly()) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11960) // C++ [over.over]p4:
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11961) // If more than one function is selected, [...]
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11962) if (Matches.size() > 1 && !eliminiateSuboptimalOverloadCandidates()) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11963) if (FoundNonTemplateFunction)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11964) EliminateAllTemplateMatches();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11965) else
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11966) EliminateAllExceptMostSpecializedTemplate();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11967) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11968) }
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 11969)
+25c4a81e79b08 (Justin Lebar 2016-03-29 16:24:16 +0000 11970) if (S.getLangOpts().CUDA && Matches.size() > 1)
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 11971) EliminateSuboptimalCudaMatches();
+24d189484b443 (John McCall 2010-08-24 22:52:39 +0000 11972) }
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 11973)
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 11974) bool hasComplained() const { return HasComplained; }
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 11975)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 11976) private:
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11977) bool candidateHasExactlyCorrectType(const FunctionDecl *FD) {
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11978) QualType Discard;
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11979) return Context.hasSameUnqualifiedType(TargetFunctionType, FD->getType()) ||
+3c4f8d2e96c4b (Richard Smith 2016-10-16 17:54:23 +0000 11980) S.IsFunctionConversion(FD->getType(), TargetFunctionType, Discard);
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11981) }
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11982)
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11983) /// \return true if A is considered a better overload candidate for the
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11984) /// desired type than B.
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11985) bool isBetterCandidate(const FunctionDecl *A, const FunctionDecl *B) {
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11986) // If A doesn't have exactly the correct type, we don't want to classify it
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11987) // as "better" than anything else. This way, the user is required to
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11988) // disambiguate for us if there are multiple candidates and no exact match.
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11989) return candidateHasExactlyCorrectType(A) &&
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11990) (!candidateHasExactlyCorrectType(B) ||
+3dc16691339e0 (George Burgess IV 2016-05-10 01:59:34 +0000 11991) compareEnableIfAttrs(S, A, B) == Comparison::Better);
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11992) }
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11993)
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11994) /// \return true if we were able to eliminate all but one overload candidate,
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 11995) /// false otherwise.
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11996) bool eliminiateSuboptimalOverloadCandidates() {
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11997) // Same algorithm as overload resolution -- one pass to pick the "best",
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11998) // another pass to be sure that nothing is better than the best.
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 11999) auto Best = Matches.begin();
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12000) for (auto I = Matches.begin()+1, E = Matches.end(); I != E; ++I)
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12001) if (isBetterCandidate(I->second, Best->second))
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12002) Best = I;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12003)
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12004) const FunctionDecl *BestFn = Best->second;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12005) auto IsBestOrInferiorToBest = [this, BestFn](
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12006) const std::pair<DeclAccessPair, FunctionDecl *> &Pair) {
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12007) return BestFn == Pair.second || isBetterCandidate(BestFn, Pair.second);
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12008) };
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12009)
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12010) // Note: We explicitly leave Matches unmodified if there isn't a clear best
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12011) // option, so we can potentially give the user a better error
+3117b17bc57c1 (Fangrui Song 2018-10-20 17:53:42 +0000 12012) if (!llvm::all_of(Matches, IsBestOrInferiorToBest))
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12013) return false;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12014) Matches[0] = *Best;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12015) Matches.resize(1);
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12016) return true;
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12017) }
+2a6150d93290b (George Burgess IV 2015-10-16 01:17:38 +0000 12018)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12019) bool isTargetTypeAFunction() const {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12020) return TargetFunctionType->isFunctionType();
+24d189484b443 (John McCall 2010-08-24 22:52:39 +0000 12021) }
+24d189484b443 (John McCall 2010-08-24 22:52:39 +0000 12022)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12023) // [ToType] [Return]
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12024)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12025) // R (*)(A) --> R (A), IsNonStaticMemberFunction = false
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12026) // R (&)(A) --> R (A), IsNonStaticMemberFunction = false
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12027) // R (S::*)(A) --> R (A), IsNonStaticMemberFunction = true
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12028) void inline ExtractUnqualifiedFunctionTypeFromTargetType() {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12029) TargetFunctionType = S.ExtractUnqualifiedFunctionType(TargetType);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12030) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12031)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12032) // return true if any matching specializations were found
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12033) bool AddMatchingTemplateFunction(FunctionTemplateDecl* FunctionTemplate,
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12034) const DeclAccessPair& CurAccessFunPair) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12035) if (CXXMethodDecl *Method
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12036) = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12037) // Skip non-static function templates when converting to pointer, and
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12038) // static when converting to member pointer.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12039) if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12040) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12041) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12042) else if (TargetTypeIsNonStaticMemberFunction)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12043) return false;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12044)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12045) // C++ [over.over]p2:
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12046) // If the name is a function template, template argument deduction is
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12047) // done (14.8.2.2), and if the argument deduction succeeds, the
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12048) // resulting template argument list is used to generate a single
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12049) // function template specialization, which is added to the set of
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12050) // overloaded functions considered.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12051) FunctionDecl *Specialization = nullptr;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12052) TemplateDeductionInfo Info(FailedCandidates.getLocation());
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12053) if (Sema::TemplateDeductionResult Result
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12054) = S.DeduceTemplateArguments(FunctionTemplate,
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12055) &OvlExplicitTemplateArgs,
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12056) TargetFunctionType, Specialization,
+baa4783d310c7 (Richard Smith 2016-12-01 02:11:49 +0000 12057) Info, /*IsAddressOfFunction*/true)) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12058) // Make a note of the failed deduction for diagnostics.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12059) FailedCandidates.addCandidate()
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 12060) .set(CurAccessFunPair, FunctionTemplate->getTemplatedDecl(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12061) MakeDeductionFailureInfo(Context, Result, Info));
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12062) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12063) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12064)
+19a41f161b87b (Douglas Gregor 2013-04-17 08:45:07 +0000 12065) // Template argument deduction ensures that we have an exact match or
+19a41f161b87b (Douglas Gregor 2013-04-17 08:45:07 +0000 12066) // compatible pointer-to-function arguments that would be adjusted by ICS.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12067) // This function template specicalization works.
+19a41f161b87b (Douglas Gregor 2013-04-17 08:45:07 +0000 12068) assert(S.isSameOrCompatibleFunctionType(
+19a41f161b87b (Douglas Gregor 2013-04-17 08:45:07 +0000 12069) Context.getCanonicalType(Specialization->getType()),
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 12070) Context.getCanonicalType(TargetFunctionType)));
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12071)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 12072) if (!S.checkAddressOfFunctionIsAvailable(Specialization))
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12073) return false;
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12074)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12075) Matches.push_back(std::make_pair(CurAccessFunPair, Specialization));
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12076) return true;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12077) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12078)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12079) bool AddMatchingNonTemplateFunction(NamedDecl* Fn,
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12080) const DeclAccessPair& CurAccessFunPair) {
+c25c6ee3dbf28 (Chandler Carruth 2009-12-29 06:17:27 +0000 12081) if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
+18f8ff62a3adb (Sebastian Redl 2009-02-04 21:23:32 +0000 12082) // Skip non-static functions when converting to pointer, and static
+18f8ff62a3adb (Sebastian Redl 2009-02-04 21:23:32 +0000 12083) // when converting to member pointer.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12084) if (Method->isStatic() == TargetTypeIsNonStaticMemberFunction)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12085) return false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12086) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12087) else if (TargetTypeIsNonStaticMemberFunction)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12088) return false;
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 12089)
+c25c6ee3dbf28 (Chandler Carruth 2009-12-29 06:17:27 +0000 12090) if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) {
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 12091) if (S.getLangOpts().CUDA)
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 12092) if (FunctionDecl *Caller = dyn_cast<FunctionDecl>(S.CurContext))
+b008003aa3f0d (Justin Lebar 2016-08-10 01:09:11 +0000 12093) if (!Caller->isImplicit() && !S.IsAllowedCUDACall(Caller, FunDecl))
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 12094) return false;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 12095) if (FunDecl->isMultiVersion()) {
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 12096) const auto *TA = FunDecl->getAttr<TargetAttr>();
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 12097) if (TA && !TA->isDefaultVersion())
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 12098) return false;
+281d20b601c8a (Erich Keane 2018-01-08 21:34:17 +0000 12099) }
+7277fe8aed6e1 (Peter Collingbourne 2011-10-02 23:49:40 +0000 12100)
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 12101) // If any candidate has a placeholder return type, trigger its deduction
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 12102) // now.
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12103) if (completeFunctionType(S, FunDecl, SourceExpr->getBeginLoc(),
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 12104) Complain)) {
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12105) HasComplained |= Complain;
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 12106) return false;
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12107) }
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 12108)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 12109) if (!S.checkAddressOfFunctionIsAvailable(FunDecl))
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12110) return false;
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12111)
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 12112) // If we're in C, we need to support types that aren't exactly identical.
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 12113) if (!S.getLangOpts().CPlusPlus ||
+6da4c20f7daa6 (George Burgess IV 2016-03-23 02:33:58 +0000 12114) candidateHasExactlyCorrectType(FunDecl)) {
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12115) Matches.push_back(std::make_pair(
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12116) CurAccessFunPair, cast<FunctionDecl>(FunDecl->getCanonicalDecl())));
+b257e4fff8a94 (Douglas Gregor 2009-07-08 23:33:52 +0000 12117) FoundNonTemplateFunction = true;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12118) return true;
+b257e4fff8a94 (Douglas Gregor 2009-07-08 23:33:52 +0000 12119) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12120) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12121)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12122) return false;
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 12123) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12124)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12125) bool FindAllFunctionsThatMatchTargetTypeExactly() {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12126) bool Ret = false;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12127)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12128) // If the overload expression doesn't have the form of a pointer to
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12129) // member, don't try to convert it to a pointer-to-member type.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12130) if (IsInvalidFormOfPointerToMemberFunction())
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12131) return false;
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 12132)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12133) for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12134) E = OvlExpr->decls_end();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12135) I != E; ++I) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12136) // Look through any using declarations to find the underlying function.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12137) NamedDecl *Fn = (*I)->getUnderlyingDecl();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12138)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12139) // C++ [over.over]p3:
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12140) // Non-member functions and static member functions match
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12141) // targets of type "pointer-to-function" or "reference-to-function."
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12142) // Nonstatic member functions match targets of
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12143) // type "pointer-to-member-function."
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12144) // Note that according to DR 247, the containing class does not matter.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12145) if (FunctionTemplateDecl *FunctionTemplate
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12146) = dyn_cast<FunctionTemplateDecl>(Fn)) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12147) if (AddMatchingTemplateFunction(FunctionTemplate, I.getPair()))
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12148) Ret = true;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12149) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12150) // If we have explicit template arguments supplied, skip non-templates.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12151) else if (!OvlExpr->hasExplicitTemplateArgs() &&
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12152) AddMatchingNonTemplateFunction(Fn, I.getPair()))
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12153) Ret = true;
+5bb5e4ad9d8ed (Douglas Gregor 2010-10-12 23:32:35 +0000 12154) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12155) assert(Ret || Matches.empty());
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12156) return Ret;
+df4b80e7c0caf (Sebastian Redl 2009-10-17 21:12:09 +0000 12157) }
+b257e4fff8a94 (Douglas Gregor 2009-07-08 23:33:52 +0000 12158)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12159) void EliminateAllExceptMostSpecializedTemplate() {
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12160) // [...] and any given function template specialization F1 is
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12161) // eliminated if the set contains a second function template
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12162) // specialization whose function template is more specialized
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12163) // than the function template of F1 according to the partial
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12164) // ordering rules of 14.5.5.2.
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12165)
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12166) // The algorithm specified above is quadratic. We instead use a
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12167) // two-pass algorithm (similar to the one used to identify the
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12168) // best viable function in an overload set) that identifies the
+05155d8d7b215 (Douglas Gregor 2009-08-21 23:19:43 +0000 12169) // best function template (if it exists).
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12170)
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12171) UnresolvedSet<4> MatchesCopy; // TODO: avoid!
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12172) for (unsigned I = 0, E = Matches.size(); I != E; ++I)
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12173) MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12174)
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12175) // TODO: It looks like FailedCandidates does not serve much purpose
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12176) // here, since the no_viable diagnostic has index 0.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12177) UnresolvedSetIterator Result = S.getMostSpecialized(
+35e1da259fcfb (Richard Smith 2013-09-10 22:59:25 +0000 12178) MatchesCopy.begin(), MatchesCopy.end(), FailedCandidates,
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12179) SourceExpr->getBeginLoc(), S.PDiag(),
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 12180) S.PDiag(diag::err_addr_ovl_ambiguous)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 12181) << Matches[0].second->getDeclName(),
+5179eb78210a2 (Richard Smith 2016-06-28 19:03:57 +0000 12182) S.PDiag(diag::note_ovl_candidate)
+92e523bf55087 (Eric Fiselier 2018-05-30 01:00:41 +0000 12183) << (unsigned)oc_function << (unsigned)ocs_described_template,
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12184) Complain, TargetFunctionType);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12185)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12186) if (Result != MatchesCopy.end()) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12187) // Make it the first and only element
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12188) Matches[0].first = Matches[Result - MatchesCopy.begin()].first;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12189) Matches[0].second = cast<FunctionDecl>(*Result);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12190) Matches.resize(1);
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12191) } else
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12192) HasComplained |= Complain;
+b257e4fff8a94 (Douglas Gregor 2009-07-08 23:33:52 +0000 12193) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12194)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12195) void EliminateAllTemplateMatches() {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12196) // [...] any function template specializations in the set are
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12197) // eliminated if the set also contains a non-template function, [...]
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12198) for (unsigned I = 0, N = Matches.size(); I != N; ) {
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12199) if (Matches[I].second->getPrimaryTemplate() == nullptr)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12200) ++I;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12201) else {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12202) Matches[I] = Matches[--N];
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 12203) Matches.resize(N);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12204) }
+58cc69d4c1516 (John McCall 2010-01-27 01:50:18 +0000 12205) }
+58cc69d4c1516 (John McCall 2010-01-27 01:50:18 +0000 12206) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12207)
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 12208) void EliminateSuboptimalCudaMatches() {
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 12209) S.EraseUnwantedCUDAMatches(dyn_cast<FunctionDecl>(S.CurContext), Matches);
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 12210) }
+94a55e8169a1e (Artem Belevich 2015-09-22 17:22:59 +0000 12211)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12212) public:
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12213) void ComplainNoMatchesFound() const {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12214) assert(Matches.empty());
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12215) S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_no_viable)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12216) << OvlExpr->getName() << TargetFunctionType
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12217) << OvlExpr->getSourceRange();
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12218) if (FailedCandidates.empty())
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12219) S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12220) /*TakingAddress=*/true);
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12221) else {
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12222) // We have some deduction failure messages. Use them to diagnose
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12223) // the function templates, and diagnose the non-template candidates
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12224) // normally.
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12225) for (UnresolvedSetIterator I = OvlExpr->decls_begin(),
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12226) IEnd = OvlExpr->decls_end();
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12227) I != IEnd; ++I)
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12228) if (FunctionDecl *Fun =
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12229) dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl()))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 12230) if (!functionHasPassObjectSizeParams(Fun))
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 12231) S.NoteOverloadCandidate(*I, Fun, CRK_None, TargetFunctionType,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 12232) /*TakingAddress=*/true);
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12233) FailedCandidates.NoteCandidates(S, OvlExpr->getBeginLoc());
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12234) }
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12235) }
+0d905476f8316 (Richard Smith 2013-08-14 00:00:44 +0000 12236)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12237) bool IsInvalidFormOfPointerToMemberFunction() const {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12238) return TargetTypeIsNonStaticMemberFunction &&
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12239) !OvlExprInfo.HasFormOfMemberPointer;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12240) }
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12241)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12242) void ComplainIsInvalidFormOfPointerToMemberFunction() const {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12243) // TODO: Should we condition this on whether any functions might
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12244) // have matched, or is it more appropriate to do that in callers?
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12245) // TODO: a fixit wouldn't hurt.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12246) S.Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12247) << TargetType << OvlExpr->getSourceRange();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12248) }
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12249)
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12250) bool IsStaticMemberFunctionFromBoundPointer() const {
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12251) return StaticMemberFunctionFromBoundPointer;
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12252) }
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12253)
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12254) void ComplainIsStaticMemberFunctionFromBoundPointer() const {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12255) S.Diag(OvlExpr->getBeginLoc(),
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12256) diag::err_invalid_form_pointer_member_function)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12257) << OvlExpr->getSourceRange();
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12258) }
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12259)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12260) void ComplainOfInvalidConversion() const {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12261) S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_not_func_ptrref)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12262) << OvlExpr->getName() << TargetType;
+df4b80e7c0caf (Sebastian Redl 2009-10-17 21:12:09 +0000 12263) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12264)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12265) void ComplainMultipleMatchesFound() const {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12266) assert(Matches.size() > 1);
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12267) S.Diag(OvlExpr->getBeginLoc(), diag::err_addr_ovl_ambiguous)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12268) << OvlExpr->getName() << OvlExpr->getSourceRange();
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12269) S.NoteAllOverloadCandidates(OvlExpr, TargetFunctionType,
+5f21c718007fd (George Burgess IV 2015-10-12 19:57:04 +0000 12270) /*TakingAddress=*/true);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12271) }
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12272)
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12273) bool hadMultipleCandidates() const { return (OvlExpr->getNumDecls() > 1); }
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12274)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12275) int getNumMatches() const { return Matches.size(); }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12276)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12277) FunctionDecl* getMatchingFunctionDecl() const {
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12278) if (Matches.size() != 1) return nullptr;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12279) return Matches[0].second;
+e81f58e180117 (Douglas Gregor 2010-11-08 03:40:48 +0000 12280) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12281)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12282) const DeclAccessPair* getMatchingFunctionAccessPair() const {
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12283) if (Matches.size() != 1) return nullptr;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12284) return &Matches[0].first;
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12285) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12286) };
+ab9db51042d1b (Alexander Kornienko 2015-06-22 23:07:51 +0000 12287) }
+17c00b43288dc (Richard Smith 2014-11-12 01:24:00 +0000 12288)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12289) /// ResolveAddressOfOverloadedFunction - Try to resolve the address of
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12290) /// an overloaded function (C++ [over.over]), where @p From is an
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12291) /// expression with overloaded function type and @p ToType is the type
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12292) /// we're trying to resolve to. For example:
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12293) ///
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12294) /// @code
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12295) /// int f(double);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12296) /// int f(int);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12297) ///
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12298) /// int (*pfd)(double) = f; // selects f(double)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12299) /// @endcode
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12300) ///
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12301) /// This routine returns the resulting FunctionDecl if it could be
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12302) /// resolved, and NULL otherwise. When @p Complain is true, this
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12303) /// routine will emit diagnostics if there is an error.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12304) FunctionDecl *
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12305) Sema::ResolveAddressOfOverloadedFunction(Expr *AddressOfExpr,
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12306) QualType TargetType,
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12307) bool Complain,
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12308) DeclAccessPair &FoundResult,
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12309) bool *pHadMultipleCandidates) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12310) assert(AddressOfExpr->getType() == Context.OverloadTy);
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12311)
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12312) AddressOfFunctionResolver Resolver(*this, AddressOfExpr, TargetType,
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12313) Complain);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12314) int NumMatches = Resolver.getNumMatches();
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12315) FunctionDecl *Fn = nullptr;
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12316) bool ShouldComplain = Complain && !Resolver.hasComplained();
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12317) if (NumMatches == 0 && ShouldComplain) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12318) if (Resolver.IsInvalidFormOfPointerToMemberFunction())
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12319) Resolver.ComplainIsInvalidFormOfPointerToMemberFunction();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12320) else
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12321) Resolver.ComplainNoMatchesFound();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12322) }
+5f2ef457bfb1d (George Burgess IV 2015-10-12 18:40:58 +0000 12323) else if (NumMatches > 1 && ShouldComplain)
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12324) Resolver.ComplainMultipleMatchesFound();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12325) else if (NumMatches == 1) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12326) Fn = Resolver.getMatchingFunctionDecl();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12327) assert(Fn);
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 12328) if (auto *FPT = Fn->getType()->getAs<FunctionProtoType>())
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 12329) ResolveExceptionSpec(AddressOfExpr->getExprLoc(), FPT);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12330) FoundResult = *Resolver.getMatchingFunctionAccessPair();
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12331) if (Complain) {
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12332) if (Resolver.IsStaticMemberFunctionFromBoundPointer())
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12333) Resolver.ComplainIsStaticMemberFunctionFromBoundPointer();
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12334) else
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12335) CheckAddressOfMemberAccess(AddressOfExpr, FoundResult);
+a4f7c7a600c3e (David Majnemer 2013-08-01 06:13:59 +0000 12336) }
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12337) }
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12338)
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12339) if (pHadMultipleCandidates)
+5001caa1b6320 (Abramo Bagnara 2011-11-19 11:44:21 +0000 12340) *pHadMultipleCandidates = Resolver.hadMultipleCandidates();
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12341) return Fn;
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 12342) }
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 12343)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 12344) /// Given an expression that refers to an overloaded function, try to
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12345) /// resolve that function to a single function that can have its address taken.
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12346) /// This will modify `Pair` iff it returns non-null.
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12347) ///
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12348) /// This routine can only succeed if from all of the candidates in the overload
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12349) /// set for SrcExpr that can have their addresses taken, there is one candidate
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12350) /// that is more constrained than the rest.
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12351) FunctionDecl *
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12352) Sema::resolveAddressOfSingleOverloadCandidate(Expr *E, DeclAccessPair &Pair) {
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12353) OverloadExpr::FindResult R = OverloadExpr::find(E);
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12354) OverloadExpr *Ovl = R.Expression;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12355) bool IsResultAmbiguous = false;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12356) FunctionDecl *Result = nullptr;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12357) DeclAccessPair DAP;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12358) SmallVector<FunctionDecl *, 2> AmbiguousDecls;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12359)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12360) auto CheckMoreConstrained =
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12361) [&] (FunctionDecl *FD1, FunctionDecl *FD2) -> Optional<bool> {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12362) SmallVector<const Expr *, 1> AC1, AC2;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12363) FD1->getAssociatedConstraints(AC1);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12364) FD2->getAssociatedConstraints(AC2);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12365) bool AtLeastAsConstrained1, AtLeastAsConstrained2;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12366) if (IsAtLeastAsConstrained(FD1, AC1, FD2, AC2, AtLeastAsConstrained1))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12367) return None;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12368) if (IsAtLeastAsConstrained(FD2, AC2, FD1, AC1, AtLeastAsConstrained2))
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12369) return None;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12370) if (AtLeastAsConstrained1 == AtLeastAsConstrained2)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12371) return None;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12372) return AtLeastAsConstrained1;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12373) };
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12374)
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12375) // Don't use the AddressOfResolver because we're specifically looking for
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12376) // cases where we have one overload candidate that lacks
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12377) // enable_if/pass_object_size/...
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12378) for (auto I = Ovl->decls_begin(), E = Ovl->decls_end(); I != E; ++I) {
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12379) auto *FD = dyn_cast<FunctionDecl>(I->getUnderlyingDecl());
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12380) if (!FD)
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12381) return nullptr;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12382)
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12383) if (!checkAddressOfFunctionIsAvailable(FD))
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12384) continue;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12385)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12386) // We have more than one result - see if it is more constrained than the
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12387) // previous one.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12388) if (Result) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12389) Optional<bool> MoreConstrainedThanPrevious = CheckMoreConstrained(FD,
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12390) Result);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12391) if (!MoreConstrainedThanPrevious) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12392) IsResultAmbiguous = true;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12393) AmbiguousDecls.push_back(FD);
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12394) continue;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12395) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12396) if (!*MoreConstrainedThanPrevious)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12397) continue;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12398) // FD is more constrained - replace Result with it.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12399) }
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12400) IsResultAmbiguous = false;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12401) DAP = I.getPair();
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12402) Result = FD;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12403) }
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12404)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12405) if (IsResultAmbiguous)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12406) return nullptr;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12407)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12408) if (Result) {
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12409) SmallVector<const Expr *, 1> ResultAC;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12410) // We skipped over some ambiguous declarations which might be ambiguous with
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12411) // the selected result.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12412) for (FunctionDecl *Skipped : AmbiguousDecls)
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12413) if (!CheckMoreConstrained(Skipped, Result).hasValue())
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12414) return nullptr;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12415) Pair = DAP;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12416) }
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12417) return Result;
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12418) }
+3cde9bf9d5734 (George Burgess IV 2016-03-19 21:36:10 +0000 12419)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 12420) /// Given an overloaded function, tries to turn it into a non-overloaded
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12421) /// function reference using resolveAddressOfSingleOverloadCandidate. This
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12422) /// will perform access checks, diagnose the use of the resultant decl, and, if
+1dbfa856b1172 (George Burgess IV 2017-05-09 04:06:24 +0000 12423) /// requested, potentially perform a function-to-pointer decay.
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12424) ///
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12425) /// Returns false if resolveAddressOfSingleOverloadCandidate fails.
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12426) /// Otherwise, returns true. This may emit diagnostics and return true.
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12427) bool Sema::resolveAndFixAddressOfSingleOverloadCandidate(
+1dbfa856b1172 (George Burgess IV 2017-05-09 04:06:24 +0000 12428) ExprResult &SrcExpr, bool DoFunctionPointerConverion) {
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12429) Expr *E = SrcExpr.get();
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12430) assert(E->getType() == Context.OverloadTy && "SrcExpr must be an overload");
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12431)
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12432) DeclAccessPair DAP;
+b65b1f322bd88 (Saar Raz 2020-01-09 15:07:51 +0200 12433) FunctionDecl *Found = resolveAddressOfSingleOverloadCandidate(E, DAP);
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 12434) if (!Found || Found->isCPUDispatchMultiVersion() ||
+3efe00206f0f4 (Erich Keane 2018-07-20 14:13:28 +0000 12435) Found->isCPUSpecificMultiVersion())
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12436) return false;
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12437)
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12438) // Emitting multiple diagnostics for a function that is both inaccessible and
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12439) // unavailable is consistent with our behavior elsewhere. So, always check
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12440) // for both.
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12441) DiagnoseUseOfDecl(Found, E->getExprLoc());
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12442) CheckAddressOfMemberAccess(E, DAP);
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12443) Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
+1dbfa856b1172 (George Burgess IV 2017-05-09 04:06:24 +0000 12444) if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12445) SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12446) else
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12447) SrcExpr = Fixed;
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12448) return true;
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12449) }
+beca4a3338ab3 (George Burgess IV 2016-06-08 00:34:22 +0000 12450)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 12451) /// Given an expression that refers to an overloaded function, try to
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12452) /// resolve that overloaded function expression down to a single function.
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12453) ///
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12454) /// This routine can only resolve template-ids that refer to a single function
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12455) /// template, where that template-id refers to a single template whose template
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12456) /// arguments are either provided by the template-id or have defaults,
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12457) /// as described in C++0x [temp.arg.explicit]p3.
+67b47ac0a76bd (Alp Toker 2013-10-20 18:48:56 +0000 12458) ///
+67b47ac0a76bd (Alp Toker 2013-10-20 18:48:56 +0000 12459) /// If no template-ids are found, no diagnostics are emitted and NULL is
+67b47ac0a76bd (Alp Toker 2013-10-20 18:48:56 +0000 12460) /// returned.
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12461) FunctionDecl *
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12462) Sema::ResolveSingleFunctionTemplateSpecialization(OverloadExpr *ovl,
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12463) bool Complain,
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12464) DeclAccessPair *FoundResult) {
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12465) // C++ [over.over]p1:
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12466) // [...] [Note: any redundant set of parentheses surrounding the
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12467) // overloaded function name is ignored (5.1). ]
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12468) // C++ [over.over]p1:
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12469) // [...] The overloaded function name can be preceded by the &
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12470) // operator.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12471)
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12472) // If we didn't actually find any template-ids, we're done.
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12473) if (!ovl->hasExplicitTemplateArgs())
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12474) return nullptr;
+1acbbb5a4c6e6 (John McCall 2010-02-02 06:20:04 +0000 12475)
+1acbbb5a4c6e6 (John McCall 2010-02-02 06:20:04 +0000 12476) TemplateArgumentListInfo ExplicitTemplateArgs;
+04ec5bfad8ff4 (James Y Knight 2015-12-24 02:59:37 +0000 12477) ovl->copyTemplateArgumentsInto(ExplicitTemplateArgs);
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12478) TemplateSpecCandidateSet FailedCandidates(ovl->getNameLoc());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12479)
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12480) // Look through all of the overloaded functions, searching for one
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12481) // whose type matches exactly.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12482) FunctionDecl *Matched = nullptr;
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12483) for (UnresolvedSetIterator I = ovl->decls_begin(),
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12484) E = ovl->decls_end(); I != E; ++I) {
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12485) // C++0x [temp.arg.explicit]p3:
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12486) // [...] In contexts where deduction is done and fails, or in contexts
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12487) // where deduction is not done, if a template argument list is
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12488) // specified and it, along with any default template arguments,
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12489) // identifies a single function template specialization, then the
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12490) // template-id is an lvalue for the function template specialization.
+eebe72199e186 (Douglas Gregor 2010-07-14 23:20:53 +0000 12491) FunctionTemplateDecl *FunctionTemplate
+eebe72199e186 (Douglas Gregor 2010-07-14 23:20:53 +0000 12492) = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12493)
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12494) // C++ [over.over]p2:
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12495) // If the name is a function template, template argument deduction is
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12496) // done (14.8.2.2), and if the argument deduction succeeds, the
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12497) // resulting template argument list is used to generate a single
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12498) // function template specialization, which is added to the set of
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12499) // overloaded functions considered.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12500) FunctionDecl *Specialization = nullptr;
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12501) TemplateDeductionInfo Info(FailedCandidates.getLocation());
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12502) if (TemplateDeductionResult Result
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12503) = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs,
+19a41f161b87b (Douglas Gregor 2013-04-17 08:45:07 +0000 12504) Specialization, Info,
+baa4783d310c7 (Richard Smith 2016-12-01 02:11:49 +0000 12505) /*IsAddressOfFunction*/true)) {
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12506) // Make a note of the failed deduction for diagnostics.
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12507) // TODO: Actually use the failed-deduction info?
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12508) FailedCandidates.addCandidate()
+c2bebe9acab26 (Richard Smith 2016-05-11 20:37:46 +0000 12509) .set(I.getPair(), FunctionTemplate->getTemplatedDecl(),
+98b20f1278e09 (Larisse Voufo 2013-07-19 23:00:19 +0000 12510) MakeDeductionFailureInfo(Context, Result, Info));
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12511) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12512) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12513)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12514) assert(Specialization && "no specialization and no error?");
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12515)
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12516) // Multiple matches; we can't resolve to a single declaration.
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12517) if (Matched) {
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12518) if (Complain) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12519) Diag(ovl->getExprLoc(), diag::err_addr_ovl_ambiguous)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12520) << ovl->getName();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12521) NoteAllOverloadCandidates(ovl);
+b491ed36b4ef9 (Douglas Gregor 2011-02-19 21:32:49 +0000 12522) }
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12523) return nullptr;
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12524) }
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12525)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12526) Matched = Specialization;
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12527) if (FoundResult) *FoundResult = I.getPair();
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12528) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12529)
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 12530) if (Matched &&
+9095e5bf7e4fc (Richard Smith 2016-11-01 01:31:23 +0000 12531) completeFunctionType(*this, Matched, ovl->getExprLoc(), Complain))
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12532) return nullptr;
+2a7d481faf546 (Richard Smith 2013-05-04 07:00:32 +0000 12533)
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12534) return Matched;
+8364e6b56856e (Douglas Gregor 2009-12-21 23:17:24 +0000 12535) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12536)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12537) // Resolve and fix an overloaded expression that can be resolved
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12538) // because it identifies a single function template specialization.
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12539) //
+1beec45a618b4 (Douglas Gregor 2011-03-12 01:48:56 +0000 12540) // Last three arguments should only be supplied if Complain = true
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12541) //
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12542) // Return true if it was logically possible to so resolve the
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12543) // expression, regardless of whether or not it succeeded. Always
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12544) // returns true if 'complain' is set.
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12545) bool Sema::ResolveAndFixSingleFunctionTemplateSpecialization(
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12546) ExprResult &SrcExpr, bool doFunctionPointerConverion,
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12547) bool complain, SourceRange OpRangeForComplaining,
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12548) QualType DestTypeForComplaining,
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12549) unsigned DiagIDForComplaining) {
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12550) assert(SrcExpr.get()->getType() == Context.OverloadTy);
+1beec45a618b4 (Douglas Gregor 2011-03-12 01:48:56 +0000 12551)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12552) OverloadExpr::FindResult ovl = OverloadExpr::find(SrcExpr.get());
+1beec45a618b4 (Douglas Gregor 2011-03-12 01:48:56 +0000 12553)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12554) DeclAccessPair found;
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12555) ExprResult SingleFunctionExpression;
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12556) if (FunctionDecl *fn = ResolveSingleFunctionTemplateSpecialization(
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12557) ovl.Expression, /*complain*/ false, &found)) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 12558) if (DiagnoseUseOfDecl(fn, SrcExpr.get()->getBeginLoc())) {
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12559) SrcExpr = ExprError();
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12560) return true;
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12561) }
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12562)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12563) // It is only correct to resolve to an instance method if we're
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12564) // resolving a form that's permitted to be a pointer to member.
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12565) // Otherwise we'll end up making a bound member expression, which
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12566) // is illegal in all the contexts we resolve like this.
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12567) if (!ovl.HasFormOfMemberPointer &&
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12568) isa<CXXMethodDecl>(fn) &&
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12569) cast<CXXMethodDecl>(fn)->isInstance()) {
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12570) if (!complain) return false;
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12571)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12572) Diag(ovl.Expression->getExprLoc(),
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12573) diag::err_bound_member_function)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12574) << 0 << ovl.Expression->getSourceRange();
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12575)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12576) // TODO: I believe we only end up here if there's a mix of
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12577) // static and non-static candidates (otherwise the expression
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12578) // would have 'bound member' type, not 'overload' type).
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12579) // Ideally we would note which candidate was chosen and why
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12580) // the static candidates were rejected.
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12581) SrcExpr = ExprError();
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12582) return true;
+1beec45a618b4 (Douglas Gregor 2011-03-12 01:48:56 +0000 12583) }
+89f3cd5c15212 (Douglas Gregor 2011-03-16 19:16:25 +0000 12584)
+a5202660fb2f2 (Sylvestre Ledru 2012-07-31 06:56:50 +0000 12585) // Fix the expression to refer to 'fn'.
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12586) SingleFunctionExpression =
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 12587) FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12588)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12589) // If desired, do function-to-pointer decay.
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12590) if (doFunctionPointerConverion) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12591) SingleFunctionExpression =
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 12592) DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12593) if (SingleFunctionExpression.isInvalid()) {
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12594) SrcExpr = ExprError();
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12595) return true;
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12596) }
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12597) }
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12598) }
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12599)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12600) if (!SingleFunctionExpression.isUsable()) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12601) if (complain) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12602) Diag(OpRangeForComplaining.getBegin(), DiagIDForComplaining)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12603) << ovl.Expression->getName()
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12604) << DestTypeForComplaining
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 12605) << OpRangeForComplaining
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12606) << ovl.Expression->getQualifierLoc().getSourceRange();
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12607) NoteAllOverloadCandidates(SrcExpr.get());
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12608)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12609) SrcExpr = ExprError();
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12610) return true;
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12611) }
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12612)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12613) return false;
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12614) }
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 12615)
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12616) SrcExpr = SingleFunctionExpression;
+50a2c2c19de5e (John McCall 2011-10-11 23:14:30 +0000 12617) return true;
+1beec45a618b4 (Douglas Gregor 2011-03-12 01:48:56 +0000 12618) }
+1beec45a618b4 (Douglas Gregor 2011-03-12 01:48:56 +0000 12619)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 12620) /// Add a single candidate to the overload set.
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12621) static void AddOverloadedCallCandidate(Sema &S,
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12622) DeclAccessPair FoundDecl,
+739b107af8003 (Douglas Gregor 2011-03-03 02:41:12 +0000 12623) TemplateArgumentListInfo *ExplicitTemplateArgs,
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 12624) ArrayRef<Expr *> Args,
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12625) OverloadCandidateSet &CandidateSet,
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12626) bool PartialOverloading,
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12627) bool KnownValid) {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12628) NamedDecl *Callee = FoundDecl.getDecl();
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12629) if (isa<UsingShadowDecl>(Callee))
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12630) Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl();
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12631)
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12632) if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) {
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12633) if (ExplicitTemplateArgs) {
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12634) assert(!KnownValid && "Explicit template arguments?");
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12635) return;
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12636) }
+370296302d037 (Bruno Cardoso Lopes 2017-04-26 20:13:45 +0000 12637) // Prevent ill-formed function decls to be added as overload candidates.
+370296302d037 (Bruno Cardoso Lopes 2017-04-26 20:13:45 +0000 12638) if (!dyn_cast<FunctionProtoType>(Func->getType()->getAs<FunctionType>()))
+370296302d037 (Bruno Cardoso Lopes 2017-04-26 20:13:45 +0000 12639) return;
+370296302d037 (Bruno Cardoso Lopes 2017-04-26 20:13:45 +0000 12640)
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 12641) S.AddOverloadCandidate(Func, FoundDecl, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 12642) /*SuppressUserConversions=*/false,
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 12643) PartialOverloading);
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12644) return;
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12645) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12646)
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12647) if (FunctionTemplateDecl *FuncTemplate
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12648) = dyn_cast<FunctionTemplateDecl>(Callee)) {
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 12649) S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl,
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 12650) ExplicitTemplateArgs, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 12651) /*SuppressUserConversions=*/false,
+975a9f6ecea60 (Francisco Lopes da Silva 2015-01-21 16:24:11 +0000 12652) PartialOverloading);
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12653) return;
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12654) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12655)
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12656) assert(!KnownValid && "unhandled case in overloaded call candidate");
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12657) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 12658)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 12659) /// Add the overload candidates named by callee and/or found by argument
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12660) /// dependent lookup to the given overload set.
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12661) void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 12662) ArrayRef<Expr *> Args,
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12663) OverloadCandidateSet &CandidateSet,
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12664) bool PartialOverloading) {
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12665)
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12666) #ifndef NDEBUG
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12667) // Verify that ArgumentDependentLookup is consistent with the rules
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12668) // in C++0x [basic.lookup.argdep]p3:
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12669) //
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12670) // Let X be the lookup set produced by unqualified lookup (3.4.1)
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12671) // and let Y be the lookup set produced by argument dependent
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12672) // lookup (defined as follows). If X contains
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12673) //
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12674) // -- a declaration of a class member, or
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12675) //
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12676) // -- a block-scope function declaration that is not a
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12677) // using-declaration, or
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12678) //
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12679) // -- a declaration that is neither a function or a function
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12680) // template
+b8a9a41dd6ea0 (Douglas Gregor 2009-02-04 15:01:18 +0000 12681) //
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 12682) // then Y is empty.
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12683)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12684) if (ULE->requiresADL()) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12685) for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12686) E = ULE->decls_end(); I != E; ++I) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12687) assert(!(*I)->getDeclContext()->isRecord());
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12688) assert(isa<UsingShadowDecl>(*I) ||
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12689) !(*I)->getDeclContext()->isFunctionOrMethod());
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12690) assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate());
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12691) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12692) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12693) #endif
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12694)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12695) // It would be nice to avoid this copy.
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12696) TemplateArgumentListInfo TABuffer;
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12697) TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12698) if (ULE->hasExplicitTemplateArgs()) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12699) ULE->copyTemplateArgumentsInto(TABuffer);
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12700) ExplicitTemplateArgs = &TABuffer;
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12701) }
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12702)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12703) for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(),
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12704) E = ULE->decls_end(); I != E; ++I)
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 12705) AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 12706) CandidateSet, PartialOverloading,
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 12707) /*KnownValid*/ true);
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 12708)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12709) if (ULE->requiresADL())
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 12710) AddArgumentDependentLookupCandidates(ULE->getName(), ULE->getExprLoc(),
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 12711) Args, ExplicitTemplateArgs,
+b6626748c2e50 (Richard Smith 2012-10-18 17:56:02 +0000 12712) CandidateSet, PartialOverloading);
+cabea40ea3c9b (Douglas Gregor 2009-09-22 15:41:20 +0000 12713) }
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12714)
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12715) /// Add the call candidates from the given set of lookup results to the given
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12716) /// overload set. Non-function lookup results are ignored.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12717) void Sema::AddOverloadedCallCandidates(
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12718) LookupResult &R, TemplateArgumentListInfo *ExplicitTemplateArgs,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12719) ArrayRef<Expr *> Args, OverloadCandidateSet &CandidateSet) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12720) for (LookupResult::iterator I = R.begin(), E = R.end(); I != E; ++I)
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12721) AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, Args,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12722) CandidateSet, false, /*KnownValid*/ false);
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12723) }
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12724)
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12725) /// Determine whether a declaration with the specified name could be moved into
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12726) /// a
diff erent namespace.
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12727) static bool canBeDeclaredInNamespace(const DeclarationName &Name) {
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12728) switch (Name.getCXXOverloadedOperator()) {
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12729) case OO_New: case OO_Array_New:
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12730) case OO_Delete: case OO_Array_Delete:
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12731) return false;
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12732)
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12733) default:
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12734) return true;
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12735) }
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12736) }
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12737)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12738) /// Attempt to recover from an ill-formed use of a non-dependent name in a
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12739) /// template, where the non-dependent name was declared after the template
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12740) /// was defined. This is common in code written for a compilers which do not
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12741) /// correctly implement two-stage name lookup.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12742) ///
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12743) /// Returns true if a viable candidate was found and a diagnostic was issued.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12744) static bool DiagnoseTwoPhaseLookup(
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12745) Sema &SemaRef, SourceLocation FnLoc, const CXXScopeSpec &SS,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12746) LookupResult &R, OverloadCandidateSet::CandidateSetKind CSK,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12747) TemplateArgumentListInfo *ExplicitTemplateArgs, ArrayRef<Expr *> Args,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12748) CXXRecordDecl **FoundInClass = nullptr) {
+51ec0cf4aa94f (Richard Smith 2017-02-21 01:17:38 +0000 12749) if (!SemaRef.inTemplateInstantiation() || !SS.isEmpty())
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12750) return false;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12751)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12752) for (DeclContext *DC = SemaRef.CurContext; DC; DC = DC->getParent()) {
+fcd5e7a1602cd (Nick Lewycky 2012-03-14 20:41:00 +0000 12753) if (DC->isTransparentContext())
+fcd5e7a1602cd (Nick Lewycky 2012-03-14 20:41:00 +0000 12754) continue;
+fcd5e7a1602cd (Nick Lewycky 2012-03-14 20:41:00 +0000 12755)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12756) SemaRef.LookupQualifiedName(R, DC);
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12757)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12758) if (!R.empty()) {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12759) R.suppressDiagnostics();
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12760)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 12761) OverloadCandidateSet Candidates(FnLoc, CSK);
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12762) SemaRef.AddOverloadedCallCandidates(R, ExplicitTemplateArgs, Args,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12763) Candidates);
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12764)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12765) OverloadCandidateSet::iterator Best;
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12766) OverloadingResult OR =
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12767) Candidates.BestViableFunction(SemaRef, FnLoc, Best);
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12768)
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12769) if (auto *RD = dyn_cast<CXXRecordDecl>(DC)) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12770) // We either found non-function declarations or a best viable function
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12771) // at class scope. A class-scope lookup result disables ADL. Don't
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12772) // look past this, but let the caller know that we found something that
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12773) // either is, or might be, usable in this class.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12774) if (FoundInClass) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12775) *FoundInClass = RD;
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12776) if (OR == OR_Success) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12777) R.clear();
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12778) R.addDecl(Best->FoundDecl.getDecl(), Best->FoundDecl.getAccess());
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12779) R.resolveKind();
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12780) }
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12781) }
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12782) return false;
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12783) }
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12784)
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12785) if (OR != OR_Success) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12786) // There wasn't a unique best function or function template.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12787) return false;
+95ce4f67a3369 (Richard Smith 2011-06-26 22:19:54 +0000 12788) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12789)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12790) // Find the namespaces where ADL would have looked, and suggest
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12791) // declaring the function there instead.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12792) Sema::AssociatedNamespaceSet AssociatedNamespaces;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12793) Sema::AssociatedClassSet AssociatedClasses;
+7d8b041999de9 (John McCall 2012-08-24 20:38:34 +0000 12794) SemaRef.FindAssociatedClassesAndNamespaces(FnLoc, Args,
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12795) AssociatedNamespaces,
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12796) AssociatedClasses);
+d50f1690986f0 (Chandler Carruth 2011-06-05 23:36:55 +0000 12797) Sema::AssociatedNamespaceSet SuggestedNamespaces;
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12798) if (canBeDeclaredInNamespace(R.getLookupName())) {
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12799) DeclContext *Std = SemaRef.getStdNamespace();
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12800) for (Sema::AssociatedNamespaceSet::iterator
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12801) it = AssociatedNamespaces.begin(),
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12802) end = AssociatedNamespaces.end(); it != end; ++it) {
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12803) // Never suggest declaring a function within namespace 'std'.
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12804) if (Std && Std->Encloses(*it))
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12805) continue;
+21bae43fab8fa (Richard Smith 2012-12-22 02:46:14 +0000 12806)
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12807) // Never suggest declaring a function within a namespace with a
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12808) // reserved name, like __gnu_cxx.
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12809) NamespaceDecl *NS = dyn_cast<NamespaceDecl>(*it);
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12810) if (NS &&
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12811) NS->getQualifiedNameAsString().find("__") != std::string::npos)
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12812) continue;
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12813)
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12814) SuggestedNamespaces.insert(*it);
+0603bbb53c53c (Richard Smith 2013-06-12 22:56:54 +0000 12815) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12816) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12817)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12818) SemaRef.Diag(R.getNameLoc(), diag::err_not_found_by_two_phase_lookup)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12819) << R.getLookupName();
+d50f1690986f0 (Chandler Carruth 2011-06-05 23:36:55 +0000 12820) if (SuggestedNamespaces.empty()) {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12821) SemaRef.Diag(Best->Function->getLocation(),
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12822) diag::note_not_found_by_two_phase_lookup)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12823) << R.getLookupName() << 0;
+d50f1690986f0 (Chandler Carruth 2011-06-05 23:36:55 +0000 12824) } else if (SuggestedNamespaces.size() == 1) {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12825) SemaRef.Diag(Best->Function->getLocation(),
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12826) diag::note_not_found_by_two_phase_lookup)
+d50f1690986f0 (Chandler Carruth 2011-06-05 23:36:55 +0000 12827) << R.getLookupName() << 1 << *SuggestedNamespaces.begin();
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12828) } else {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12829) // FIXME: It would be useful to list the associated namespaces here,
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12830) // but the diagnostics infrastructure doesn't provide a way to produce
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12831) // a localized representation of a list of items.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12832) SemaRef.Diag(Best->Function->getLocation(),
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12833) diag::note_not_found_by_two_phase_lookup)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12834) << R.getLookupName() << 2;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12835) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12836)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12837) // Try to recover by calling this function.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12838) return true;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12839) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12840)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12841) R.clear();
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12842) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12843)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12844) return false;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12845) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12846)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12847) /// Attempt to recover from ill-formed use of a non-dependent operator in a
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12848) /// template, where the non-dependent operator was declared after the template
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12849) /// was defined.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12850) ///
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12851) /// Returns true if a viable candidate was found and a diagnostic was issued.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12852) static bool
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12853) DiagnoseTwoPhaseOperatorLookup(Sema &SemaRef, OverloadedOperatorKind Op,
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12854) SourceLocation OpLoc,
+f857950d391d0 (Dmitri Gribenko 2013-01-12 19:30:44 +0000 12855) ArrayRef<Expr *> Args) {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12856) DeclarationName OpName =
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12857) SemaRef.Context.DeclarationNames.getCXXOperatorName(Op);
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12858) LookupResult R(SemaRef, OpName, OpLoc, Sema::LookupOperatorName);
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12859) return DiagnoseTwoPhaseLookup(SemaRef, OpLoc, CXXScopeSpec(), R,
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 12860) OverloadCandidateSet::CSK_Operator,
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12861) /*ExplicitTemplateArgs=*/nullptr, Args);
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12862) }
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12863)
+8edb17d7538bf (Kaelyn Uhrain 2012-01-25 18:37:44 +0000 12864) namespace {
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12865) class BuildRecoveryCallExprRAII {
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12866) Sema &SemaRef;
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12867) public:
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12868) BuildRecoveryCallExprRAII(Sema &S) : SemaRef(S) {
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12869) assert(SemaRef.IsBuildingRecoveryCallExpr == false);
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12870) SemaRef.IsBuildingRecoveryCallExpr = true;
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12871) }
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12872)
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12873) ~BuildRecoveryCallExprRAII() {
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12874) SemaRef.IsBuildingRecoveryCallExpr = false;
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12875) }
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12876) };
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12877)
+ab9db51042d1b (Alexander Kornienko 2015-06-22 23:07:51 +0000 12878) }
+8edb17d7538bf (Kaelyn Uhrain 2012-01-25 18:37:44 +0000 12879)
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12880) /// Attempts to recover from a call where no functions were found.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12881) ///
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12882) /// This function will do one of three things:
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12883) /// * Diagnose, recover, and return a recovery expression.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12884) /// * Diagnose, fail to recover, and return ExprError().
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12885) /// * Do not diagnose, do not recover, and return ExprResult(). The caller is
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12886) /// expected to diagnose as appropriate.
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 12887) static ExprResult
+2fb18b746fdb2 (Douglas Gregor 2010-04-14 20:27:54 +0000 12888) BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12889) UnresolvedLookupExpr *ULE,
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12890) SourceLocation LParenLoc,
+e3d2ecbe86eee (Craig Topper 2014-06-28 23:22:33 +0000 12891) MutableArrayRef<Expr *> Args,
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 12892) SourceLocation RParenLoc,
+9afaf793b36dc (Kaelyn Uhrain 2012-01-25 21:11:35 +0000 12893) bool EmptyLookup, bool AllowTypoCorrection) {
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12894) // Do not try to recover if it is already building a recovery call.
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12895) // This stops infinite loops for template instantiations like
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12896) //
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12897) // template <typename T> auto foo(T t) -> decltype(foo(t)) {}
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12898) // template <typename T> auto foo(T t) -> decltype(foo(&t)) {}
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12899) if (SemaRef.IsBuildingRecoveryCallExpr)
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12900) return ExprResult();
+88d67f341279d (Richard Smith 2012-09-25 04:46:05 +0000 12901) BuildRecoveryCallExprRAII RCE(SemaRef);
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12902)
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12903) CXXScopeSpec SS;
+0da1d43e1600a (Douglas Gregor 2011-02-28 20:01:57 +0000 12904) SS.Adopt(ULE->getQualifierLoc());
+7945c981b974f (Abramo Bagnara 2012-01-27 09:46:47 +0000 12905) SourceLocation TemplateKWLoc = ULE->getTemplateKeywordLoc();
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12906)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12907) TemplateArgumentListInfo TABuffer;
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 12908) TemplateArgumentListInfo *ExplicitTemplateArgs = nullptr;
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12909) if (ULE->hasExplicitTemplateArgs()) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12910) ULE->copyTemplateArgumentsInto(TABuffer);
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12911) ExplicitTemplateArgs = &TABuffer;
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12912) }
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12913)
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12914) LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(),
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12915) Sema::LookupOrdinaryName);
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12916) CXXRecordDecl *FoundInClass = nullptr;
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12917) if (DiagnoseTwoPhaseLookup(SemaRef, Fn->getExprLoc(), SS, R,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12918) OverloadCandidateSet::CSK_Normal,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12919) ExplicitTemplateArgs, Args, &FoundInClass)) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12920) // OK, diagnosed a two-phase lookup issue.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12921) } else if (EmptyLookup) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12922) // Try to recover from an empty lookup with typo correction.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12923) R.clear();
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12924) NoTypoCorrectionCCC NoTypoValidator{};
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12925) FunctionCallFilterCCC FunctionCallValidator(SemaRef, Args.size(),
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12926) ExplicitTemplateArgs != nullptr,
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12927) dyn_cast<MemberExpr>(Fn));
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12928) CorrectionCandidateCallback &Validator =
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12929) AllowTypoCorrection
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12930) ? static_cast<CorrectionCandidateCallback &>(FunctionCallValidator)
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12931) : static_cast<CorrectionCandidateCallback &>(NoTypoValidator);
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12932) if (SemaRef.DiagnoseEmptyLookup(S, SS, R, Validator, ExplicitTemplateArgs,
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12933) Args))
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12934) return ExprError();
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12935) } else if (FoundInClass && SemaRef.getLangOpts().MSVCCompat) {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12936) // We found a usable declaration of the name in a dependent base of some
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12937) // enclosing class.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12938) // FIXME: We should also explain why the candidates found by name lookup
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12939) // were not viable.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12940) if (SemaRef.DiagnoseDependentMemberLookup(R))
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12941) return ExprError();
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12942) } else {
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12943) // We had viable candidates and couldn't recover; let the caller diagnose
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12944) // this.
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12945) return ExprResult();
+70ad396bc49a9 (Bruno Ricci 2019-03-25 17:08:51 +0000 12946) }
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12947)
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12948) // If we get here, we should have issued a diagnostic and formed a recovery
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 12949) // lookup result.
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12950) assert(!R.empty() && "lookup results empty despite recovery");
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12951)
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 12952) // If recovery created an ambiguity, just bail out.
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 12953) if (R.isAmbiguous()) {
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 12954) R.suppressDiagnostics();
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 12955) return ExprError();
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 12956) }
+151c4568581f1 (Richard Smith 2016-12-20 21:35:28 +0000 12957)
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12958) // Build an implicit member call if appropriate. Just drop the
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12959) // casts and such from the call, we don't really care.
+faf5fb4b78c79 (John McCall 2010-08-26 23:41:50 +0000 12960) ExprResult NewFn = ExprError();
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12961) if ((*R.begin())->isCXXClassMember())
+6924dcdf6f737 (Aaron Ballman 2015-09-01 14:49:24 +0000 12962) NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, TemplateKWLoc, R,
+6924dcdf6f737 (Aaron Ballman 2015-09-01 14:49:24 +0000 12963) ExplicitTemplateArgs, S);
+65f7c3dba22f0 (Abramo Bagnara 2012-02-06 14:31:00 +0000 12964) else if (ExplicitTemplateArgs || TemplateKWLoc.isValid())
+7945c981b974f (Abramo Bagnara 2012-01-27 09:46:47 +0000 12965) NewFn = SemaRef.BuildTemplateIdExpr(SS, TemplateKWLoc, R, false,
+65f7c3dba22f0 (Abramo Bagnara 2012-02-06 14:31:00 +0000 12966) ExplicitTemplateArgs);
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12967) else
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12968) NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false);
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12969)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12970) if (NewFn.isInvalid())
+faf5fb4b78c79 (John McCall 2010-08-26 23:41:50 +0000 12971) return ExprError();
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12972)
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12973) // This shouldn't cause an infinite loop because we're giving it
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12974) // an expression with viable lookup results, which should never
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12975) // end up here.
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12976) return SemaRef.BuildCallExpr(/*Scope*/ nullptr, NewFn.get(), LParenLoc,
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12977) MultiExprArg(Args.data(), Args.size()),
+d972d4c749048 (Haojian Wu 2021-01-22 12:15:05 +0100 12978) RParenLoc);
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 12979) }
+4038cf4b57da3 (Douglas Gregor 2010-06-08 17:35:15 +0000 12980)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 12981) /// Constructs and populates an OverloadedCandidateSet from
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12982) /// the given function.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12983) /// \returns true when an the ExprResult output parameter has been set.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12984) bool Sema::buildOverloadedCallSet(Scope *S, Expr *Fn,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12985) UnresolvedLookupExpr *ULE,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 12986) MultiExprArg Args,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12987) SourceLocation RParenLoc,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12988) OverloadCandidateSet *CandidateSet,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 12989) ExprResult *Result) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12990) #ifndef NDEBUG
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12991) if (ULE->requiresADL()) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12992) // To do ADL, we must have found an unqualified name.
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12993) assert(!ULE->getQualifier() && "qualified name with ADL");
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12994)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12995) // We don't perform ADL for implicit declarations of builtins.
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12996) // Verify that this was correctly set up.
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 12997) FunctionDecl *F;
+b23c5e8c3df85 (Richard Smith 2019-05-09 03:31:27 +0000 12998) if (ULE->decls_begin() != ULE->decls_end() &&
+b23c5e8c3df85 (Richard Smith 2019-05-09 03:31:27 +0000 12999) ULE->decls_begin() + 1 == ULE->decls_end() &&
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13000) (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) &&
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13001) F->getBuiltinID() && F->isImplicit())
+83d382b1cad13 (David Blaikie 2011-09-23 05:06:16 +0000 13002) llvm_unreachable("performing ADL for builtin");
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13003)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13004) // We don't perform ADL in C.
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 13005) assert(getLangOpts().CPlusPlus && "ADL enabled in C");
+b6626748c2e50 (Richard Smith 2012-10-18 17:56:02 +0000 13006) }
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13007) #endif
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13008)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13009) UnbridgedCastsSet UnbridgedCasts;
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13010) if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts)) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13011) *Result = ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13012) return true;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13013) }
+e254f90d94e32 (Douglas Gregor 2009-02-04 00:32:51 +0000 13014)
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13015) // Add the functions denoted by the callee to the set of candidate
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13016) // functions, including those from argument-dependent lookup.
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13017) AddOverloadedCallCandidates(ULE, Args, *CandidateSet);
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 13018)
+b274738725f2e (Hans Wennborg 2015-06-12 21:23:23 +0000 13019) if (getLangOpts().MSVCCompat &&
+b274738725f2e (Hans Wennborg 2015-06-12 21:23:23 +0000 13020) CurContext->isDependentContext() && !isSFINAEContext() &&
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13021) (isa<FunctionDecl>(CurContext) || isa<CXXRecordDecl>(CurContext))) {
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13022)
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13023) OverloadCandidateSet::iterator Best;
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13024) if (CandidateSet->empty() ||
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 13025) CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best) ==
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13026) OR_No_Viable_Function) {
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13027) // In Microsoft mode, if we are inside a template class member function
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13028) // then create a type dependent CallExpr. The goal is to postpone name
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13029) // lookup to instantiation time to be able to search into type dependent
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13030) // base classes.
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 13031) CallExpr *CE =
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 13032) CallExpr::Create(Context, Fn, Args, Context.DependentTy, VK_RValue,
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 13033) RParenLoc, CurFPFeatureOverrides());
+b4f02d89e5d8d (Sam McCall 2020-03-18 23:38:08 +0100 13034) CE->markDependentForPostponedNameLookup();
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 13035) *Result = CE;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13036) return true;
+b49c46c25cdc6 (Sebastian Redl 2011-09-24 17:48:00 +0000 13037) }
+bcf6471010a1c (Francois Pichet 2011-09-07 00:14:57 +0000 13038) }
+d681c3959f85b (John McCall 2009-12-16 08:11:27 +0000 13039)
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13040) if (CandidateSet->empty())
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13041) return false;
+64937c6f97fc4 (Hans Wennborg 2015-06-11 21:21:57 +0000 13042)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13043) UnbridgedCasts.restore();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13044) return false;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13045) }
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13046)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13047) // Guess at what the return type for an unresolvable overload should be.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13048) static QualType chooseRecoveryType(OverloadCandidateSet &CS,
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13049) OverloadCandidateSet::iterator *Best) {
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13050) llvm::Optional<QualType> Result;
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13051) // Adjust Type after seeing a candidate.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13052) auto ConsiderCandidate = [&](const OverloadCandidate &Candidate) {
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13053) if (!Candidate.Function)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13054) return;
+031738a561184 (Haojian Wu 2020-08-11 13:49:11 +0200 13055) if (Candidate.Function->isInvalidDecl())
+031738a561184 (Haojian Wu 2020-08-11 13:49:11 +0200 13056) return;
+96a5cfff208d8 (Haojian Wu 2020-07-08 13:53:47 +0200 13057) QualType T = Candidate.Function->getReturnType();
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13058) if (T.isNull())
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13059) return;
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13060) if (!Result)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13061) Result = T;
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13062) else if (Result != T)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13063) Result = QualType();
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13064) };
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13065)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13066) // Look for an unambiguous type from a progressively larger subset.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13067) // e.g. if types disagree, but all *viable* overloads return int, choose int.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13068) //
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13069) // First, consider only the best candidate.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13070) if (Best && *Best != CS.end())
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13071) ConsiderCandidate(**Best);
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13072) // Next, consider only viable candidates.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13073) if (!Result)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13074) for (const auto &C : CS)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13075) if (C.Viable)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13076) ConsiderCandidate(C);
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13077) // Finally, consider all candidates.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13078) if (!Result)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13079) for (const auto &C : CS)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13080) ConsiderCandidate(C);
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13081)
+7f05fe1aeeb00 (Haojian Wu 2020-10-05 12:52:03 +0200 13082) if (!Result)
+7f05fe1aeeb00 (Haojian Wu 2020-10-05 12:52:03 +0200 13083) return QualType();
+7f05fe1aeeb00 (Haojian Wu 2020-10-05 12:52:03 +0200 13084) auto Value = Result.getValue();
+7f05fe1aeeb00 (Haojian Wu 2020-10-05 12:52:03 +0200 13085) if (Value.isNull() || Value->isUndeducedType())
+7f05fe1aeeb00 (Haojian Wu 2020-10-05 12:52:03 +0200 13086) return QualType();
+7f05fe1aeeb00 (Haojian Wu 2020-10-05 12:52:03 +0200 13087) return Value;
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13088) }
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13089)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13090) /// FinishOverloadedCallExpr - given an OverloadCandidateSet, builds and returns
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13091) /// the completed call expression. If overload resolution fails, emits
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13092) /// diagnostics and returns ExprError()
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13093) static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13094) UnresolvedLookupExpr *ULE,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13095) SourceLocation LParenLoc,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13096) MultiExprArg Args,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13097) SourceLocation RParenLoc,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13098) Expr *ExecConfig,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13099) OverloadCandidateSet *CandidateSet,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13100) OverloadCandidateSet::iterator *Best,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13101) OverloadingResult OverloadResult,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13102) bool AllowTypoCorrection) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13103) switch (OverloadResult) {
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13104) case OR_Success: {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13105) FunctionDecl *FDecl = (*Best)->Function;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13106) SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 13107) if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 13108) return ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13109) Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13110) return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 13111) ExecConfig, /*IsExecConfig=*/false,
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 13112) (*Best)->IsADLCandidate);
+5750077300414 (John McCall 2009-12-16 12:17:52 +0000 13113) }
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13114)
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13115) case OR_No_Viable_Function: {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13116) // Try to recover by looking for viable functions which the user might
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13117) // have meant to call.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13118) ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13119) Args, RParenLoc,
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 13120) CandidateSet->empty(),
+9afaf793b36dc (Kaelyn Uhrain 2012-01-25 21:11:35 +0000 13121) AllowTypoCorrection);
+c4fb7720ceb30 (Richard Smith 2020-12-02 17:46:28 -0800 13122) if (Recovery.isInvalid() || Recovery.isUsable())
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13123) return Recovery;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13124)
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13125) // If the user passes in a function that we can't take the address of, we
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13126) // generally end up emitting really bad error messages. Here, we attempt to
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13127) // emit better ones.
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13128) for (const Expr *Arg : Args) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13129) if (!Arg->getType()->isFunctionType())
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13130) continue;
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13131) if (auto *DRE = dyn_cast<DeclRefExpr>(Arg->IgnoreParenImpCasts())) {
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13132) auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl());
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13133) if (FD &&
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13134) !SemaRef.checkAddressOfFunctionIsAvailable(FD, /*Complain=*/true,
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13135) Arg->getExprLoc()))
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13136) return ExprError();
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13137) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13138) }
+3e3bb95b6951c (George Burgess IV 2015-12-02 21:58:08 +0000 13139)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13140) CandidateSet->NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13141) PartialDiagnosticAt(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13142) Fn->getBeginLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13143) SemaRef.PDiag(diag::err_ovl_no_viable_function_in_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13144) << ULE->getName() << Fn->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13145) SemaRef, OCD_AllCandidates, Args);
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13146) break;
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13147) }
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13148)
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13149) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13150) CandidateSet->NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13151) PartialDiagnosticAt(Fn->getBeginLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13152) SemaRef.PDiag(diag::err_ovl_ambiguous_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13153) << ULE->getName() << Fn->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 13154) SemaRef, OCD_AmbiguousCandidates, Args);
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13155) break;
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 13156)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13157) case OR_Deleted: {
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13158) CandidateSet->NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13159) PartialDiagnosticAt(Fn->getBeginLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13160) SemaRef.PDiag(diag::err_ovl_deleted_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13161) << ULE->getName() << Fn->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13162) SemaRef, OCD_AllCandidates, Args);
+3eaa22af57876 (Argyrios Kyrtzidis 2011-11-04 15:58:13 +0000 13163)
+2a8c18d991188 (Alexander Kornienko 2018-04-06 15:14:32 +0000 13164) // We emitted an error for the unavailable/deleted function call but keep
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13165) // the call in the AST.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13166) FunctionDecl *FDecl = (*Best)->Function;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13167) Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13168) return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 13169) ExecConfig, /*IsExecConfig=*/false,
+5cdc2cda28ac8 (Eric Fiselier 2018-12-12 21:50:55 +0000 13170) (*Best)->IsADLCandidate);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13171) }
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13172) }
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13173)
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13174) // Overload resolution failed, try to recover.
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13175) SmallVector<Expr *, 8> SubExprs = {Fn};
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13176) SubExprs.append(Args.begin(), Args.end());
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13177) return SemaRef.CreateRecoveryExpr(Fn->getBeginLoc(), RParenLoc, SubExprs,
+8222107aa9249 (Haojian Wu 2020-05-08 16:13:17 +0200 13178) chooseRecoveryType(*CandidateSet, Best));
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13179) }
+99dcbff1542f3 (Douglas Gregor 2008-11-26 05:54:23 +0000 13180)
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13181) static void markUnaddressableCandidatesUnviable(Sema &S,
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13182) OverloadCandidateSet &CS) {
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13183) for (auto I = CS.begin(), E = CS.end(); I != E; ++I) {
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13184) if (I->Viable &&
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13185) !S.checkAddressOfFunctionIsAvailable(I->Function, /*Complain=*/false)) {
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13186) I->Viable = false;
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13187) I->FailureKind = ovl_fail_addr_not_available;
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13188) }
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13189) }
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13190) }
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13191)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13192) /// BuildOverloadedCallExpr - Given the call expression that calls Fn
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13193) /// (which eventually refers to the declaration Func) and the call
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13194) /// arguments Args/NumArgs, attempt to resolve the function call down
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13195) /// to a specific function. If overload resolution succeeds, returns
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13196) /// the call expression produced by overload resolution.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13197) /// Otherwise, emits diagnostics and returns ExprError.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13198) ExprResult Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13199) UnresolvedLookupExpr *ULE,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13200) SourceLocation LParenLoc,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13201) MultiExprArg Args,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13202) SourceLocation RParenLoc,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13203) Expr *ExecConfig,
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13204) bool AllowTypoCorrection,
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13205) bool CalleesAddressIsTaken) {
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 13206) OverloadCandidateSet CandidateSet(Fn->getExprLoc(),
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 13207) OverloadCandidateSet::CSK_Normal);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13208) ExprResult result;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13209)
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13210) if (buildOverloadedCallSet(S, Fn, ULE, Args, LParenLoc, &CandidateSet,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 13211) &result))
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13212) return result;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13213)
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13214) // If the user handed us something like `(&Foo)(Bar)`, we need to ensure that
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13215) // functions that aren't addressible are considered unviable.
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13216) if (CalleesAddressIsTaken)
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13217) markUnaddressableCandidatesUnviable(*this, CandidateSet);
+7204ed97dd930 (George Burgess IV 2016-01-07 02:26:57 +0000 13218)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13219) OverloadCandidateSet::iterator Best;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13220) OverloadingResult OverloadResult =
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 13221) CandidateSet.BestViableFunction(*this, Fn->getBeginLoc(), Best);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13222)
+b23c5e8c3df85 (Richard Smith 2019-05-09 03:31:27 +0000 13223) return FinishOverloadedCallExpr(*this, S, Fn, ULE, LParenLoc, Args, RParenLoc,
+b23c5e8c3df85 (Richard Smith 2019-05-09 03:31:27 +0000 13224) ExecConfig, &CandidateSet, &Best,
+b23c5e8c3df85 (Richard Smith 2019-05-09 03:31:27 +0000 13225) OverloadResult, AllowTypoCorrection);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13226) }
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 13227)
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13228) static bool IsOverloaded(const UnresolvedSetImpl &Functions) {
+283b901cf3542 (John McCall 2009-11-22 00:44:51 +0000 13229) return Functions.size() > 1 ||
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13230) (Functions.size() == 1 &&
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13231) isa<FunctionTemplateDecl>((*Functions.begin())->getUnderlyingDecl()));
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13232) }
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13233)
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13234) ExprResult Sema::CreateUnresolvedLookupExpr(CXXRecordDecl *NamingClass,
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13235) NestedNameSpecifierLoc NNSLoc,
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13236) DeclarationNameInfo DNI,
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13237) const UnresolvedSetImpl &Fns,
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13238) bool PerformADL) {
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13239) return UnresolvedLookupExpr::Create(Context, NamingClass, NNSLoc, DNI,
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13240) PerformADL, IsOverloaded(Fns),
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13241) Fns.begin(), Fns.end());
+283b901cf3542 (John McCall 2009-11-22 00:44:51 +0000 13242) }
+283b901cf3542 (John McCall 2009-11-22 00:44:51 +0000 13243)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 13244) /// Create a unary operation that may resolve to an overloaded
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13245) /// operator.
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13246) ///
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13247) /// \param OpLoc The location of the operator itself (e.g., '*').
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13248) ///
+a92ffb011eef7 (Craig Topper 2015-12-10 08:51:49 +0000 13249) /// \param Opc The UnaryOperatorKind that describes this operator.
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13250) ///
+18348b6218e4c (James Dennett 2012-06-22 08:52:37 +0000 13251) /// \param Fns The set of non-member functions that will be
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13252) /// considered by overload resolution. The caller needs to build this
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13253) /// set based on the context using, e.g.,
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13254) /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13255) /// set should not contain any member functions; those will be added
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13256) /// by CreateOverloadedUnaryOp().
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13257) ///
+91738ffda3fa5 (James Dennett 2012-06-22 10:32:46 +0000 13258) /// \param Input The input argument.
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 13259) ExprResult
+a92ffb011eef7 (Craig Topper 2015-12-10 08:51:49 +0000 13260) Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, UnaryOperatorKind Opc,
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13261) const UnresolvedSetImpl &Fns,
+91fc7d89d0d5a (Richard Smith 2017-10-05 19:35:51 +0000 13262) Expr *Input, bool PerformADL) {
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13263) OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13264) assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13265) DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 13266) // TODO: provide better source location info.
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 13267) DeclarationNameInfo OpNameInfo(OpName, OpLoc);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13268)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13269) if (checkPlaceholderForOverload(*this, Input))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13270) return ExprError();
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13271)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13272) Expr *Args[2] = { Input, nullptr };
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13273) unsigned NumArgs = 1;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 13274)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13275) // For post-increment and post-decrement, add the implicit '0' as
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13276) // the second argument, so that we know this is a post-increment or
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13277) // post-decrement.
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 13278) if (Opc == UO_PostInc || Opc == UO_PostDec) {
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13279) llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
+43b205796f4ab (Argyrios Kyrtzidis 2010-08-28 09:06:06 +0000 13280) Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy,
+43b205796f4ab (Argyrios Kyrtzidis 2010-08-28 09:06:06 +0000 13281) SourceLocation());
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13282) NumArgs = 2;
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13283) }
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13284)
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 13285) ArrayRef<Expr *> ArgsArray(Args, NumArgs);
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 13286)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13287) if (Input->isTypeDependent()) {
+630dec57a2af3 (Douglas Gregor 2010-06-17 15:46:20 +0000 13288) if (Fns.empty())
+f5360d4bb3376 (Melanie Blower 2020-05-01 10:32:06 -0700 13289) return UnaryOperator::Create(Context, Input, Opc, Context.DependentTy,
+f5360d4bb3376 (Melanie Blower 2020-05-01 10:32:06 -0700 13290) VK_RValue, OK_Ordinary, OpLoc, false,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 13291) CurFPFeatureOverrides());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13292)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13293) CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13294) ExprResult Fn = CreateUnresolvedLookupExpr(
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13295) NamingClass, NestedNameSpecifierLoc(), OpNameInfo, Fns);
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13296) if (Fn.isInvalid())
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13297) return ExprError();
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13298) return CXXOperatorCallExpr::Create(Context, Op, Fn.get(), ArgsArray,
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13299) Context.DependentTy, VK_RValue, OpLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 13300) CurFPFeatureOverrides());
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13301) }
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13302)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13303) // Build an empty overload set.
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 13304) OverloadCandidateSet CandidateSet(OpLoc, OverloadCandidateSet::CSK_Operator);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13305)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13306) // Add the candidates from the given function set.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13307) AddNonMemberOperatorCandidates(Fns, ArgsArray, CandidateSet);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13308)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13309) // Add operator candidates that are member functions.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 13310) AddMemberOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13311)
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13312) // Add candidates from ADL.
+91fc7d89d0d5a (Richard Smith 2017-10-05 19:35:51 +0000 13313) if (PerformADL) {
+91fc7d89d0d5a (Richard Smith 2017-10-05 19:35:51 +0000 13314) AddArgumentDependentLookupCandidates(OpName, OpLoc, ArgsArray,
+91fc7d89d0d5a (Richard Smith 2017-10-05 19:35:51 +0000 13315) /*ExplicitTemplateArgs*/nullptr,
+91fc7d89d0d5a (Richard Smith 2017-10-05 19:35:51 +0000 13316) CandidateSet);
+91fc7d89d0d5a (Richard Smith 2017-10-05 19:35:51 +0000 13317) }
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13318)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13319) // Add builtin operator candidates.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 13320) AddBuiltinOperatorCandidates(Op, OpLoc, ArgsArray, CandidateSet);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13321)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 13322) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 13323)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13324) // Perform overload resolution.
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13325) OverloadCandidateSet::iterator Best;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 13326) switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13327) case OR_Success: {
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13328) // We found a built-in operator or an overloaded operator.
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13329) FunctionDecl *FnDecl = Best->Function;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 13330)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13331) if (FnDecl) {
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13332) Expr *Base = nullptr;
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13333) // We matched an overloaded operator. Build a call to that
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13334) // operator.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 13335)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13336) // Convert the arguments.
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13337) if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13338) CheckMemberOperatorAccess(OpLoc, Args[0], nullptr, Best->FoundDecl);
+b3a4400554925 (John McCall 2010-01-28 01:42:12 +0000 13339)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13340) ExprResult InputRes =
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13341) PerformObjectArgumentInitialization(Input, /*Qualifier=*/nullptr,
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13342) Best->FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13343) if (InputRes.isInvalid())
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13344) return ExprError();
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13345) Base = Input = InputRes.get();
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13346) } else {
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13347) // Convert the arguments.
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 13348) ExprResult InputInit
+e6600379b1c6f (Douglas Gregor 2009-12-23 17:40:29 +0000 13349) = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+8fb87aec78b52 (Fariborz Jahanian 2010-09-24 17:30:16 +0000 13350) Context,
+8d48e9a26e5e2 (Douglas Gregor 2009-12-23 00:02:00 +0000 13351) FnDecl->getParamDecl(0)),
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13352) SourceLocation(),
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 13353) Input);
+e6600379b1c6f (Douglas Gregor 2009-12-23 17:40:29 +0000 13354) if (InputInit.isInvalid())
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13355) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13356) Input = InputInit.get();
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13357) }
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13358)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13359) // Build the actual expression node.
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 13360) ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl, Best->FoundDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13361) Base, HadMultipleCandidates,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13362) OpLoc);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13363) if (FnExpr.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13364) return ExprError();
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 13365)
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13366) // Determine the result type.
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 13367) QualType ResultTy = FnDecl->getReturnType();
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13368) ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13369) ResultTy = ResultTy.getNonLValueExprType(Context);
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13370)
+030eee4e5c369 (Eli Friedman 2009-11-18 03:58:17 +0000 13371) Args[0] = Input;
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13372) CallExpr *TheCall = CXXOperatorCallExpr::Create(
+8812b0cc5cc09 (Melanie Blower 2020-04-16 08:45:26 -0700 13373) Context, Op, FnExpr.get(), ArgsArray, ResultTy, VK, OpLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 13374) CurFPFeatureOverrides(), Best->IsADLCandidate);
+4fa0d5f2bd849 (John McCall 2010-05-06 18:15:07 +0000 13375)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 13376) if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall, FnDecl))
+f64a3dae047f5 (Anders Carlsson 2009-10-13 21:19:37 +0000 13377) return ExprError();
+f64a3dae047f5 (Anders Carlsson 2009-10-13 21:19:37 +0000 13378)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13379) if (CheckFunctionCall(FnDecl, TheCall,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13380) FnDecl->getType()->castAs<FunctionProtoType>()))
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13381) return ExprError();
+008e7bf92343b (Tyker 2020-02-04 19:23:33 +0100 13382) return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), FnDecl);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13383) } else {
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13384) // We matched a built-in operator. Convert the arguments, then
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13385) // break out so that we will build the appropriate built-in
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13386) // operator node.
+5f6ab9a8bf307 (George Burgess IV 2017-06-08 20:55:21 +0000 13387) ExprResult InputRes = PerformImplicitConversion(
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13388) Input, Best->BuiltinParamTypes[0], Best->Conversions[0], AA_Passing,
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13389) CCK_ForBuiltinOverloadedOp);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13390) if (InputRes.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13391) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13392) Input = InputRes.get();
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13393) break;
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13394) }
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13395) }
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13396)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13397) case OR_No_Viable_Function:
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13398) // This is an erroneous use of an operator which can be overloaded by
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13399) // a non-member function. Check for non-member operators which were
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13400) // defined too late to be candidates.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 13401) if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, ArgsArray))
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13402) // FIXME: Recover by calling the found function.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13403) return ExprError();
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13404)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13405) // No viable function; fall through to handling this as a
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13406) // built-in operator, which will produce an error message for us.
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13407) break;
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13408)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13409) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13410) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13411) PartialDiagnosticAt(OpLoc,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13412) PDiag(diag::err_ovl_ambiguous_oper_unary)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13413) << UnaryOperator::getOpcodeStr(Opc)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13414) << Input->getType() << Input->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 13415) *this, OCD_AmbiguousCandidates, ArgsArray,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13416) UnaryOperator::getOpcodeStr(Opc), OpLoc);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13417) return ExprError();
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13418)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13419) case OR_Deleted:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13420) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13421) PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13422) << UnaryOperator::getOpcodeStr(Opc)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13423) << Input->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13424) *this, OCD_AllCandidates, ArgsArray, UnaryOperator::getOpcodeStr(Opc),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13425) OpLoc);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13426) return ExprError();
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13427) }
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13428)
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13429) // Either we found no viable overloaded operator or we matched a
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13430) // built-in operator. In either case, fall through to trying to
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13431) // build a built-in operation.
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 13432) return CreateBuiltinUnaryOp(OpLoc, Opc, Input);
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13433) }
+084d855a17f27 (Douglas Gregor 2009-03-13 23:49:33 +0000 13434)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13435) /// Perform lookup for an overloaded binary operator.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13436) void Sema::LookupOverloadedBinOp(OverloadCandidateSet &CandidateSet,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13437) OverloadedOperatorKind Op,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13438) const UnresolvedSetImpl &Fns,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13439) ArrayRef<Expr *> Args, bool PerformADL) {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13440) SourceLocation OpLoc = CandidateSet.getLocation();
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13441)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13442) OverloadedOperatorKind ExtraOp =
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13443) CandidateSet.getRewriteInfo().AllowRewrittenCandidates
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13444) ? getRewrittenOverloadedOperator(Op)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13445) : OO_None;
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13446)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13447) // Add the candidates from the given function set. This also adds the
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13448) // rewritten candidates using these functions if necessary.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13449) AddNonMemberOperatorCandidates(Fns, Args, CandidateSet);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13450)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13451) // Add operator candidates that are member functions.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13452) AddMemberOperatorCandidates(Op, OpLoc, Args, CandidateSet);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13453) if (CandidateSet.getRewriteInfo().shouldAddReversed(Op))
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13454) AddMemberOperatorCandidates(Op, OpLoc, {Args[1], Args[0]}, CandidateSet,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13455) OverloadCandidateParamOrder::Reversed);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13456)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13457) // In C++20, also add any rewritten member candidates.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13458) if (ExtraOp) {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13459) AddMemberOperatorCandidates(ExtraOp, OpLoc, Args, CandidateSet);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13460) if (CandidateSet.getRewriteInfo().shouldAddReversed(ExtraOp))
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13461) AddMemberOperatorCandidates(ExtraOp, OpLoc, {Args[1], Args[0]},
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13462) CandidateSet,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13463) OverloadCandidateParamOrder::Reversed);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13464) }
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13465)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13466) // Add candidates from ADL. Per [over.match.oper]p2, this lookup is not
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13467) // performed for an assignment operator (nor for operator[] nor operator->,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13468) // which don't get here).
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13469) if (Op != OO_Equal && PerformADL) {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13470) DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13471) AddArgumentDependentLookupCandidates(OpName, OpLoc, Args,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13472) /*ExplicitTemplateArgs*/ nullptr,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13473) CandidateSet);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13474) if (ExtraOp) {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13475) DeclarationName ExtraOpName =
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13476) Context.DeclarationNames.getCXXOperatorName(ExtraOp);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13477) AddArgumentDependentLookupCandidates(ExtraOpName, OpLoc, Args,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13478) /*ExplicitTemplateArgs*/ nullptr,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13479) CandidateSet);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13480) }
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13481) }
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13482)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13483) // Add builtin operator candidates.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13484) //
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13485) // FIXME: We don't add any rewritten candidates here. This is strictly
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13486) // incorrect; a builtin candidate could be hidden by a non-viable candidate,
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13487) // resulting in our selecting a rewritten builtin candidate. For example:
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13488) //
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13489) // enum class E { e };
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13490) // bool operator!=(E, E) requires false;
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13491) // bool k = E::e != E::e;
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13492) //
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13493) // ... should select the rewritten builtin candidate 'operator==(E, E)'. But
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13494) // it seems unreasonable to consider rewritten builtin candidates. A core
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13495) // issue has been filed proposing to removed this requirement.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13496) AddBuiltinOperatorCandidates(Op, OpLoc, Args, CandidateSet);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13497) }
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13498)
+9fc8faf9e6197 (Adrian Prantl 2018-05-09 01:00:01 +0000 13499) /// Create a binary operation that may resolve to an overloaded
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13500) /// operator.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13501) ///
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13502) /// \param OpLoc The location of the operator itself (e.g., '+').
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13503) ///
+a92ffb011eef7 (Craig Topper 2015-12-10 08:51:49 +0000 13504) /// \param Opc The BinaryOperatorKind that describes this operator.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13505) ///
+18348b6218e4c (James Dennett 2012-06-22 08:52:37 +0000 13506) /// \param Fns The set of non-member functions that will be
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13507) /// considered by overload resolution. The caller needs to build this
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13508) /// set based on the context using, e.g.,
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13509) /// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13510) /// set should not contain any member functions; those will be added
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13511) /// by CreateOverloadedBinOp().
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13512) ///
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13513) /// \param LHS Left-hand argument.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13514) /// \param RHS Right-hand argument.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13515) /// \param PerformADL Whether to consider operator candidates found by ADL.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13516) /// \param AllowRewrittenCandidates Whether to consider candidates found by
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13517) /// C++20 operator rewrites.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13518) /// \param DefaultedFn If we are synthesizing a defaulted operator function,
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13519) /// the function in question. Such a function is never a candidate in
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13520) /// our overload resolution. This also enables synthesizing a three-way
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13521) /// comparison from < and == as described in C++20 [class.spaceship]p1.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13522) ExprResult Sema::CreateOverloadedBinOp(SourceLocation OpLoc,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13523) BinaryOperatorKind Opc,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13524) const UnresolvedSetImpl &Fns, Expr *LHS,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13525) Expr *RHS, bool PerformADL,
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13526) bool AllowRewrittenCandidates,
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13527) FunctionDecl *DefaultedFn) {
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13528) Expr *Args[2] = { LHS, RHS };
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13529) LHS=RHS=nullptr; // Please use only Args instead of LHS/RHS couple
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13530)
+6a30894391ca6 (Aaron Ballman 2020-04-21 15:37:19 -0400 13531) if (!getLangOpts().CPlusPlus20)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13532) AllowRewrittenCandidates = false;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13533)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13534) OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc);
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13535)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13536) // If either side is type-dependent, create an appropriate dependent
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13537) // expression.
+e9899d9769661 (Douglas Gregor 2009-08-26 17:08:25 +0000 13538) if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13539) if (Fns.empty()) {
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13540) // If there are no functions to store, just build a dependent
+5287f091b269e (Douglas Gregor 2009-11-05 00:51:44 +0000 13541) // BinaryOperator or CompoundAssignment.
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13542) if (BinaryOperator::isCompoundAssignmentOp(Opc))
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13543) return CompoundAssignOperator::Create(
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13544) Context, Args[0], Args[1], Opc, Context.DependentTy, VK_LValue,
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13545) OK_Ordinary, OpLoc, CurFPFeatureOverrides(), Context.DependentTy,
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13546) Context.DependentTy);
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13547) return BinaryOperator::Create(Context, Args[0], Args[1], Opc,
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13548) Context.DependentTy, VK_RValue, OK_Ordinary,
+31dc90801746e (Haojian Wu 2020-10-07 09:50:43 +0200 13549) OpLoc, CurFPFeatureOverrides());
+5287f091b269e (Douglas Gregor 2009-11-05 00:51:44 +0000 13550) }
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13551)
+4c4c1dfc2b768 (John McCall 2010-01-26 03:27:55 +0000 13552) // FIXME: save results of ADL from here?
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13553) CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 13554) // TODO: provide better source location info in DNLoc component.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13555) DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op);
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 13556) DeclarationNameInfo OpNameInfo(OpName, OpLoc);
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13557) ExprResult Fn = CreateUnresolvedLookupExpr(
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13558) NamingClass, NestedNameSpecifierLoc(), OpNameInfo, Fns, PerformADL);
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13559) if (Fn.isInvalid())
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13560) return ExprError();
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 13561) return CXXOperatorCallExpr::Create(Context, Op, Fn.get(), Args,
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13562) Context.DependentTy, VK_RValue, OpLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 13563) CurFPFeatureOverrides());
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13564) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13565)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13566) // Always do placeholder-like conversions on the RHS.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13567) if (checkPlaceholderForOverload(*this, Args[1]))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13568) return ExprError();
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13569)
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 13570) // Do placeholder-like conversion on the LHS; note that we should
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 13571) // not get here with a PseudoObject LHS.
+526ab47a55734 (John McCall 2011-10-25 17:37:35 +0000 13572) assert(Args[0]->getObjectKind() != OK_ObjCProperty);
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13573) if (checkPlaceholderForOverload(*this, Args[0]))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13574) return ExprError();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 13575)
+6a96bf7d6e33d (Sebastian Redl 2009-11-18 23:10:33 +0000 13576) // If this is the assignment operator, we only perform overload resolution
+6a96bf7d6e33d (Sebastian Redl 2009-11-18 23:10:33 +0000 13577) // if the left-hand side is a class or enumeration type. This is actually
+6a96bf7d6e33d (Sebastian Redl 2009-11-18 23:10:33 +0000 13578) // a hack. The standard requires that we do overload resolution between the
+6a96bf7d6e33d (Sebastian Redl 2009-11-18 23:10:33 +0000 13579) // various built-in candidates, but as DR507 points out, this can lead to
+6a96bf7d6e33d (Sebastian Redl 2009-11-18 23:10:33 +0000 13580) // problems. So we do it this way, which pretty much follows what GCC does.
+6a96bf7d6e33d (Sebastian Redl 2009-11-18 23:10:33 +0000 13581) // Note that we go the traditional code path for compound assignment forms.
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 13582) if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType())
+e9899d9769661 (Douglas Gregor 2009-08-26 17:08:25 +0000 13583) return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13584)
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13585) // If this is the .* operator, which is not overloadable, just
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13586) // create a built-in binary operator.
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13587) if (Opc == BO_PtrMemD)
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13588) return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 13589)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13590) // Build the overload set.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13591) OverloadCandidateSet CandidateSet(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13592) OpLoc, OverloadCandidateSet::CSK_Operator,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13593) OverloadCandidateSet::OperatorRewriteInfo(Op, AllowRewrittenCandidates));
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13594) if (DefaultedFn)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13595) CandidateSet.exclude(DefaultedFn);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13596) LookupOverloadedBinOp(CandidateSet, Op, Fns, Args, PerformADL);
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13597)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 13598) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 13599)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13600) // Perform overload resolution.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13601) OverloadCandidateSet::iterator Best;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 13602) switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
+1a99f441e64c8 (Sebastian Redl 2009-04-16 17:51:27 +0000 13603) case OR_Success: {
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13604) // We found a built-in operator or an overloaded operator.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13605) FunctionDecl *FnDecl = Best->Function;
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13606)
+fcea7fbdba1bd (Richard Smith 2020-02-10 06:05:59 -0800 13607) bool IsReversed = Best->isReversed();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13608) if (IsReversed)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13609) std::swap(Args[0], Args[1]);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13610)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13611) if (FnDecl) {
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13612) Expr *Base = nullptr;
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13613) // We matched an overloaded operator. Build a call to that
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13614) // operator.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13615)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13616) OverloadedOperatorKind ChosenOp =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13617) FnDecl->getDeclName().getCXXOverloadedOperator();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13618)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13619) // C++2a [over.match.oper]p9:
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13620) // If a rewritten operator== candidate is selected by overload
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13621) // resolution for an operator@, its return type shall be cv bool
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13622) if (Best->RewriteKind && ChosenOp == OO_EqualEqual &&
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13623) !FnDecl->getReturnType()->isBooleanType()) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13624) bool IsExtension =
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13625) FnDecl->getReturnType()->isIntegralOrUnscopedEnumerationType();
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13626) Diag(OpLoc, IsExtension ? diag::ext_ovl_rewrite_equalequal_not_bool
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13627) : diag::err_ovl_rewrite_equalequal_not_bool)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13628) << FnDecl->getReturnType() << BinaryOperator::getOpcodeStr(Opc)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13629) << Args[0]->getSourceRange() << Args[1]->getSourceRange();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13630) Diag(FnDecl->getLocation(), diag::note_declared_at);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13631) if (!IsExtension)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13632) return ExprError();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13633) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13634)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13635) if (AllowRewrittenCandidates && !IsReversed &&
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13636) CandidateSet.getRewriteInfo().isReversible()) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13637) // We could have reversed this operator, but didn't. Check if some
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13638) // reversed form was a viable candidate, and if so, if it had a
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13639) // better conversion for either parameter. If so, this call is
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13640) // formally ambiguous, and allowing it is an extension.
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13641) llvm::SmallVector<FunctionDecl*, 4> AmbiguousWith;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13642) for (OverloadCandidate &Cand : CandidateSet) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13643) if (Cand.Viable && Cand.Function && Cand.isReversed() &&
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13644) haveSameParameterTypes(Context, Cand.Function, FnDecl, 2)) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13645) for (unsigned ArgIdx = 0; ArgIdx < 2; ++ArgIdx) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13646) if (CompareImplicitConversionSequences(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13647) *this, OpLoc, Cand.Conversions[ArgIdx],
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13648) Best->Conversions[ArgIdx]) ==
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13649) ImplicitConversionSequence::Better) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13650) AmbiguousWith.push_back(Cand.Function);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13651) break;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13652) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13653) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13654) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13655) }
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13656)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13657) if (!AmbiguousWith.empty()) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13658) bool AmbiguousWithSelf =
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13659) AmbiguousWith.size() == 1 &&
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13660) declaresSameEntity(AmbiguousWith.front(), FnDecl);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13661) Diag(OpLoc, diag::ext_ovl_ambiguous_oper_binary_reversed)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13662) << BinaryOperator::getOpcodeStr(Opc)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13663) << Args[0]->getType() << Args[1]->getType() << AmbiguousWithSelf
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13664) << Args[0]->getSourceRange() << Args[1]->getSourceRange();
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13665) if (AmbiguousWithSelf) {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13666) Diag(FnDecl->getLocation(),
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13667) diag::note_ovl_ambiguous_oper_binary_reversed_self);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13668) } else {
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13669) Diag(FnDecl->getLocation(),
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13670) diag::note_ovl_ambiguous_oper_binary_selected_candidate);
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13671) for (auto *F : AmbiguousWith)
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13672) Diag(F->getLocation(),
+dc4259d5a3840 (Richard Smith 2020-03-20 13:19:26 -0700 13673) diag::note_ovl_ambiguous_oper_binary_reversed_candidate);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13674) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13675) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13676) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13677)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13678) // Convert the arguments.
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13679) if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) {
+b3a4400554925 (John McCall 2010-01-28 01:42:12 +0000 13680) // Best->Access is only meaningful for class members.
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 13681) CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl);
+b3a4400554925 (John McCall 2010-01-28 01:42:12 +0000 13682)
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13683) ExprResult Arg1 =
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13684) PerformCopyInitialization(
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13685) InitializedEntity::InitializeParameter(Context,
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13686) FnDecl->getParamDecl(0)),
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 13687) SourceLocation(), Args[1]);
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13688) if (Arg1.isInvalid())
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13689) return ExprError();
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13690)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13691) ExprResult Arg0 =
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 13692) PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13693) Best->FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13694) if (Arg0.isInvalid())
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13695) return ExprError();
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13696) Base = Args[0] = Arg0.getAs<Expr>();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13697) Args[1] = RHS = Arg1.getAs<Expr>();
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13698) } else {
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13699) // Convert the arguments.
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13700) ExprResult Arg0 = PerformCopyInitialization(
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13701) InitializedEntity::InitializeParameter(Context,
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13702) FnDecl->getParamDecl(0)),
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 13703) SourceLocation(), Args[0]);
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13704) if (Arg0.isInvalid())
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13705) return ExprError();
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13706)
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13707) ExprResult Arg1 =
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13708) PerformCopyInitialization(
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13709) InitializedEntity::InitializeParameter(Context,
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13710) FnDecl->getParamDecl(1)),
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 13711) SourceLocation(), Args[1]);
+0a70c4d9a2e5f (Douglas Gregor 2009-12-22 21:44:34 +0000 13712) if (Arg1.isInvalid())
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13713) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13714) Args[0] = LHS = Arg0.getAs<Expr>();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13715) Args[1] = RHS = Arg1.getAs<Expr>();
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13716) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13717)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13718) // Build the actual expression node.
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 13719) ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 13720) Best->FoundDecl, Base,
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 13721) HadMultipleCandidates, OpLoc);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13722) if (FnExpr.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13723) return ExprError();
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13724)
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13725) // Determine the result type.
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 13726) QualType ResultTy = FnDecl->getReturnType();
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13727) ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13728) ResultTy = ResultTy.getNonLValueExprType(Context);
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 13729)
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 13730) CXXOperatorCallExpr *TheCall = CXXOperatorCallExpr::Create(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13731) Context, ChosenOp, FnExpr.get(), Args, ResultTy, VK, OpLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 13732) CurFPFeatureOverrides(), Best->IsADLCandidate);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13733)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 13734) if (CheckCallReturnType(FnDecl->getReturnType(), OpLoc, TheCall,
+e4f4b5e919adc (Anders Carlsson 2009-10-13 22:43:21 +0000 13735) FnDecl))
+e4f4b5e919adc (Anders Carlsson 2009-10-13 22:43:21 +0000 13736) return ExprError();
+e4f4b5e919adc (Anders Carlsson 2009-10-13 22:43:21 +0000 13737)
+d24d5f2b79790 (Nick Lewycky 2013-01-24 02:03:08 +0000 13738) ArrayRef<const Expr *> ArgsArray(Args, 2);
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13739) const Expr *ImplicitThis = nullptr;
+d24d5f2b79790 (Nick Lewycky 2013-01-24 02:03:08 +0000 13740) // Cut off the implicit 'this'.
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13741) if (isa<CXXMethodDecl>(FnDecl)) {
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13742) ImplicitThis = ArgsArray[0];
+d24d5f2b79790 (Nick Lewycky 2013-01-24 02:03:08 +0000 13743) ArgsArray = ArgsArray.slice(1);
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13744) }
+36d0b2b49f7c8 (Richard Trieu 2015-01-13 02:32:02 +0000 13745)
+36d0b2b49f7c8 (Richard Trieu 2015-01-13 02:32:02 +0000 13746) // Check for a self move.
+36d0b2b49f7c8 (Richard Trieu 2015-01-13 02:32:02 +0000 13747) if (Op == OO_Equal)
+36d0b2b49f7c8 (Richard Trieu 2015-01-13 02:32:02 +0000 13748) DiagnoseSelfMove(Args[0], Args[1], OpLoc);
+36d0b2b49f7c8 (Richard Trieu 2015-01-13 02:32:02 +0000 13749)
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13750) if (ImplicitThis) {
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13751) QualType ThisType = Context.getPointerType(ImplicitThis->getType());
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13752) QualType ThisTypeFromDecl = Context.getPointerType(
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13753) cast<CXXMethodDecl>(FnDecl)->getThisObjectType());
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13754)
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13755) CheckArgAlignment(OpLoc, FnDecl, "'this'", ThisType,
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13756) ThisTypeFromDecl);
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13757) }
+7e5cea5b509f5 (Tomas Matheson 2021-02-19 17:33:56 +0000 13758)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13759) checkCall(FnDecl, nullptr, ImplicitThis, ArgsArray,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13760) isa<CXXMethodDecl>(FnDecl), OpLoc, TheCall->getSourceRange(),
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 13761) VariadicDoesNotApply);
+d24d5f2b79790 (Nick Lewycky 2013-01-24 02:03:08 +0000 13762)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13763) ExprResult R = MaybeBindToTemporary(TheCall);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13764) if (R.isInvalid())
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13765) return ExprError();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13766)
+5a5f5350e1cbe (Richard Smith 2020-06-29 19:02:47 -0700 13767) R = CheckForImmediateInvocation(R, FnDecl);
+5a5f5350e1cbe (Richard Smith 2020-06-29 19:02:47 -0700 13768) if (R.isInvalid())
+5a5f5350e1cbe (Richard Smith 2020-06-29 19:02:47 -0700 13769) return ExprError();
+5a5f5350e1cbe (Richard Smith 2020-06-29 19:02:47 -0700 13770)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13771) // For a rewritten candidate, we've already reversed the arguments
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13772) // if needed. Perform the rest of the rewrite now.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13773) if ((Best->RewriteKind & CRK_DifferentOperator) ||
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13774) (Op == OO_Spaceship && IsReversed)) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13775) if (Op == OO_ExclaimEqual) {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13776) assert(ChosenOp == OO_EqualEqual && "unexpected operator name");
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13777) R = CreateBuiltinUnaryOp(OpLoc, UO_LNot, R.get());
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13778) } else {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13779) assert(ChosenOp == OO_Spaceship && "unexpected operator name");
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13780) llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13781) Expr *ZeroLiteral =
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13782) IntegerLiteral::Create(Context, Zero, Context.IntTy, OpLoc);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13783)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13784) Sema::CodeSynthesisContext Ctx;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13785) Ctx.Kind = Sema::CodeSynthesisContext::RewritingOperatorAsSpaceship;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13786) Ctx.Entity = FnDecl;
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13787) pushCodeSynthesisContext(Ctx);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13788)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13789) R = CreateOverloadedBinOp(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13790) OpLoc, Opc, Fns, IsReversed ? ZeroLiteral : R.get(),
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13791) IsReversed ? R.get() : ZeroLiteral, PerformADL,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13792) /*AllowRewrittenCandidates=*/false);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13793)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13794) popCodeSynthesisContext();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13795) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13796) if (R.isInvalid())
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13797) return ExprError();
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13798) } else {
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13799) assert(ChosenOp == Op && "unexpected operator name");
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13800) }
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13801)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13802) // Make a note in the AST if we did any rewriting.
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13803) if (Best->RewriteKind != CRK_None)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13804) R = new (Context) CXXRewrittenBinaryOperator(R.get(), IsReversed);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13805)
+5a5f5350e1cbe (Richard Smith 2020-06-29 19:02:47 -0700 13806) return R;
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13807) } else {
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13808) // We matched a built-in operator. Convert the arguments, then
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13809) // break out so that we will build the appropriate built-in
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13810) // operator node.
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13811) ExprResult ArgsRes0 = PerformImplicitConversion(
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13812) Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13813) AA_Passing, CCK_ForBuiltinOverloadedOp);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13814) if (ArgsRes0.isInvalid())
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13815) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13816) Args[0] = ArgsRes0.get();
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13817)
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13818) ExprResult ArgsRes1 = PerformImplicitConversion(
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13819) Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 13820) AA_Passing, CCK_ForBuiltinOverloadedOp);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13821) if (ArgsRes1.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 13822) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 13823) Args[1] = ArgsRes1.get();
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13824) break;
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13825) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13826) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13827)
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13828) case OR_No_Viable_Function: {
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13829) // C++ [over.match.oper]p9:
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13830) // If the operator is the operator , [...] and there are no
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13831) // viable functions, then the operator is assumed to be the
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13832) // built-in operator and interpreted according to clause 5.
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 13833) if (Opc == BO_Comma)
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13834) break;
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13835)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13836) // When defaulting an 'operator<=>', we can try to synthesize a three-way
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13837) // compare result using '==' and '<'.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13838) if (DefaultedFn && Opc == BO_Cmp) {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13839) ExprResult E = BuildSynthesizedThreeWayComparison(OpLoc, Fns, Args[0],
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13840) Args[1], DefaultedFn);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13841) if (E.isInvalid() || E.isUsable())
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13842) return E;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13843) }
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13844)
+2a8c18d991188 (Alexander Kornienko 2018-04-06 15:14:32 +0000 13845) // For class as left operand for assignment or compound assignment
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13846) // operator do not fall through to handling in built-in, but report that
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 13847) // no overloaded assignment operator found
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 13848) ExprResult Result = ExprError();
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13849) StringRef OpcStr = BinaryOperator::getOpcodeStr(Opc);
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13850) auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13851) Args, OpLoc);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13852) if (Args[0]->getType()->isRecordType() &&
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 13853) Opc >= BO_Assign && Opc <= BO_OrAssign) {
+027de2adcd43f (Sebastian Redl 2009-05-21 11:50:50 +0000 13854) Diag(OpLoc, diag::err_ovl_no_viable_oper)
+027de2adcd43f (Sebastian Redl 2009-05-21 11:50:50 +0000 13855) << BinaryOperator::getOpcodeStr(Opc)
+e9899d9769661 (Douglas Gregor 2009-08-26 17:08:25 +0000 13856) << Args[0]->getSourceRange() << Args[1]->getSourceRange();
+a31efa07ff703 (Eli Friedman 2013-08-28 20:35:35 +0000 13857) if (Args[0]->getType()->isIncompleteType()) {
+a31efa07ff703 (Eli Friedman 2013-08-28 20:35:35 +0000 13858) Diag(OpLoc, diag::note_assign_lhs_incomplete)
+a31efa07ff703 (Eli Friedman 2013-08-28 20:35:35 +0000 13859) << Args[0]->getType()
+a31efa07ff703 (Eli Friedman 2013-08-28 20:35:35 +0000 13860) << Args[0]->getSourceRange() << Args[1]->getSourceRange();
+a31efa07ff703 (Eli Friedman 2013-08-28 20:35:35 +0000 13861) }
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13862) } else {
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13863) // This is an erroneous use of an operator which can be overloaded by
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13864) // a non-member function. Check for non-member operators which were
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13865) // defined too late to be candidates.
+b24b9aa298311 (Ahmed Charles 2012-02-25 11:00:22 +0000 13866) if (DiagnoseTwoPhaseOperatorLookup(*this, Op, OpLoc, Args))
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13867) // FIXME: Recover by calling the found function.
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13868) return ExprError();
+998a591e32613 (Richard Smith 2011-06-05 22:42:48 +0000 13869)
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13870) // No viable function; try to create a built-in operation, which will
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13871) // produce an error. Then, show the non-viable candidates.
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13872) Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
+027de2adcd43f (Sebastian Redl 2009-05-21 11:50:50 +0000 13873) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 13874) assert(Result.isInvalid() &&
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13875) "C++ binary operator overloading is missing candidates!");
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13876) CandidateSet.NoteCandidates(*this, Args, Cands, OpcStr, OpLoc);
+62b95d88dc14f (Benjamin Kramer 2012-08-23 21:35:17 +0000 13877) return Result;
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13878) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13879)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13880) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13881) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13882) PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13883) << BinaryOperator::getOpcodeStr(Opc)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13884) << Args[0]->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13885) << Args[1]->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13886) << Args[0]->getSourceRange()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13887) << Args[1]->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 13888) *this, OCD_AmbiguousCandidates, Args, BinaryOperator::getOpcodeStr(Opc),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13889) OpLoc);
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13890) return ExprError();
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13891)
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13892) case OR_Deleted:
+74f7d50f6a5b2 (Douglas Gregor 2012-02-15 19:33:52 +0000 13893) if (isImplicitlyDeleted(Best->Function)) {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13894) FunctionDecl *DeletedFD = Best->Function;
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13895) DefaultedFunctionKind DFK = getDefaultedFunctionKind(DeletedFD);
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13896) if (DFK.isSpecialMember()) {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13897) Diag(OpLoc, diag::err_ovl_deleted_special_oper)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13898) << Args[0]->getType() << DFK.asSpecialMember();
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13899) } else {
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13900) assert(DFK.isComparison());
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13901) Diag(OpLoc, diag::err_ovl_deleted_comparison)
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13902) << Args[0]->getType() << DeletedFD;
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13903) }
+6f1e2c6d19a7f (Richard Smith 2012-04-02 20:59:25 +0000 13904)
+de1a487402585 (Richard Smith 2012-12-28 12:23:24 +0000 13905) // The user probably meant to call this special member. Just
+de1a487402585 (Richard Smith 2012-12-28 12:23:24 +0000 13906) // explain why it's deleted.
+5253d9138eb31 (Richard Smith 2019-11-06 12:03:12 -0800 13907) NoteDeletedFunction(DeletedFD);
+de1a487402585 (Richard Smith 2012-12-28 12:23:24 +0000 13908) return ExprError();
+74f7d50f6a5b2 (Douglas Gregor 2012-02-15 19:33:52 +0000 13909) }
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13910) CandidateSet.NoteCandidates(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13911) PartialDiagnosticAt(
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13912) OpLoc, PDiag(diag::err_ovl_deleted_oper)
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13913) << getOperatorSpelling(Best->Function->getDeclName()
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13914) .getCXXOverloadedOperator())
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13915) << Args[0]->getSourceRange()
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 13916) << Args[1]->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13917) *this, OCD_AllCandidates, Args, BinaryOperator::getOpcodeStr(Opc),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 13918) OpLoc);
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13919) return ExprError();
+0d1da2298aaa8 (John McCall 2010-01-12 00:44:57 +0000 13920) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13921)
+66950a32d9083 (Douglas Gregor 2009-09-30 21:46:01 +0000 13922) // We matched a built-in operator; build it.
+e9899d9769661 (Douglas Gregor 2009-08-26 17:08:25 +0000 13923) return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]);
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13924) }
+1baf54e1aa8a1 (Douglas Gregor 2009-03-13 18:40:31 +0000 13925)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13926) ExprResult Sema::BuildSynthesizedThreeWayComparison(
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13927) SourceLocation OpLoc, const UnresolvedSetImpl &Fns, Expr *LHS, Expr *RHS,
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13928) FunctionDecl *DefaultedFn) {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13929) const ComparisonCategoryInfo *Info =
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13930) Context.CompCategories.lookupInfoForType(DefaultedFn->getReturnType());
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13931) // If we're not producing a known comparison category type, we can't
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13932) // synthesize a three-way comparison. Let the caller diagnose this.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13933) if (!Info)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13934) return ExprResult((Expr*)nullptr);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13935)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13936) // If we ever want to perform this synthesis more generally, we will need to
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13937) // apply the temporary materialization conversion to the operands.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13938) assert(LHS->isGLValue() && RHS->isGLValue() &&
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13939) "cannot use prvalue expressions more than once");
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13940) Expr *OrigLHS = LHS;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13941) Expr *OrigRHS = RHS;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13942)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13943) // Replace the LHS and RHS with OpaqueValueExprs; we're going to refer to
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13944) // each of them multiple times below.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13945) LHS = new (Context)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13946) OpaqueValueExpr(LHS->getExprLoc(), LHS->getType(), LHS->getValueKind(),
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13947) LHS->getObjectKind(), LHS);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13948) RHS = new (Context)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13949) OpaqueValueExpr(RHS->getExprLoc(), RHS->getType(), RHS->getValueKind(),
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13950) RHS->getObjectKind(), RHS);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13951)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13952) ExprResult Eq = CreateOverloadedBinOp(OpLoc, BO_EQ, Fns, LHS, RHS, true, true,
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13953) DefaultedFn);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13954) if (Eq.isInvalid())
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13955) return ExprError();
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13956)
+f495de43bd5da (Richard Smith 2019-12-16 17:40:03 -0800 13957) ExprResult Less = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, LHS, RHS, true,
+f495de43bd5da (Richard Smith 2019-12-16 17:40:03 -0800 13958) true, DefaultedFn);
+f495de43bd5da (Richard Smith 2019-12-16 17:40:03 -0800 13959) if (Less.isInvalid())
+f495de43bd5da (Richard Smith 2019-12-16 17:40:03 -0800 13960) return ExprError();
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13961)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13962) ExprResult Greater;
+f495de43bd5da (Richard Smith 2019-12-16 17:40:03 -0800 13963) if (Info->isPartial()) {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13964) Greater = CreateOverloadedBinOp(OpLoc, BO_LT, Fns, RHS, LHS, true, true,
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13965) DefaultedFn);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13966) if (Greater.isInvalid())
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13967) return ExprError();
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13968) }
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13969)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13970) // Form the list of comparisons we're going to perform.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13971) struct Comparison {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13972) ExprResult Cmp;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13973) ComparisonCategoryResult Result;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13974) } Comparisons[4] =
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13975) { {Eq, Info->isStrong() ? ComparisonCategoryResult::Equal
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13976) : ComparisonCategoryResult::Equivalent},
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13977) {Less, ComparisonCategoryResult::Less},
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13978) {Greater, ComparisonCategoryResult::Greater},
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13979) {ExprResult(), ComparisonCategoryResult::Unordered},
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13980) };
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13981)
+f495de43bd5da (Richard Smith 2019-12-16 17:40:03 -0800 13982) int I = Info->isPartial() ? 3 : 2;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13983)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13984) // Combine the comparisons with suitable conditional expressions.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13985) ExprResult Result;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13986) for (; I >= 0; --I) {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13987) // Build a reference to the comparison category constant.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13988) auto *VI = Info->lookupValueInfo(Comparisons[I].Result);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13989) // FIXME: Missing a constant for a comparison category. Diagnose this?
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13990) if (!VI)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13991) return ExprResult((Expr*)nullptr);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13992) ExprResult ThisResult =
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13993) BuildDeclarationNameExpr(CXXScopeSpec(), DeclarationNameInfo(), VI->VD);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13994) if (ThisResult.isInvalid())
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13995) return ExprError();
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13996)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13997) // Build a conditional unless this is the final case.
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13998) if (Result.get()) {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 13999) Result = ActOnConditionalOp(OpLoc, OpLoc, Comparisons[I].Cmp.get(),
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14000) ThisResult.get(), Result.get());
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14001) if (Result.isInvalid())
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14002) return ExprError();
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14003) } else {
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14004) Result = ThisResult;
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14005) }
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14006) }
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14007)
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14008) // Build a PseudoObjectExpr to model the rewriting of an <=> operator, and to
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14009) // bind the OpaqueValueExprs before they're (repeatedly) used.
+2ba4e3a4598b1 (Melanie Blower 2020-04-10 13:34:46 -0700 14010) Expr *SyntacticForm = BinaryOperator::Create(
+2ba4e3a4598b1 (Melanie Blower 2020-04-10 13:34:46 -0700 14011) Context, OrigLHS, OrigRHS, BO_Cmp, Result.get()->getType(),
+2ba4e3a4598b1 (Melanie Blower 2020-04-10 13:34:46 -0700 14012) Result.get()->getValueKind(), Result.get()->getObjectKind(), OpLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14013) CurFPFeatureOverrides());
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14014) Expr *SemanticForm[] = {LHS, RHS, Result.get()};
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14015) return PseudoObjectExpr::Create(Context, SyntacticForm, SemanticForm, 2);
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14016) }
+cafc7416baf7e (Richard Smith 2019-12-04 15:25:27 -0800 14017)
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 14018) ExprResult
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14019) Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc,
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14020) SourceLocation RLoc,
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 14021) Expr *Base, Expr *Idx) {
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 14022) Expr *Args[2] = { Base, Idx };
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14023) DeclarationName OpName =
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14024) Context.DeclarationNames.getCXXOperatorName(OO_Subscript);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14025)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14026) // If either side is type-dependent, create an appropriate dependent
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14027) // expression.
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14028) if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) {
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14029)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14030) CXXRecordDecl *NamingClass = nullptr; // lookup ignores member operators
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 14031) // CHECKME: no 'operator' keyword?
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 14032) DeclarationNameInfo OpNameInfo(OpName, LLoc);
+d6d2f18905433 (Abramo Bagnara 2010-08-11 22:01:17 +0000 14033) OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14034) ExprResult Fn = CreateUnresolvedLookupExpr(
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14035) NamingClass, NestedNameSpecifierLoc(), OpNameInfo, UnresolvedSet<0>());
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14036) if (Fn.isInvalid())
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14037) return ExprError();
+e66edc18ae0fc (John McCall 2009-11-24 19:00:30 +0000 14038) // Can't add any actual overloads yet
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14039)
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14040) return CXXOperatorCallExpr::Create(Context, OO_Subscript, Fn.get(), Args,
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 14041) Context.DependentTy, VK_RValue, RLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14042) CurFPFeatureOverrides());
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14043) }
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14044)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14045) // Handle placeholders on both operands.
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14046) if (checkPlaceholderForOverload(*this, Args[0]))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14047) return ExprError();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14048) if (checkPlaceholderForOverload(*this, Args[1]))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14049) return ExprError();
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 14050)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14051) // Build an empty overload set.
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14052) OverloadCandidateSet CandidateSet(LLoc, OverloadCandidateSet::CSK_Operator);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14053)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14054) // Subscript can only be overloaded as a member function.
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14055)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14056) // Add operator candidates that are member functions.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 14057) AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14058)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14059) // Add builtin operator candidates.
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 14060) AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, CandidateSet);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14061)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14062) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14063)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14064) // Perform overload resolution.
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14065) OverloadCandidateSet::iterator Best;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 14066) switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) {
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14067) case OR_Success: {
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14068) // We found a built-in operator or an overloaded operator.
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14069) FunctionDecl *FnDecl = Best->Function;
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14070)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14071) if (FnDecl) {
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14072) // We matched an overloaded operator. Build a call to that
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14073) // operator.
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14074)
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 14075) CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl);
+58cc69d4c1516 (John McCall 2010-01-27 01:50:18 +0000 14076)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14077) // Convert the arguments.
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14078) CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14079) ExprResult Arg0 =
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14080) PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/nullptr,
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14081) Best->FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14082) if (Arg0.isInvalid())
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14083) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14084) Args[0] = Arg0.get();
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14085)
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14086) // Convert the arguments.
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 14087) ExprResult InputInit
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14088) = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+8fb87aec78b52 (Fariborz Jahanian 2010-09-24 17:30:16 +0000 14089) Context,
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14090) FnDecl->getParamDecl(0)),
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14091) SourceLocation(),
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 14092) Args[1]);
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14093) if (InputInit.isInvalid())
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14094) return ExprError();
+a68e51e3a1803 (Anders Carlsson 2010-01-29 18:37:50 +0000 14095)
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14096) Args[1] = InputInit.getAs<Expr>();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14097)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14098) // Build the actual expression node.
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14099) DeclarationNameInfo OpLocInfo(OpName, LLoc);
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14100) OpLocInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc));
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14101) ExprResult FnExpr = CreateFunctionRefExpr(*this, FnDecl,
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 14102) Best->FoundDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 14103) Base,
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14104) HadMultipleCandidates,
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14105) OpLocInfo.getLoc(),
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14106) OpLocInfo.getInfo());
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14107) if (FnExpr.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14108) return ExprError();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14109)
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 14110) // Determine the result type
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14111) QualType ResultTy = FnDecl->getReturnType();
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 14112) ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 14113) ResultTy = ResultTy.getNonLValueExprType(Context);
+c156470be5123 (Richard Smith 2013-11-15 02:58:23 +0000 14114)
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14115) CXXOperatorCallExpr *TheCall = CXXOperatorCallExpr::Create(
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14116) Context, OO_Subscript, FnExpr.get(), Args, ResultTy, VK, RLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14117) CurFPFeatureOverrides());
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14118) if (CheckCallReturnType(FnDecl->getReturnType(), LLoc, TheCall, FnDecl))
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14119) return ExprError();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14120)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14121) if (CheckFunctionCall(Method, TheCall,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14122) Method->getType()->castAs<FunctionProtoType>()))
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14123) return ExprError();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14124)
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 14125) return MaybeBindToTemporary(TheCall);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14126) } else {
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14127) // We matched a built-in operator. Convert the arguments, then
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14128) // break out so that we will build the appropriate built-in
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14129) // operator node.
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 14130) ExprResult ArgsRes0 = PerformImplicitConversion(
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 14131) Args[0], Best->BuiltinParamTypes[0], Best->Conversions[0],
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 14132) AA_Passing, CCK_ForBuiltinOverloadedOp);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14133) if (ArgsRes0.isInvalid())
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14134) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14135) Args[0] = ArgsRes0.get();
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14136)
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 14137) ExprResult ArgsRes1 = PerformImplicitConversion(
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 14138) Args[1], Best->BuiltinParamTypes[1], Best->Conversions[1],
+1ef7554efd1ad (Richard Smith 2018-06-27 20:30:34 +0000 14139) AA_Passing, CCK_ForBuiltinOverloadedOp);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14140) if (ArgsRes1.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14141) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14142) Args[1] = ArgsRes1.get();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14143)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14144) break;
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14145) }
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14146) }
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14147)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14148) case OR_No_Viable_Function: {
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14149) PartialDiagnostic PD = CandidateSet.empty()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14150) ? (PDiag(diag::err_ovl_no_oper)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14151) << Args[0]->getType() << /*subscript*/ 0
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14152) << Args[0]->getSourceRange() << Args[1]->getSourceRange())
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14153) : (PDiag(diag::err_ovl_no_viable_subscript)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14154) << Args[0]->getType() << Args[0]->getSourceRange()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14155) << Args[1]->getSourceRange());
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14156) CandidateSet.NoteCandidates(PartialDiagnosticAt(LLoc, PD), *this,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14157) OCD_AllCandidates, Args, "[]", LLoc);
+0237485287e9b (John McCall 2010-01-07 02:04:15 +0000 14158) return ExprError();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14159) }
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14160)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14161) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14162) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14163) PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_ambiguous_oper_binary)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14164) << "[]" << Args[0]->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14165) << Args[1]->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14166) << Args[0]->getSourceRange()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14167) << Args[1]->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 14168) *this, OCD_AmbiguousCandidates, Args, "[]", LLoc);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14169) return ExprError();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14170)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14171) case OR_Deleted:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14172) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14173) PartialDiagnosticAt(LLoc, PDiag(diag::err_ovl_deleted_oper)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14174) << "[]" << Args[0]->getSourceRange()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14175) << Args[1]->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14176) *this, OCD_AllCandidates, Args, "[]", LLoc);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14177) return ExprError();
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14178) }
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14179)
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14180) // We matched a built-in operator; build it.
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 14181) return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc);
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14182) }
+adba46edc224c (Sebastian Redl 2009-10-29 20:17:01 +0000 14183)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14184) /// BuildCallToMemberFunction - Build a call to a member
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14185) /// function. MemExpr is the expression that refers to the member
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14186) /// function (and includes the object parameter), Args/NumArgs are the
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14187) /// arguments to the function call (not including the object
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14188) /// parameter). The caller needs to validate that the member
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14189) /// expression refers to a non-static member function or an overloaded
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14190) /// member function.
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14191) ExprResult Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE,
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14192) SourceLocation LParenLoc,
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14193) MultiExprArg Args,
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14194) SourceLocation RParenLoc,
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14195) bool AllowRecovery) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14196) assert(MemExprE->getType() == Context.BoundMemberTy ||
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14197) MemExprE->getType() == Context.OverloadTy);
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14198)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14199) // Dig out the member expression. This holds both the object
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14200) // argument and the member function we're referring to.
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14201) Expr *NakedMemExpr = MemExprE->IgnoreParens();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14202)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14203) // Determine whether this is a call to a pointer-to-member function.
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14204) if (BinaryOperator *op = dyn_cast<BinaryOperator>(NakedMemExpr)) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14205) assert(op->getType() == Context.BoundMemberTy);
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14206) assert(op->getOpcode() == BO_PtrMemD || op->getOpcode() == BO_PtrMemI);
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14207)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14208) QualType fnType =
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14209) op->getRHS()->getType()->castAs<MemberPointerType>()->getPointeeType();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14210)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14211) const FunctionProtoType *proto = fnType->castAs<FunctionProtoType>();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14212) QualType resultType = proto->getCallResultType(Context);
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14213) ExprValueKind valueKind = Expr::getValueKindForType(proto->getReturnType());
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14214)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14215) // Check that the object type isn't more qualified than the
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14216) // member function we're calling.
+c61eaa5920161 (Anastasia Stulova 2019-01-28 11:37:49 +0000 14217) Qualifiers funcQuals = proto->getMethodQuals();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14218)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14219) QualType objectType = op->getLHS()->getType();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14220) if (op->getOpcode() == BO_PtrMemI)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14221) objectType = objectType->castAs<PointerType>()->getPointeeType();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14222) Qualifiers objectQuals = objectType.getQualifiers();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14223)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14224) Qualifiers
diff erence = objectQuals - funcQuals;
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14225)
diff erence.removeObjCGCAttr();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14226)
diff erence.removeAddressSpace();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14227) if (
diff erence) {
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14228) std::string qualsString =
diff erence.getAsString();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14229) Diag(LParenLoc, diag::err_pointer_to_member_call_drops_quals)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14230) << fnType.getUnqualifiedType()
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14231) << qualsString
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14232) << (qualsString.find(' ') == std::string::npos ? 1 : 2);
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14233) }
+35a6ef4c35cca (Nick Lewycky 2014-01-11 02:50:57 +0000 14234)
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14235) CXXMemberCallExpr *call = CXXMemberCallExpr::Create(
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14236) Context, MemExprE, Args, resultType, valueKind, RParenLoc,
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14237) CurFPFeatureOverrides(), proto->getNumParams());
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14238)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14239) if (CheckCallReturnType(proto->getReturnType(), op->getRHS()->getBeginLoc(),
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14240) call, nullptr))
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14241) return ExprError();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14242)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14243) if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14244) return ExprError();
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14245)
+9be9c6804f514 (Richard Trieu 2013-06-22 02:30:38 +0000 14246) if (CheckOtherCall(call, proto))
+9be9c6804f514 (Richard Trieu 2013-06-22 02:30:38 +0000 14247) return ExprError();
+9be9c6804f514 (Richard Trieu 2013-06-22 02:30:38 +0000 14248)
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14249) return MaybeBindToTemporary(call);
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14250) }
+0009fcc39e19e (John McCall 2011-04-26 20:42:42 +0000 14251)
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14252) // We only try to build a recovery expr at this level if we can preserve
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14253) // the return type, otherwise we return ExprError() and let the caller
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14254) // recover.
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14255) auto BuildRecoveryExpr = [&](QualType Type) {
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14256) if (!AllowRecovery)
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14257) return ExprError();
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14258) std::vector<Expr *> SubExprs = {MemExprE};
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14259) llvm::for_each(Args, [&SubExprs](Expr *E) { SubExprs.push_back(E); });
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14260) return CreateRecoveryExpr(MemExprE->getBeginLoc(), RParenLoc, SubExprs,
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14261) Type);
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14262) };
+ced8bdf74a4f2 (David Majnemer 2015-02-25 17:36:15 +0000 14263) if (isa<CXXPseudoDestructorExpr>(NakedMemExpr))
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 14264) return CallExpr::Create(Context, MemExprE, Args, Context.VoidTy, VK_RValue,
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14265) RParenLoc, CurFPFeatureOverrides());
+ced8bdf74a4f2 (David Majnemer 2015-02-25 17:36:15 +0000 14266)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14267) UnbridgedCastsSet UnbridgedCasts;
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 14268) if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14269) return ExprError();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14270)
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14271) MemberExpr *MemExpr;
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14272) CXXMethodDecl *Method = nullptr;
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14273) DeclAccessPair FoundDecl = DeclAccessPair::make(nullptr, AS_public);
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14274) NestedNameSpecifier *Qualifier = nullptr;
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14275) if (isa<MemberExpr>(NakedMemExpr)) {
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14276) MemExpr = cast<MemberExpr>(NakedMemExpr);
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14277) Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl());
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 14278) FoundDecl = MemExpr->getFoundDecl();
+cc3f325fa69e7 (Douglas Gregor 2010-03-03 23:55:11 +0000 14279) Qualifier = MemExpr->getQualifier();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14280) UnbridgedCasts.restore();
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14281) } else {
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14282) UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr);
+cc3f325fa69e7 (Douglas Gregor 2010-03-03 23:55:11 +0000 14283) Qualifier = UnresExpr->getQualifier();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14284)
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14285) QualType ObjectType = UnresExpr->getBaseType();
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 14286) Expr::Classification ObjectClassification
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 14287) = UnresExpr->isArrow()? Expr::Classification::makeSimpleLValue()
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 14288) : UnresExpr->getBase()->Classify(Context);
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14289)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14290) // Add overload candidates
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14291) OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc(),
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14292) OverloadCandidateSet::CSK_Normal);
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14293)
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14294) // FIXME: avoid copy.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14295) TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14296) if (UnresExpr->hasExplicitTemplateArgs()) {
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14297) UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14298) TemplateArgs = &TemplateArgsBuffer;
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14299) }
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14300)
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14301) for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(),
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14302) E = UnresExpr->decls_end(); I != E; ++I) {
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14303)
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14304) NamedDecl *Func = *I;
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14305) CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext());
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14306) if (isa<UsingShadowDecl>(Func))
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14307) Func = cast<UsingShadowDecl>(Func)->getTargetDecl();
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14308)
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 14309)
+64225794119ee (Francois Pichet 2011-01-18 05:04:39 +0000 14310) // Microsoft supports direct constructor calls.
+bbafb8a745736 (David Blaikie 2012-03-11 07:00:24 +0000 14311) if (getLangOpts().MicrosoftExt && isa<CXXConstructorDecl>(Func)) {
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 14312) AddOverloadCandidate(cast<CXXConstructorDecl>(Func), I.getPair(), Args,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 14313) CandidateSet,
+76b9027f352a8 (Richard Smith 2019-05-09 03:59:21 +0000 14314) /*SuppressUserConversions*/ false);
+64225794119ee (Francois Pichet 2011-01-18 05:04:39 +0000 14315) } else if ((Method = dyn_cast<CXXMethodDecl>(Func))) {
+d33198420ddad (Douglas Gregor 2009-10-24 04:59:53 +0000 14316) // If explicit template arguments were provided, we can't call a
+d33198420ddad (Douglas Gregor 2009-10-24 04:59:53 +0000 14317) // non-template member function.
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14318) if (TemplateArgs)
+d33198420ddad (Douglas Gregor 2009-10-24 04:59:53 +0000 14319) continue;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14320)
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 14321) AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14322) ObjectClassification, Args, CandidateSet,
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 14323) /*SuppressUserConversions=*/false);
+6b51f28e82646 (John McCall 2009-11-23 01:53:49 +0000 14324) } else {
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 14325) AddMethodTemplateCandidate(
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 14326) cast<FunctionTemplateDecl>(Func), I.getPair(), ActingDC,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14327) TemplateArgs, ObjectType, ObjectClassification, Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 14328) /*SuppressUserConversions=*/false);
+6b51f28e82646 (John McCall 2009-11-23 01:53:49 +0000 14329) }
+5ed5ae476e5c7 (Douglas Gregor 2009-08-21 18:42:58 +0000 14330) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14331)
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14332) DeclarationName DeclName = UnresExpr->getMemberName();
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14333)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14334) UnbridgedCasts.restore();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14335)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14336) OverloadCandidateSet::iterator Best;
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14337) bool Succeeded = false;
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14338) switch (CandidateSet.BestViableFunction(*this, UnresExpr->getBeginLoc(),
+9331ed89f8d34 (Nick Lewycky 2010-11-20 01:29:55 +0000 14339) Best)) {
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14340) case OR_Success:
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14341) Method = cast<CXXMethodDecl>(Best->Function);
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 14342) FoundDecl = Best->FoundDecl;
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 14343) CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl);
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 14344) if (DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()))
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14345) break;
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14346) // If FoundDecl is
diff erent from Method (such as if one is a template
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 14347) // and the other a specialization), make sure DiagnoseUseOfDecl is
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14348) // called on both.
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14349) // FIXME: This would be more comprehensively addressed by modifying
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14350) // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14351) // being used.
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 14352) if (Method != FoundDecl.getDecl() &&
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14353) DiagnoseUseOfDecl(Method, UnresExpr->getNameLoc()))
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14354) break;
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14355) Succeeded = true;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14356) break;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14357)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14358) case OR_No_Viable_Function:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14359) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14360) PartialDiagnosticAt(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14361) UnresExpr->getMemberLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14362) PDiag(diag::err_ovl_no_viable_member_function_in_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14363) << DeclName << MemExprE->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14364) *this, OCD_AllCandidates, Args);
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14365) break;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14366) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14367) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14368) PartialDiagnosticAt(UnresExpr->getMemberLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14369) PDiag(diag::err_ovl_ambiguous_member_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14370) << DeclName << MemExprE->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 14371) *this, OCD_AmbiguousCandidates, Args);
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14372) break;
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 14373) case OR_Deleted:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14374) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14375) PartialDiagnosticAt(UnresExpr->getMemberLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14376) PDiag(diag::err_ovl_deleted_member_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14377) << DeclName << MemExprE->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14378) *this, OCD_AllCandidates, Args);
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14379) break;
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14380) }
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14381) // Overload resolution fails, try to recover.
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14382) if (!Succeeded)
+6326b098852be (Haojian Wu 2020-12-14 08:45:13 +0100 14383) return BuildRecoveryExpr(chooseRecoveryType(CandidateSet, &Best));
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14384)
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 14385) MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14386)
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14387) // If overload resolution picked a static member, build a
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14388) // non-member call based on that function.
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14389) if (Method->isStatic()) {
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 14390) return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 14391) RParenLoc);
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14392) }
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14393)
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 14394) MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens());
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14395) }
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14396)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14397) QualType ResultType = Method->getReturnType();
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 14398) ExprValueKind VK = Expr::getValueKindForType(ResultType);
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 14399) ResultType = ResultType.getNonLValueExprType(Context);
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 14400)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14401) assert(Method && "Member call to something that isn't a method?");
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 14402) const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14403) CXXMemberCallExpr *TheCall = CXXMemberCallExpr::Create(
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14404) Context, MemExprE, Args, ResultType, VK, RParenLoc,
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14405) CurFPFeatureOverrides(), Proto->getNumParams());
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14406)
+c4859baea4af6 (Anders Carlsson 2009-10-10 00:06:20 +0000 14407) // Check for a valid return type.
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14408) if (CheckCallReturnType(Method->getReturnType(), MemExpr->getMemberLoc(),
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 14409) TheCall, Method))
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14410) return BuildRecoveryExpr(ResultType);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14411)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14412) // Convert the object argument (for a non-static member function call).
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 14413) // We only need to do this if there was actually an overload; otherwise
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 14414) // it was done at lookup.
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14415) if (!Method->isStatic()) {
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14416) ExprResult ObjectArg =
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14417) PerformObjectArgumentInitialization(MemExpr->getBase(), Qualifier,
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14418) FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14419) if (ObjectArg.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14420) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14421) MemExpr->setBase(ObjectArg.get());
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14422) }
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14423)
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14424) // Convert the rest of the arguments
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 14425) if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args,
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14426) RParenLoc))
+556e4eba4404a (Haojian Wu 2020-11-29 22:31:42 +0100 14427) return BuildRecoveryExpr(ResultType);
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14428)
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 14429) DiagnoseSentinelCalls(Method, LParenLoc, Args);
+ff4b407009962 (Eli Friedman 2012-02-18 04:48:30 +0000 14430)
+55ce352d4d011 (Richard Smith 2012-06-25 20:30:08 +0000 14431) if (CheckFunctionCall(Method, TheCall, Proto))
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 14432) return ExprError();
+8c84c206d95e8 (Anders Carlsson 2009-08-16 03:42:12 +0000 14433)
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14434) // In the case the method to call was not selected by the overloading
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14435) // resolution process, we still need to handle the enable_if attribute. Do
+0d546534d3e7e (George Burgess IV 2016-11-10 21:47:12 +0000 14436) // that here, so it will not hide previous -- and more relevant -- errors.
+add6ab5084903 (George Burgess IV 2016-11-16 21:31:25 +0000 14437) if (auto *MemE = dyn_cast<MemberExpr>(NakedMemExpr)) {
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 14438) if (const EnableIfAttr *Attr =
+0dfb43deb6d55 (Richard Smith 2020-05-28 15:02:18 -0700 14439) CheckEnableIf(Method, LParenLoc, Args, true)) {
+add6ab5084903 (George Burgess IV 2016-11-16 21:31:25 +0000 14440) Diag(MemE->getMemberLoc(),
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14441) diag::err_ovl_no_viable_member_function_in_call)
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14442) << Method << Method->getSourceRange();
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14443) Diag(Method->getLocation(),
+177399e2277c3 (George Burgess IV 2017-01-09 04:12:14 +0000 14444) diag::note_ovl_candidate_disabled_by_function_cond_attr)
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14445) << Attr->getCond()->getSourceRange() << Attr->getMessage();
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14446) return ExprError();
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14447) }
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14448) }
+aea6ade63a5e8 (George Burgess IV 2015-09-25 17:53:16 +0000 14449)
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 14450) if ((isa<CXXConstructorDecl>(CurContext) ||
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 14451) isa<CXXDestructorDecl>(CurContext)) &&
+47061ee5bc64f (Anders Carlsson 2011-05-06 14:25:31 +0000 14452) TheCall->getMethodDecl()->isPure()) {
+47061ee5bc64f (Anders Carlsson 2011-05-06 14:25:31 +0000 14453) const CXXMethodDecl *MD = TheCall->getMethodDecl();
+47061ee5bc64f (Anders Carlsson 2011-05-06 14:25:31 +0000 14454)
+ccb3738527581 (Davide Italiano 2015-07-14 23:36:10 +0000 14455) if (isa<CXXThisExpr>(MemExpr->getBase()->IgnoreParenCasts()) &&
+ccb3738527581 (Davide Italiano 2015-07-14 23:36:10 +0000 14456) MemExpr->performsVirtualDispatch(getLangOpts())) {
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14457) Diag(MemExpr->getBeginLoc(),
+47061ee5bc64f (Anders Carlsson 2011-05-06 14:25:31 +0000 14458) diag::warn_call_to_pure_virtual_member_function_from_ctor_dtor)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14459) << MD->getDeclName() << isa<CXXDestructorDecl>(CurContext)
+eb10b065f2a87 (Bruno Ricci 2020-07-27 23:22:21 +0100 14460) << MD->getParent();
+47061ee5bc64f (Anders Carlsson 2011-05-06 14:25:31 +0000 14461)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14462) Diag(MD->getBeginLoc(), diag::note_previous_decl) << MD->getDeclName();
+ccb3738527581 (Davide Italiano 2015-07-14 23:36:10 +0000 14463) if (getLangOpts().AppleKext)
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14464) Diag(MemExpr->getBeginLoc(), diag::note_pure_qualified_call_kext)
+eb10b065f2a87 (Bruno Ricci 2020-07-27 23:22:21 +0100 14465) << MD->getParent() << MD->getDeclName();
+5925926a2fc0f (Chandler Carruth 2011-06-27 08:31:58 +0000 14466) }
+47061ee5bc64f (Anders Carlsson 2011-05-06 14:25:31 +0000 14467) }
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14468)
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14469) if (CXXDestructorDecl *DD =
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14470) dyn_cast<CXXDestructorDecl>(TheCall->getMethodDecl())) {
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14471) // a->A::f() doesn't go through the vtable, except in AppleKext mode.
+d35f706cc2849 (Justin Lebar 2016-07-12 23:23:01 +0000 14472) bool CallCanBeVirtual = !MemExpr->hasQualifier() || getLangOpts().AppleKext;
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14473) CheckVirtualDtorCall(DD, MemExpr->getBeginLoc(), /*IsDelete=*/false,
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14474) CallCanBeVirtual, /*WarnOnNonAbstractTypes=*/true,
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14475) MemExpr->getMemberLoc());
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14476) }
+5a9259caa9b78 (Nico Weber 2016-01-15 21:45:31 +0000 14477)
+008e7bf92343b (Tyker 2020-02-04 19:23:33 +0100 14478) return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall),
+008e7bf92343b (Tyker 2020-02-04 19:23:33 +0100 14479) TheCall->getMethodDecl());
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14480) }
+97fd6e24c4e09 (Douglas Gregor 2008-12-22 05:46:06 +0000 14481)
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14482) /// BuildCallToObjectOfClassType - Build a call to an object of class
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14483) /// type (C++ [over.call.object]), which can end up invoking an
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14484) /// overloaded function call operator (@c operator()) or performing a
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14485) /// user-defined conversion on the object argument.
+faf5fb4b78c79 (John McCall 2010-08-26 23:41:50 +0000 14486) ExprResult
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14487) Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Obj,
+b0846b0f5101c (Douglas Gregor 2008-12-06 00:22:45 +0000 14488) SourceLocation LParenLoc,
+d3b75560aa07b (Dmitri Gribenko 2013-05-09 23:32:58 +0000 14489) MultiExprArg Args,
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14490) SourceLocation RParenLoc) {
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14491) if (checkPlaceholderForOverload(*this, Obj))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14492) return ExprError();
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 14493) ExprResult Object = Obj;
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14494)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14495) UnbridgedCastsSet UnbridgedCasts;
+d3b75560aa07b (Dmitri Gribenko 2013-05-09 23:32:58 +0000 14496) if (checkArgPlaceholdersForOverload(*this, Args, UnbridgedCasts))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14497) return ExprError();
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 14498)
+b58e51c304112 (Nico Weber 2014-11-19 05:21:39 +0000 14499) assert(Object.get()->getType()->isRecordType() &&
+b58e51c304112 (Nico Weber 2014-11-19 05:21:39 +0000 14500) "Requires object type argument");
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14501)
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14502) // C++ [over.call.object]p1:
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14503) // If the primary-expression E in the function call syntax
+44b83eea308ef (Eli Friedman 2009-08-05 19:21:58 +0000 14504) // evaluates to a class object of type "cv T", then the set of
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14505) // candidate functions includes at least the function call
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14506) // operators of T. The function call operators of T are obtained by
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14507) // ordinary lookup of the name operator() in the context of
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14508) // (E).operator().
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14509) OverloadCandidateSet CandidateSet(LParenLoc,
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14510) OverloadCandidateSet::CSK_Operator);
+91f84216f78f5 (Douglas Gregor 2008-12-11 16:49:14 +0000 14511) DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call);
+c473cbb3b2316 (Douglas Gregor 2009-11-15 07:48:03 +0000 14512)
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14513) if (RequireCompleteType(LParenLoc, Object.get()->getType(),
+7bfb2d026ec99 (Douglas Gregor 2012-05-04 16:32:21 +0000 14514) diag::err_incomplete_object_call, Object.get()))
+c473cbb3b2316 (Douglas Gregor 2009-11-15 07:48:03 +0000 14515) return true;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14516)
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 14517) const auto *Record = Object.get()->getType()->castAs<RecordType>();
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 14518) LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName);
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 14519) LookupQualifiedName(R, Record->getDecl());
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 14520) R.suppressDiagnostics();
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 14521)
+c473cbb3b2316 (Douglas Gregor 2009-11-15 07:48:03 +0000 14522) for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
+358e7745ed8fd (Douglas Gregor 2009-11-07 17:23:56 +0000 14523) Oper != OperEnd; ++Oper) {
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14524) AddMethodCandidate(Oper.getPair(), Object.get()->getType(),
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14525) Object.get()->Classify(Context), Args, CandidateSet,
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 14526) /*SuppressUserConversion=*/false);
+358e7745ed8fd (Douglas Gregor 2009-11-07 17:23:56 +0000 14527) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14528)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14529) // C++ [over.call.object]p2:
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 14530) // In addition, for each (non-explicit in C++0x) conversion function
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14531) // declared in T of the form
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14532) //
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14533) // operator conversion-type-id () cv-qualifier;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14534) //
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14535) // where cv-qualifier is the same cv-qualification as, or a
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14536) // greater cv-qualification than, cv, and where conversion-type-id
+f49fdf8337440 (Douglas Gregor 2008-11-20 13:33:37 +0000 14537) // denotes the type "pointer to function of (P1,...,Pn) returning
+f49fdf8337440 (Douglas Gregor 2008-11-20 13:33:37 +0000 14538) // R", or the type "reference to pointer to function of
+f49fdf8337440 (Douglas Gregor 2008-11-20 13:33:37 +0000 14539) // (P1,...,Pn) returning R", or the type "reference to function
+f49fdf8337440 (Douglas Gregor 2008-11-20 13:33:37 +0000 14540) // of (P1,...,Pn) returning R", a surrogate call function [...]
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14541) // is also considered as a candidate function. Similarly,
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14542) // surrogate call functions are added to the set of candidate
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14543) // functions for each conversion function declared in an
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14544) // accessible base class provided the function is not hidden
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14545) // within T by another intervening declaration.
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 14546) const auto &Conversions =
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 14547) cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions();
+b4ef66832dee0 (Benjamin Kramer 2015-02-06 17:25:10 +0000 14548) for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14549) NamedDecl *D = *I;
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14550) CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14551) if (isa<UsingShadowDecl>(D))
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14552) D = cast<UsingShadowDecl>(D)->getTargetDecl();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14553)
+74ba25ca5a34e (Douglas Gregor 2009-10-21 06:18:39 +0000 14554) // Skip over templated conversion functions; they aren't
+74ba25ca5a34e (Douglas Gregor 2009-10-21 06:18:39 +0000 14555) // surrogates.
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14556) if (isa<FunctionTemplateDecl>(D))
+74ba25ca5a34e (Douglas Gregor 2009-10-21 06:18:39 +0000 14557) continue;
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14558)
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14559) CXXConversionDecl *Conv = cast<CXXConversionDecl>(D);
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14560) if (!Conv->isExplicit()) {
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14561) // Strip the reference type (if any) and then the pointer type (if
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14562) // any) to get down to what might be a function type.
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14563) QualType ConvType = Conv->getConversionType().getNonReferenceType();
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14564) if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>())
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14565) ConvType = ConvPtrType->getPointeeType();
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14566)
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14567) if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>())
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14568) {
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14569) AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto,
+d3b75560aa07b (Dmitri Gribenko 2013-05-09 23:32:58 +0000 14570) Object.get(), Args, CandidateSet);
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14571) }
+38b2d3fa3e49a (Douglas Gregor 2011-07-23 18:59:35 +0000 14572) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14573) }
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14574)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14575) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14576)
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14577) // Perform overload resolution.
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14578) OverloadCandidateSet::iterator Best;
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 14579) switch (CandidateSet.BestViableFunction(*this, Object.get()->getBeginLoc(),
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 14580) Best)) {
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14581) case OR_Success:
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14582) // Overload resolution succeeded; we'll build the appropriate call
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14583) // below.
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14584) break;
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14585)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14586) case OR_No_Viable_Function: {
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14587) PartialDiagnostic PD =
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14588) CandidateSet.empty()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14589) ? (PDiag(diag::err_ovl_no_oper)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14590) << Object.get()->getType() << /*call*/ 1
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14591) << Object.get()->getSourceRange())
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14592) : (PDiag(diag::err_ovl_no_viable_object_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14593) << Object.get()->getType() << Object.get()->getSourceRange());
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14594) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14595) PartialDiagnosticAt(Object.get()->getBeginLoc(), PD), *this,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14596) OCD_AllCandidates, Args);
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14597) break;
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14598) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14599) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14600) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14601) PartialDiagnosticAt(Object.get()->getBeginLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14602) PDiag(diag::err_ovl_ambiguous_object_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14603) << Object.get()->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14604) << Object.get()->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 14605) *this, OCD_AmbiguousCandidates, Args);
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14606) break;
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 14607)
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 14608) case OR_Deleted:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14609) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14610) PartialDiagnosticAt(Object.get()->getBeginLoc(),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14611) PDiag(diag::err_ovl_deleted_object_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14612) << Object.get()->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14613) << Object.get()->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14614) *this, OCD_AllCandidates, Args);
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 14615) break;
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14616) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14617)
+b412e174db384 (Douglas Gregor 2010-07-25 18:17:45 +0000 14618) if (Best == CandidateSet.end())
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14619) return true;
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14620)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14621) UnbridgedCasts.restore();
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14622)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14623) if (Best->Function == nullptr) {
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14624) // Since there is no function declaration, this is one of the
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14625) // surrogate candidates. Dig out the conversion function.
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14626) CXXConversionDecl *Conv
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14627) = cast<CXXConversionDecl>(
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14628) Best->Conversions[0].UserDefined.ConversionFunction);
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14629)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14630) CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr,
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14631) Best->FoundDecl);
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 14632) if (DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc))
+22262abd78af0 (Richard Smith 2013-05-04 06:44:46 +0000 14633) return ExprError();
+fb9662ae71a2d (Simon Pilgrim 2017-06-01 18:17:18 +0000 14634) assert(Conv == Best->FoundDecl.getDecl() &&
+d667641542527 (Faisal Vali 2013-06-15 11:54:37 +0000 14635) "Found Decl & conversion-to-functionptr should be same, right?!");
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14636) // We selected one of the surrogate functions that converts the
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14637) // object parameter to a function pointer. Perform the conversion
+255b85f03c5db (Richard Smith 2019-05-08 01:36:36 +0000 14638) // on the object argument, then let BuildCallExpr finish the job.
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14639)
+774cf79987ccd (Fariborz Jahanian 2009-09-28 18:35:46 +0000 14640) // Create an implicit member expr to refer to the conversion operator.
+78cfcb56a10e7 (Fariborz Jahanian 2009-09-28 23:23:40 +0000 14641) // and then call it.
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14642) ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14643) Conv, HadMultipleCandidates);
+668443efb1db5 (Douglas Gregor 2011-01-20 00:18:04 +0000 14644) if (Call.isInvalid())
+668443efb1db5 (Douglas Gregor 2011-01-20 00:18:04 +0000 14645) return ExprError();
+b0cf297654585 (Abramo Bagnara 2011-11-16 22:46:05 +0000 14646) // Record usage of conversion in an implicit cast.
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 14647) Call = ImplicitCastExpr::Create(
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 14648) Context, Call.get()->getType(), CK_UserDefinedConversion, Call.get(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 14649) nullptr, VK_RValue, CurFPFeatureOverrides());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14650)
+255b85f03c5db (Richard Smith 2019-05-08 01:36:36 +0000 14651) return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14652) }
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14653)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14654) CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
+49ec2e694c6e4 (John McCall 2010-01-28 01:54:34 +0000 14655)
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14656) // We found an overloaded operator(). Build a CXXOperatorCallExpr
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14657) // that calls this method, using Object for the implicit object
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14658) // parameter and passing along the remaining arguments.
+ab7897ac44769 (Douglas Gregor 2008-11-19 22:57:39 +0000 14659) CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
+1fefe417f0ffd (Nico Weber 2012-11-09 06:06:14 +0000 14660)
+1fefe417f0ffd (Nico Weber 2012-11-09 06:06:14 +0000 14661) // An error diagnostic has already been printed when parsing the declaration.
+9512d3f161860 (Nico Weber 2012-11-09 08:38:04 +0000 14662) if (Method->isInvalidDecl())
+1fefe417f0ffd (Nico Weber 2012-11-09 06:06:14 +0000 14663) return ExprError();
+1fefe417f0ffd (Nico Weber 2012-11-09 06:06:14 +0000 14664)
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 14665) const auto *Proto = Method->getType()->castAs<FunctionProtoType>();
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 14666) unsigned NumParams = Proto->getNumParams();
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14667)
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14668) DeclarationNameInfo OpLocInfo(
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14669) Context.DeclarationNames.getCXXOperatorName(OO_Call), LParenLoc);
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14670) OpLocInfo.setCXXOperatorNameRange(SourceRange(LParenLoc, RParenLoc));
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 14671) ExprResult NewFn = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 14672) Obj, HadMultipleCandidates,
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14673) OpLocInfo.getLoc(),
+a2a299e586bf3 (Argyrios Kyrtzidis 2012-02-08 01:21:13 +0000 14674) OpLocInfo.getInfo());
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14675) if (NewFn.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14676) return true;
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14677)
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14678) // The number of argument slots to allocate in the call. If we have default
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14679) // arguments we need to allocate space for them as well. We additionally
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14680) // need one more slot for the object parameter.
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14681) unsigned NumArgsSlots = 1 + std::max<unsigned>(Args.size(), NumParams);
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14682)
+8b1a6bd8d05c3 (Benjamin Kramer 2013-09-25 13:10:11 +0000 14683) // Build the full argument list for the method call (the implicit object
+8b1a6bd8d05c3 (Benjamin Kramer 2013-09-25 13:10:11 +0000 14684) // parameter is placed at the beginning of the list).
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14685) SmallVector<Expr *, 8> MethodArgs(NumArgsSlots);
+02a0acd0bc3e2 (Douglas Gregor 2009-01-13 05:10:00 +0000 14686)
+a8a7d0f371619 (Chris Lattner 2009-04-12 08:11:20 +0000 14687) bool IsError = false;
+a8a7d0f371619 (Chris Lattner 2009-04-12 08:11:20 +0000 14688)
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14689) // Initialize the implicit object parameter.
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14690) ExprResult ObjRes =
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14691) PerformObjectArgumentInitialization(Object.get(), /*Qualifier=*/nullptr,
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14692) Best->FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14693) if (ObjRes.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14694) IsError = true;
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14695) else
+62b95d88dc14f (Benjamin Kramer 2012-08-23 21:35:17 +0000 14696) Object = ObjRes;
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14697) MethodArgs[0] = Object.get();
+a8a7d0f371619 (Chris Lattner 2009-04-12 08:11:20 +0000 14698)
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14699) // Check the argument types.
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 14700) for (unsigned i = 0; i != NumParams; i++) {
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14701) Expr *Arg;
+d3b75560aa07b (Dmitri Gribenko 2013-05-09 23:32:58 +0000 14702) if (i < Args.size()) {
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14703) Arg = Args[i];
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14704)
+02a0acd0bc3e2 (Douglas Gregor 2009-01-13 05:10:00 +0000 14705) // Pass the argument.
+7c5fe48060c0d (Anders Carlsson 2010-01-29 18:43:53 +0000 14706)
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 14707) ExprResult InputInit
+7c5fe48060c0d (Anders Carlsson 2010-01-29 18:43:53 +0000 14708) = PerformCopyInitialization(InitializedEntity::InitializeParameter(
+8fb87aec78b52 (Fariborz Jahanian 2010-09-24 17:30:16 +0000 14709) Context,
+7c5fe48060c0d (Anders Carlsson 2010-01-29 18:43:53 +0000 14710) Method->getParamDecl(i)),
+b268a282a4f19 (John McCall 2010-08-23 23:25:46 +0000 14711) SourceLocation(), Arg);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14712)
+7c5fe48060c0d (Anders Carlsson 2010-01-29 18:43:53 +0000 14713) IsError |= InputInit.isInvalid();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14714) Arg = InputInit.getAs<Expr>();
+02a0acd0bc3e2 (Douglas Gregor 2009-01-13 05:10:00 +0000 14715) } else {
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 14716) ExprResult DefArg
+1bc688dc6029f (Douglas Gregor 2009-11-09 19:27:57 +0000 14717) = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i));
+1bc688dc6029f (Douglas Gregor 2009-11-09 19:27:57 +0000 14718) if (DefArg.isInvalid()) {
+1bc688dc6029f (Douglas Gregor 2009-11-09 19:27:57 +0000 14719) IsError = true;
+1bc688dc6029f (Douglas Gregor 2009-11-09 19:27:57 +0000 14720) break;
+1bc688dc6029f (Douglas Gregor 2009-11-09 19:27:57 +0000 14721) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14722)
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14723) Arg = DefArg.getAs<Expr>();
+02a0acd0bc3e2 (Douglas Gregor 2009-01-13 05:10:00 +0000 14724) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14725)
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14726) MethodArgs[i + 1] = Arg;
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14727) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14728)
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14729) // If this is a variadic call, handle args passed through "...".
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14730) if (Proto->isVariadic()) {
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14731) // Promote the arguments (C99 6.5.2.2p7).
+b3fd5cfa81b83 (Alp Toker 2014-01-21 00:32:38 +0000 14732) for (unsigned i = NumParams, e = Args.size(); i < e; i++) {
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14733) ExprResult Arg = DefaultVariadicArgumentPromotion(Args[i], VariadicMethod,
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14734) nullptr);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14735) IsError |= Arg.isInvalid();
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14736) MethodArgs[i + 1] = Arg.get();
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14737) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14738) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14739)
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14740) if (IsError)
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14741) return true;
+a8a7d0f371619 (Chris Lattner 2009-04-12 08:11:20 +0000 14742)
+d3b75560aa07b (Dmitri Gribenko 2013-05-09 23:32:58 +0000 14743) DiagnoseSentinelCalls(Method, LParenLoc, Args);
+ff4b407009962 (Eli Friedman 2012-02-18 04:48:30 +0000 14744)
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14745) // Once we've built TheCall, all of the expressions are properly owned.
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14746) QualType ResultTy = Method->getReturnType();
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14747) ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14748) ResultTy = ResultTy.getNonLValueExprType(Context);
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14749)
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14750) CXXOperatorCallExpr *TheCall = CXXOperatorCallExpr::Create(
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14751) Context, OO_Call, NewFn.get(), MethodArgs, ResultTy, VK, RParenLoc,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14752) CurFPFeatureOverrides());
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14753)
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14754) if (CheckCallReturnType(Method->getReturnType(), LParenLoc, TheCall, Method))
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14755) return true;
+6ef089d21c885 (Bruno Ricci 2018-12-03 13:23:56 +0000 14756)
+55ce352d4d011 (Richard Smith 2012-06-25 20:30:08 +0000 14757) if (CheckFunctionCall(Method, TheCall, Proto))
+bc4c1078365b6 (Anders Carlsson 2009-08-16 01:56:34 +0000 14758) return true;
+bc4c1078365b6 (Anders Carlsson 2009-08-16 01:56:34 +0000 14759)
+008e7bf92343b (Tyker 2020-02-04 19:23:33 +0100 14760) return CheckForImmediateInvocation(MaybeBindToTemporary(TheCall), Method);
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14761) }
+91cea0ad1e4cd (Douglas Gregor 2008-11-19 21:05:33 +0000 14762)
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14763) /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14764) /// (if one exists), where @c Base is an expression of class type and
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14765) /// @c Member is the name of the member we're trying to find.
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 14766) ExprResult
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14767) Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc,
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14768) bool *NoArrowOperatorFound) {
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 14769) assert(Base->getType()->isRecordType() &&
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 14770) "left-hand side must have class type");
+11289f4280768 (Mike Stump 2009-09-09 15:08:12 +0000 14771)
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14772) if (checkPlaceholderForOverload(*this, Base))
+4124c4924d634 (John McCall 2011-10-17 18:40:02 +0000 14773) return ExprError();
+e26a872b02740 (John McCall 2010-12-04 08:14:53 +0000 14774)
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 14775) SourceLocation Loc = Base->getExprLoc();
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 14776)
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14777) // C++ [over.ref]p1:
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14778) //
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14779) // [...] An expression x->m is interpreted as (x.operator->())->m
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14780) // for a class object x of type T if T::operator->() exists and if
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14781) // the operator is selected as the best match function by the
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14782) // overload resolution mechanism (13.3).
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 14783) DeclarationName OpName =
+8e543b3d46932 (Chandler Carruth 2010-12-12 08:17:55 +0000 14784) Context.DeclarationNames.getCXXOperatorName(OO_Arrow);
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14785) OverloadCandidateSet CandidateSet(Loc, OverloadCandidateSet::CSK_Operator);
+d806156d54595 (Douglas Gregor 2009-08-06 03:17:00 +0000 14786)
+bc077cf5897af (John McCall 2010-02-08 23:07:23 +0000 14787) if (RequireCompleteType(Loc, Base->getType(),
+7bfb2d026ec99 (Douglas Gregor 2012-05-04 16:32:21 +0000 14788) diag::err_typecheck_incomplete_tag, Base))
+132e70bfa4352 (Eli Friedman 2009-11-18 01:28:03 +0000 14789) return ExprError();
+132e70bfa4352 (Eli Friedman 2009-11-18 01:28:03 +0000 14790)
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 14791) LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName);
+ab9dbc1d124cd (Simon Pilgrim 2020-01-14 14:15:51 +0000 14792) LookupQualifiedName(R, Base->getType()->castAs<RecordType>()->getDecl());
+27b18f8144b7c (John McCall 2009-11-17 02:14:36 +0000 14793) R.suppressDiagnostics();
+78b549399413c (Anders Carlsson 2009-09-10 23:18:36 +0000 14794)
+78b549399413c (Anders Carlsson 2009-09-10 23:18:36 +0000 14795) for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end();
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14796) Oper != OperEnd; ++Oper) {
+0282432039ab9 (Douglas Gregor 2011-01-26 19:30:28 +0000 14797) AddMethodCandidate(Oper.getPair(), Base->getType(), Base->Classify(Context),
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 14798) None, CandidateSet, /*SuppressUserConversion=*/false);
+6e9f8f6374349 (John McCall 2009-12-03 04:06:58 +0000 14799) }
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14800)
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14801) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 14802)
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14803) // Perform overload resolution.
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14804) OverloadCandidateSet::iterator Best;
+5c32be0053403 (John McCall 2010-08-24 20:38:10 +0000 14805) switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) {
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14806) case OR_Success:
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14807) // Overload resolution succeeded; we'll build the call below.
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14808) break;
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14809)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14810) case OR_No_Viable_Function: {
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14811) auto Cands = CandidateSet.CompleteCandidates(*this, OCD_AllCandidates, Base);
+1bb5dbf628889 (Kaelyn Uhrain 2013-07-11 22:38:30 +0000 14812) if (CandidateSet.empty()) {
+1bb5dbf628889 (Kaelyn Uhrain 2013-07-11 22:38:30 +0000 14813) QualType BaseType = Base->getType();
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14814) if (NoArrowOperatorFound) {
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14815) // Report this specific error to the caller instead of emitting a
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14816) // diagnostic, as requested.
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14817) *NoArrowOperatorFound = true;
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14818) return ExprError();
+0c51de4ab1ae1 (Kaelyn Uhrain 2013-07-31 17:38:24 +0000 14819) }
+bad7fb09b2d16 (Kaelyn Uhrain 2013-07-15 19:54:54 +0000 14820) Diag(OpLoc, diag::err_typecheck_member_reference_arrow)
+bad7fb09b2d16 (Kaelyn Uhrain 2013-07-15 19:54:54 +0000 14821) << BaseType << Base->getSourceRange();
+1bb5dbf628889 (Kaelyn Uhrain 2013-07-11 22:38:30 +0000 14822) if (BaseType->isRecordType() && !BaseType->isPointerType()) {
+bad7fb09b2d16 (Kaelyn Uhrain 2013-07-15 19:54:54 +0000 14823) Diag(OpLoc, diag::note_typecheck_member_reference_suggestion)
+1bb5dbf628889 (Kaelyn Uhrain 2013-07-11 22:38:30 +0000 14824) << FixItHint::CreateReplacement(OpLoc, ".");
+1bb5dbf628889 (Kaelyn Uhrain 2013-07-11 22:38:30 +0000 14825) }
+1bb5dbf628889 (Kaelyn Uhrain 2013-07-11 22:38:30 +0000 14826) } else
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14827) Diag(OpLoc, diag::err_ovl_no_viable_oper)
+d806156d54595 (Douglas Gregor 2009-08-06 03:17:00 +0000 14828) << "operator->" << Base->getSourceRange();
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14829) CandidateSet.NoteCandidates(*this, Base, Cands);
+d806156d54595 (Douglas Gregor 2009-08-06 03:17:00 +0000 14830) return ExprError();
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14831) }
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14832) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14833) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14834) PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_ambiguous_oper_unary)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14835) << "->" << Base->getType()
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14836) << Base->getSourceRange()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 14837) *this, OCD_AmbiguousCandidates, Base);
+d806156d54595 (Douglas Gregor 2009-08-06 03:17:00 +0000 14838) return ExprError();
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 14839)
+171c45ab0c19b (Douglas Gregor 2009-02-18 21:56:37 +0000 14840) case OR_Deleted:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14841) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14842) PartialDiagnosticAt(OpLoc, PDiag(diag::err_ovl_deleted_oper)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14843) << "->" << Base->getSourceRange()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14844) *this, OCD_AllCandidates, Base);
+d806156d54595 (Douglas Gregor 2009-08-06 03:17:00 +0000 14845) return ExprError();
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14846) }
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14847)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14848) CheckMemberOperatorAccess(OpLoc, Base, nullptr, Best->FoundDecl);
+a0296f7987c0a (John McCall 2010-03-19 07:35:19 +0000 14849)
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14850) // Convert the object parameter.
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14851) CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14852) ExprResult BaseResult =
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14853) PerformObjectArgumentInitialization(Base, /*Qualifier=*/nullptr,
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14854) Best->FoundDecl, Method);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14855) if (BaseResult.isInvalid())
+d806156d54595 (Douglas Gregor 2009-08-06 03:17:00 +0000 14856) return ExprError();
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14857) Base = BaseResult.get();
+9ecea26443d3f (Douglas Gregor 2008-11-21 03:04:22 +0000 14858)
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14859) // Build the operator call.
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 14860) ExprResult FnExpr = CreateFunctionRefExpr(*this, Method, Best->FoundDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 14861) Base, HadMultipleCandidates, OpLoc);
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14862) if (FnExpr.isInvalid())
+0129629fd34a8 (John Wiegley 2011-04-08 18:41:53 +0000 14863) return ExprError();
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 14864)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14865) QualType ResultTy = Method->getReturnType();
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 14866) ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 14867) ResultTy = ResultTy.getNonLValueExprType(Context);
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14868) CXXOperatorCallExpr *TheCall =
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14869) CXXOperatorCallExpr::Create(Context, OO_Arrow, FnExpr.get(), Base,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 14870) ResultTy, VK, OpLoc, CurFPFeatureOverrides());
+e4f4b5e919adc (Anders Carlsson 2009-10-13 22:43:21 +0000 14871)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14872) if (CheckCallReturnType(Method->getReturnType(), OpLoc, TheCall, Method))
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14873) return ExprError();
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14874)
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14875) if (CheckFunctionCall(Method, TheCall,
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14876) Method->getType()->castAs<FunctionProtoType>()))
+ce6284b17984a (George Burgess IV 2017-01-28 02:19:40 +0000 14877) return ExprError();
+2d9c47ea6cd3a (Eli Friedman 2011-04-04 01:18:25 +0000 14878)
+2d9c47ea6cd3a (Eli Friedman 2011-04-04 01:18:25 +0000 14879) return MaybeBindToTemporary(TheCall);
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14880) }
+e0e79bdef62a5 (Douglas Gregor 2008-11-20 16:27:02 +0000 14881)
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14882) /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14883) /// a literal operator described by the provided lookup results.
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14884) ExprResult Sema::BuildLiteralOperatorCall(LookupResult &R,
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14885) DeclarationNameInfo &SuffixInfo,
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14886) ArrayRef<Expr*> Args,
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14887) SourceLocation LitEndLoc,
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14888) TemplateArgumentListInfo *TemplateArgs) {
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14889) SourceLocation UDSuffixLoc = SuffixInfo.getCXXLiteralOperatorNameLoc();
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14890)
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14891) OverloadCandidateSet CandidateSet(UDSuffixLoc,
+100b24abc5a08 (Richard Smith 2014-04-17 01:52:14 +0000 14892) OverloadCandidateSet::CSK_Normal);
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 14893) AddNonMemberOperatorCandidates(R.asUnresolvedSet(), Args, CandidateSet,
+974c8b7e2fde5 (Richard Smith 2019-10-19 00:04:43 +0000 14894) TemplateArgs);
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14895)
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14896) bool HadMultipleCandidates = (CandidateSet.size() > 1);
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14897)
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14898) // Perform overload resolution. This will usually be trivial, but might need
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14899) // to perform substitutions for a literal operator template.
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14900) OverloadCandidateSet::iterator Best;
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14901) switch (CandidateSet.BestViableFunction(*this, UDSuffixLoc, Best)) {
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14902) case OR_Success:
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14903) case OR_Deleted:
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14904) break;
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14905)
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14906) case OR_No_Viable_Function:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14907) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14908) PartialDiagnosticAt(UDSuffixLoc,
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14909) PDiag(diag::err_ovl_no_viable_function_in_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14910) << R.getLookupName()),
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14911) *this, OCD_AllCandidates, Args);
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14912) return ExprError();
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14913)
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14914) case OR_Ambiguous:
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14915) CandidateSet.NoteCandidates(
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14916) PartialDiagnosticAt(R.getNameLoc(), PDiag(diag::err_ovl_ambiguous_call)
+5e328050503c5 (David Blaikie 2019-05-03 00:44:50 +0000 14917) << R.getLookupName()),
+70f59b5bbc84d (Richard Smith 2019-10-23 17:54:10 -0700 14918) *this, OCD_AmbiguousCandidates, Args);
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14919) return ExprError();
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14920) }
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14921)
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14922) FunctionDecl *FD = Best->Function;
+134af91b06493 (Nick Lewycky 2013-02-07 05:08:22 +0000 14923) ExprResult Fn = CreateFunctionRefExpr(*this, FD, Best->FoundDecl,
+2246167362bf3 (Akira Hatanaka 2017-07-13 06:08:27 +0000 14924) nullptr, HadMultipleCandidates,
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14925) SuffixInfo.getLoc(),
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14926) SuffixInfo.getInfo());
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14927) if (Fn.isInvalid())
+bcc22fc4e1b2c (Richard Smith 2012-03-09 08:00:36 +0000 14928) return true;
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14929)
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14930) // Check the argument types. This should almost always be a no-op, except
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14931) // that array-to-pointer decay is applied to string literals.
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14932) Expr *ConvArgs[2];
+e54c307bb4ed9 (Richard Smith 2013-05-05 15:51:06 +0000 14933) for (unsigned ArgIdx = 0, N = Args.size(); ArgIdx != N; ++ArgIdx) {
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14934) ExprResult InputInit = PerformCopyInitialization(
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14935) InitializedEntity::InitializeParameter(Context, FD->getParamDecl(ArgIdx)),
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14936) SourceLocation(), Args[ArgIdx]);
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14937) if (InputInit.isInvalid())
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14938) return true;
+01a7598561561 (Nikola Smiljanic 2014-05-29 10:55:11 +0000 14939) ConvArgs[ArgIdx] = InputInit.get();
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14940) }
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14941)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14942) QualType ResultTy = FD->getReturnType();
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14943) ExprValueKind VK = Expr::getValueKindForType(ResultTy);
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14944) ResultTy = ResultTy.getNonLValueExprType(Context);
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14945)
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 14946) UserDefinedLiteral *UDL = UserDefinedLiteral::Create(
+c5885cffc5206 (Bruno Ricci 2018-12-21 15:20:32 +0000 14947) Context, Fn.get(), llvm::makeArrayRef(ConvArgs, Args.size()), ResultTy,
+70e7aa4a4ed36 (Serge Pavlov 2020-07-24 12:04:19 +0700 14948) VK, LitEndLoc, UDSuffixLoc, CurFPFeatureOverrides());
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14949)
+314cc81b8caac (Alp Toker 2014-01-25 16:55:45 +0000 14950) if (CheckCallReturnType(FD->getReturnType(), UDSuffixLoc, UDL, FD))
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14951) return ExprError();
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14952)
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14953) if (CheckFunctionCall(FD, UDL, nullptr))
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14954) return ExprError();
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14955)
+008e7bf92343b (Tyker 2020-02-04 19:23:33 +0100 14956) return CheckForImmediateInvocation(MaybeBindToTemporary(UDL), FD);
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14957) }
+c67fdd4eb95f1 (Richard Smith 2012-03-07 08:35:16 +0000 14958)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14959) /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14960) /// given LookupResult is non-empty, it is assumed to describe a member which
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14961) /// will be invoked. Otherwise, the function will be found via argument
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14962) /// dependent lookup.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14963) /// CallExpr is set to a valid expression and FRS_Success returned on success,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14964) /// otherwise CallExpr is set to ExprError() and some non-success value
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14965) /// is returned.
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14966) Sema::ForRangeStatus
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 14967) Sema::BuildForRangeBeginEndCall(SourceLocation Loc,
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 14968) SourceLocation RangeLoc,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14969) const DeclarationNameInfo &NameInfo,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14970) LookupResult &MemberLookup,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14971) OverloadCandidateSet *CandidateSet,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14972) Expr *Range, ExprResult *CallExpr) {
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 14973) Scope *S = nullptr;
+9f690bd80bb67 (Richard Smith 2015-10-27 06:02:45 +0000 14974)
+67ef14fe486e1 (Richard Smith 2017-09-26 18:37:55 +0000 14975) CandidateSet->clear(OverloadCandidateSet::CSK_Normal);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14976) if (!MemberLookup.empty()) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14977) ExprResult MemberRef =
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14978) BuildMemberReferenceExpr(Range, Range->getType(), Loc,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14979) /*IsPtr=*/false, CXXScopeSpec(),
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14980) /*TemplateKWLoc=*/SourceLocation(),
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 14981) /*FirstQualifierInScope=*/nullptr,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14982) MemberLookup,
+6924dcdf6f737 (Aaron Ballman 2015-09-01 14:49:24 +0000 14983) /*TemplateArgs=*/nullptr, S);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14984) if (MemberRef.isInvalid()) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14985) *CallExpr = ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14986) return FRS_DiagnosticIssued;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14987) }
+255b85f03c5db (Richard Smith 2019-05-08 01:36:36 +0000 14988) *CallExpr = BuildCallExpr(S, MemberRef.get(), Loc, None, Loc, nullptr);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14989) if (CallExpr->isInvalid()) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14990) *CallExpr = ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14991) return FRS_DiagnosticIssued;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14992) }
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 14993) } else {
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14994) ExprResult FnR = CreateUnresolvedLookupExpr(/*NamingClass=*/nullptr,
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14995) NestedNameSpecifierLoc(),
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14996) NameInfo, UnresolvedSet<0>());
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14997) if (FnR.isInvalid())
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14998) return FRS_DiagnosticIssued;
+ed5a18fc0399d (Richard Smith 2020-08-06 15:57:35 -0700 14999) UnresolvedLookupExpr *Fn = cast<UnresolvedLookupExpr>(FnR.get());
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15000)
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 15001) bool CandidateSetError = buildOverloadedCallSet(S, Fn, Fn, Range, Loc,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15002) CandidateSet, CallExpr);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15003) if (CandidateSet->empty() || CandidateSetError) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15004) *CallExpr = ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15005) return FRS_NoViableFunction;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15006) }
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15007) OverloadCandidateSet::iterator Best;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15008) OverloadingResult OverloadResult =
+f2ceec4811c35 (Stephen Kelly 2018-08-09 21:08:08 +0000 15009) CandidateSet->BestViableFunction(*this, Fn->getBeginLoc(), Best);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15010)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15011) if (OverloadResult == OR_No_Viable_Function) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15012) *CallExpr = ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15013) return FRS_NoViableFunction;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15014) }
+9c785c217b3f9 (Dmitri Gribenko 2013-05-09 21:02:07 +0000 15015) *CallExpr = FinishOverloadedCallExpr(*this, S, Fn, Fn, Loc, Range,
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 15016) Loc, nullptr, CandidateSet, &Best,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15017) OverloadResult,
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15018) /*AllowTypoCorrection=*/false);
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15019) if (CallExpr->isInvalid() || OverloadResult != OR_Success) {
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15020) *CallExpr = ExprError();
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15021) return FRS_DiagnosticIssued;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15022) }
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15023) }
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15024) return FRS_Success;
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15025) }
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15026)
+0f38443616f50 (Sam Panzer 2012-08-21 00:52:01 +0000 15027)
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15028) /// FixOverloadedFunctionReference - E is an expression that refers to
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15029) /// a C++ overloaded function (possibly with some parentheses and
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15030) /// perhaps a '&' around it). We have resolved the overloaded function
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15031) /// to the function declaration Fn, so patch up the expression E to
+fcb4ab4420793 (Anders Carlsson 2009-10-21 17:16:23 +0000 15032) /// refer (possibly indirectly) to Fn. Returns the new expr.
+a8ae222d0e8ba (John McCall 2010-04-06 21:38:20 +0000 15033) Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15034) FunctionDecl *Fn) {
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15035) if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15036) Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15037) Found, Fn);
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15038) if (SubExpr == PE->getSubExpr())
+c3007a21450f4 (John McCall 2010-10-26 07:05:15 +0000 15039) return PE;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15040)
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15041) return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15042) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15043)
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15044) if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15045) Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15046) Found, Fn);
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15047) assert(Context.hasSameType(ICE->getSubExpr()->getType(),
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15048) SubExpr->getType()) &&
+091f04256a60c (Douglas Gregor 2009-10-23 22:18:25 +0000 15049) "Implicit cast type cannot be determined from overload");
+cf1421650953d (John McCall 2010-08-07 06:22:56 +0000 15050) assert(ICE->path_empty() && "fixing up hierarchy conversion?");
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15051) if (SubExpr == ICE->getSubExpr())
+c3007a21450f4 (John McCall 2010-10-26 07:05:15 +0000 15052) return ICE;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15053)
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 15054) return ImplicitCastExpr::Create(Context, ICE->getType(), ICE->getCastKind(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 15055) SubExpr, nullptr, ICE->getValueKind(),
+f1cd6593da3ad (Serge Pavlov 2020-09-12 21:54:14 +0700 15056) CurFPFeatureOverrides());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15057) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15058)
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15059) if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15060) if (!GSE->isResultDependent()) {
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15061) Expr *SubExpr =
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15062) FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15063) if (SubExpr == GSE->getResultExpr())
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15064) return GSE;
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15065)
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15066) // Replace the resulting type information before rebuilding the generic
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15067) // selection expression.
+8b871d96d780b (Aaron Ballman 2016-09-02 18:31:31 +0000 15068) ArrayRef<Expr *> A = GSE->getAssocExprs();
+8b871d96d780b (Aaron Ballman 2016-09-02 18:31:31 +0000 15069) SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15070) unsigned ResultIdx = GSE->getResultIndex();
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15071) AssocExprs[ResultIdx] = SubExpr;
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15072)
+db07683d866bd (Bruno Ricci 2019-01-26 14:15:10 +0000 15073) return GenericSelectionExpr::Create(
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15074) Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15075) GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15076) GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15077) ResultIdx);
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15078) }
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15079) // Rather than fall through to the unreachable, return the original generic
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15080) // selection expression.
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15081) return GSE;
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15082) }
+ff7bd8bacd130 (Aaron Ballman 2016-09-02 13:45:40 +0000 15083)
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15084) if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
+e302792b6155b (John McCall 2010-08-25 11:45:40 +0000 15085) assert(UnOp->getOpcode() == UO_AddrOf &&
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15086) "Can only take the address of an overloaded function");
+6f233ef1d893d (Douglas Gregor 2009-02-11 01:18:59 +0000 15087) if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
+6f233ef1d893d (Douglas Gregor 2009-02-11 01:18:59 +0000 15088) if (Method->isStatic()) {
+6f233ef1d893d (Douglas Gregor 2009-02-11 01:18:59 +0000 15089) // Do nothing: static member functions aren't any
diff erent
+6f233ef1d893d (Douglas Gregor 2009-02-11 01:18:59 +0000 15090) // from non-member functions.
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15091) } else {
+028ed91127254 (Alp Toker 2013-12-06 17:56:43 +0000 15092) // Fix the subexpression, which really has to be an
+e66edc18ae0fc (John McCall 2009-11-24 19:00:30 +0000 15093) // UnresolvedLookupExpr holding an overloaded member function
+e66edc18ae0fc (John McCall 2009-11-24 19:00:30 +0000 15094) // or template.
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15095) Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15096) Found, Fn);
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15097) if (SubExpr == UnOp->getSubExpr())
+c3007a21450f4 (John McCall 2010-10-26 07:05:15 +0000 15098) return UnOp;
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15099)
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15100) assert(isa<DeclRefExpr>(SubExpr)
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15101) && "fixed to something other than a decl ref");
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15102) assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15103) && "fixed to a member ref with no nested name qualifier");
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15104)
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15105) // We have taken the address of a pointer to member
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15106) // function. Perform the computation here so that we get the
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15107) // appropriate pointer to member type.
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15108) QualType ClassType
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15109) = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15110) QualType MemPtrType
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15111) = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
+02d57cc92cb82 (David Majnemer 2016-06-30 03:02:03 +0000 15112) // Under the MS ABI, lock down the inheritance model now.
+02d57cc92cb82 (David Majnemer 2016-06-30 03:02:03 +0000 15113) if (Context.getTargetInfo().getCXXABI().isMicrosoft())
+02d57cc92cb82 (David Majnemer 2016-06-30 03:02:03 +0000 15114) (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15115)
+f5360d4bb3376 (Melanie Blower 2020-05-01 10:32:06 -0700 15116) return UnaryOperator::Create(
+f5360d4bb3376 (Melanie Blower 2020-05-01 10:32:06 -0700 15117) Context, SubExpr, UO_AddrOf, MemPtrType, VK_RValue, OK_Ordinary,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 15118) UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
+6f233ef1d893d (Douglas Gregor 2009-02-11 01:18:59 +0000 15119) }
+6f233ef1d893d (Douglas Gregor 2009-02-11 01:18:59 +0000 15120) }
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15121) Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
+16df1e59f2bb7 (John McCall 2010-03-30 21:47:33 +0000 15122) Found, Fn);
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15123) if (SubExpr == UnOp->getSubExpr())
+c3007a21450f4 (John McCall 2010-10-26 07:05:15 +0000 15124) return UnOp;
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15125)
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 15126) return UnaryOperator::Create(Context, SubExpr, UO_AddrOf,
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 15127) Context.getPointerType(SubExpr->getType()),
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 15128) VK_RValue, OK_Ordinary, UnOp->getOperatorLoc(),
+f4aaed3bf16b3 (Melanie Blower 2020-06-26 09:23:45 -0700 15129) false, CurFPFeatureOverrides());
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15130) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15131)
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15132) if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15133) // FIXME: avoid copy.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 15134) TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
+e66edc18ae0fc (John McCall 2009-11-24 19:00:30 +0000 15135) if (ULE->hasExplicitTemplateArgs()) {
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15136) ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15137) TemplateArgs = &TemplateArgsBuffer;
+e66edc18ae0fc (John McCall 2009-11-24 19:00:30 +0000 15138) }
+e66edc18ae0fc (John McCall 2009-11-24 19:00:30 +0000 15139)
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15140) DeclRefExpr *DRE =
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15141) BuildDeclRefExpr(Fn, Fn->getType(), VK_LValue, ULE->getNameInfo(),
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15142) ULE->getQualifierLoc(), Found.getDecl(),
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15143) ULE->getTemplateKeywordLoc(), TemplateArgs);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 15144) DRE->setHadMultipleCandidates(ULE->getNumDecls() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 15145) return DRE;
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15146) }
+d14a86427f9cd (John McCall 2009-11-21 08:51:07 +0000 15147)
+10eae1851d3f6 (John McCall 2009-11-30 22:42:35 +0000 15148) if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) {
+6b51f28e82646 (John McCall 2009-11-23 01:53:49 +0000 15149) // FIXME: avoid copy.
+c3ec149bb238c (Craig Topper 2014-05-26 06:22:03 +0000 15150) TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15151) if (MemExpr->hasExplicitTemplateArgs()) {
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15152) MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer);
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15153) TemplateArgs = &TemplateArgsBuffer;
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15154) }
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15155)
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15156) Expr *Base;
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15157)
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 15158) // If we're filling in a static method where we used to have an
+7decc9e4ea6c5 (John McCall 2010-11-18 06:31:45 +0000 15159) // implicit member access, rewrite to a simple decl ref.
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15160) if (MemExpr->isImplicitAccess()) {
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15161) if (cast<CXXMethodDecl>(Fn)->isStatic()) {
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15162) DeclRefExpr *DRE = BuildDeclRefExpr(
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15163) Fn, Fn->getType(), VK_LValue, MemExpr->getNameInfo(),
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15164) MemExpr->getQualifierLoc(), Found.getDecl(),
+7dcd73340ba51 (Richard Smith 2019-06-04 18:30:46 +0000 15165) MemExpr->getTemplateKeywordLoc(), TemplateArgs);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 15166) DRE->setHadMultipleCandidates(MemExpr->getNumDecls() > 1);
+635ed24e1dad8 (Abramo Bagnara 2011-10-05 07:56:41 +0000 15167) return DRE;
+b15af899fb4b4 (Douglas Gregor 2010-01-07 23:12:05 +0000 15168) } else {
+b15af899fb4b4 (Douglas Gregor 2010-01-07 23:12:05 +0000 15169) SourceLocation Loc = MemExpr->getMemberLoc();
+b15af899fb4b4 (Douglas Gregor 2010-01-07 23:12:05 +0000 15170) if (MemExpr->getQualifier())
+0da1d43e1600a (Douglas Gregor 2011-02-28 20:01:57 +0000 15171) Loc = MemExpr->getQualifierLoc().getBeginLoc();
+8458c9ef42390 (Richard Smith 2019-05-24 01:35:07 +0000 15172) Base =
+49a3ad21d6034 (Rui Ueyama 2019-07-16 04:46:31 +0000 15173) BuildCXXThisExpr(Loc, MemExpr->getBaseType(), /*IsImplicit=*/true);
+b15af899fb4b4 (Douglas Gregor 2010-01-07 23:12:05 +0000 15174) }
+2d74de96325e4 (John McCall 2009-12-01 22:10:20 +0000 15175) } else
+c3007a21450f4 (John McCall 2010-10-26 07:05:15 +0000 15176) Base = MemExpr->getBase();
+6b51f28e82646 (John McCall 2009-11-23 01:53:49 +0000 15177)
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15178) ExprValueKind valueKind;
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15179) QualType type;
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15180) if (cast<CXXMethodDecl>(Fn)->isStatic()) {
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15181) valueKind = VK_LValue;
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15182) type = Fn->getType();
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15183) } else {
+4adb38cdf4004 (John McCall 2011-04-27 00:36:17 +0000 15184) valueKind = VK_RValue;
+eba323ab4453b (Yunzhong Gao 2015-05-01 02:04:32 +0000 15185) type = Context.BoundMemberTy;
+eba323ab4453b (Yunzhong Gao 2015-05-01 02:04:32 +0000 15186) }
+eba323ab4453b (Yunzhong Gao 2015-05-01 02:04:32 +0000 15187)
+84be998497669 (Richard Smith 2019-06-06 23:24:18 +0000 15188) return BuildMemberExpr(
+84be998497669 (Richard Smith 2019-06-06 23:24:18 +0000 15189) Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
+eba323ab4453b (Yunzhong Gao 2015-05-01 02:04:32 +0000 15190) MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
+84be998497669 (Richard Smith 2019-06-06 23:24:18 +0000 15191) /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(),
+84be998497669 (Richard Smith 2019-06-06 23:24:18 +0000 15192) type, valueKind, OK_Ordinary, TemplateArgs);
+51c538bee4d75 (Douglas Gregor 2009-11-20 19:42:02 +0000 15193) }
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15194)
+c3007a21450f4 (John McCall 2010-10-26 07:05:15 +0000 15195) llvm_unreachable("Invalid reference to overloaded function");
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15196) }
+cd695e500de7e (Douglas Gregor 2008-11-10 20:40:00 +0000 15197)
+f9cbcc4cc2e26 (NAKAMURA Takumi 2011-01-27 07:10:08 +0000 15198) ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 15199) DeclAccessPair Found,
+dadc575b1e878 (John McCall 2010-08-24 06:29:42 +0000 15200) FunctionDecl *Fn) {
+03ff2596cb161 (Nikola Smiljanic 2014-05-29 14:05:12 +0000 15201) return FixOverloadedFunctionReference(E.get(), Found, Fn);
+3e1e527826048 (Douglas Gregor 2009-12-09 23:02:17 +0000 15202) }
More information about the cfe-commits
mailing list