Bug Summary

File:clang/lib/Sema/SemaOverload.cpp
Warning:line 13515, column 21
Although the value stored to 'RHS' is used in the enclosing expression, the value is never actually read from 'RHS'

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name SemaOverload.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mframe-pointer=none -relaxed-aliasing -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -fno-split-dwarf-inlining -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-12/lib/clang/12.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/build-llvm/tools/clang/lib/Sema -I /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema -I /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/include -I /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/build-llvm/include -I /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/llvm/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-12/lib/clang/12.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/build-llvm/tools/clang/lib/Sema -fdebug-prefix-map=/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b=. -ferror-limit 19 -fvisibility-inlines-hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2020-09-17-195756-12974-1 -x c++ /build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp
1//===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file provides Sema routines for C++ overloading.
10//
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/ASTContext.h"
14#include "clang/AST/CXXInheritance.h"
15#include "clang/AST/DeclObjC.h"
16#include "clang/AST/DependenceFlags.h"
17#include "clang/AST/Expr.h"
18#include "clang/AST/ExprCXX.h"
19#include "clang/AST/ExprObjC.h"
20#include "clang/AST/TypeOrdering.h"
21#include "clang/Basic/Diagnostic.h"
22#include "clang/Basic/DiagnosticOptions.h"
23#include "clang/Basic/PartialDiagnostic.h"
24#include "clang/Basic/SourceManager.h"
25#include "clang/Basic/TargetInfo.h"
26#include "clang/Sema/Initialization.h"
27#include "clang/Sema/Lookup.h"
28#include "clang/Sema/Overload.h"
29#include "clang/Sema/SemaInternal.h"
30#include "clang/Sema/Template.h"
31#include "clang/Sema/TemplateDeduction.h"
32#include "llvm/ADT/DenseSet.h"
33#include "llvm/ADT/Optional.h"
34#include "llvm/ADT/STLExtras.h"
35#include "llvm/ADT/SmallPtrSet.h"
36#include "llvm/ADT/SmallString.h"
37#include <algorithm>
38#include <cstdlib>
39
40using namespace clang;
41using namespace sema;
42
43using AllowedExplicit = Sema::AllowedExplicit;
44
45static bool functionHasPassObjectSizeParams(const FunctionDecl *FD) {
46 return llvm::any_of(FD->parameters(), [](const ParmVarDecl *P) {
47 return P->hasAttr<PassObjectSizeAttr>();
48 });
49}
50
51/// A convenience routine for creating a decayed reference to a function.
52static ExprResult
53CreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, NamedDecl *FoundDecl,
54 const Expr *Base, bool HadMultipleCandidates,
55 SourceLocation Loc = SourceLocation(),
56 const DeclarationNameLoc &LocInfo = DeclarationNameLoc()){
57 if (S.DiagnoseUseOfDecl(FoundDecl, Loc))
58 return ExprError();
59 // If FoundDecl is different from Fn (such as if one is a template
60 // and the other a specialization), make sure DiagnoseUseOfDecl is
61 // called on both.
62 // FIXME: This would be more comprehensively addressed by modifying
63 // DiagnoseUseOfDecl to accept both the FoundDecl and the decl
64 // being used.
65 if (FoundDecl != Fn && S.DiagnoseUseOfDecl(Fn, Loc))
66 return ExprError();
67 DeclRefExpr *DRE = new (S.Context)
68 DeclRefExpr(S.Context, Fn, false, Fn->getType(), VK_LValue, Loc, LocInfo);
69 if (HadMultipleCandidates)
70 DRE->setHadMultipleCandidates(true);
71
72 S.MarkDeclRefReferenced(DRE, Base);
73 if (auto *FPT = DRE->getType()->getAs<FunctionProtoType>()) {
74 if (isUnresolvedExceptionSpec(FPT->getExceptionSpecType())) {
75 S.ResolveExceptionSpec(Loc, FPT);
76 DRE->setType(Fn->getType());
77 }
78 }
79 return S.ImpCastExprToType(DRE, S.Context.getPointerType(DRE->getType()),
80 CK_FunctionToPointerDecay);
81}
82
83static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
84 bool InOverloadResolution,
85 StandardConversionSequence &SCS,
86 bool CStyle,
87 bool AllowObjCWritebackConversion);
88
89static bool IsTransparentUnionStandardConversion(Sema &S, Expr* From,
90 QualType &ToType,
91 bool InOverloadResolution,
92 StandardConversionSequence &SCS,
93 bool CStyle);
94static OverloadingResult
95IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
96 UserDefinedConversionSequence& User,
97 OverloadCandidateSet& Conversions,
98 AllowedExplicit AllowExplicit,
99 bool AllowObjCConversionOnExplicit);
100
101static ImplicitConversionSequence::CompareKind
102CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
103 const StandardConversionSequence& SCS1,
104 const StandardConversionSequence& SCS2);
105
106static ImplicitConversionSequence::CompareKind
107CompareQualificationConversions(Sema &S,
108 const StandardConversionSequence& SCS1,
109 const StandardConversionSequence& SCS2);
110
111static ImplicitConversionSequence::CompareKind
112CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
113 const StandardConversionSequence& SCS1,
114 const StandardConversionSequence& SCS2);
115
116/// GetConversionRank - Retrieve the implicit conversion rank
117/// corresponding to the given implicit conversion kind.
118ImplicitConversionRank clang::GetConversionRank(ImplicitConversionKind Kind) {
119 static const ImplicitConversionRank
120 Rank[(int)ICK_Num_Conversion_Kinds] = {
121 ICR_Exact_Match,
122 ICR_Exact_Match,
123 ICR_Exact_Match,
124 ICR_Exact_Match,
125 ICR_Exact_Match,
126 ICR_Exact_Match,
127 ICR_Promotion,
128 ICR_Promotion,
129 ICR_Promotion,
130 ICR_Conversion,
131 ICR_Conversion,
132 ICR_Conversion,
133 ICR_Conversion,
134 ICR_Conversion,
135 ICR_Conversion,
136 ICR_Conversion,
137 ICR_Conversion,
138 ICR_Conversion,
139 ICR_Conversion,
140 ICR_Conversion,
141 ICR_OCL_Scalar_Widening,
142 ICR_Complex_Real_Conversion,
143 ICR_Conversion,
144 ICR_Conversion,
145 ICR_Writeback_Conversion,
146 ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
147 // it was omitted by the patch that added
148 // ICK_Zero_Event_Conversion
149 ICR_C_Conversion,
150 ICR_C_Conversion_Extension
151 };
152 return Rank[(int)Kind];
153}
154
155/// GetImplicitConversionName - Return the name of this kind of
156/// implicit conversion.
157static const char* GetImplicitConversionName(ImplicitConversionKind Kind) {
158 static const char* const Name[(int)ICK_Num_Conversion_Kinds] = {
159 "No conversion",
160 "Lvalue-to-rvalue",
161 "Array-to-pointer",
162 "Function-to-pointer",
163 "Function pointer conversion",
164 "Qualification",
165 "Integral promotion",
166 "Floating point promotion",
167 "Complex promotion",
168 "Integral conversion",
169 "Floating conversion",
170 "Complex conversion",
171 "Floating-integral conversion",
172 "Pointer conversion",
173 "Pointer-to-member conversion",
174 "Boolean conversion",
175 "Compatible-types conversion",
176 "Derived-to-base conversion",
177 "Vector conversion",
178 "SVE Vector conversion",
179 "Vector splat",
180 "Complex-real conversion",
181 "Block Pointer conversion",
182 "Transparent Union Conversion",
183 "Writeback conversion",
184 "OpenCL Zero Event Conversion",
185 "C specific type conversion",
186 "Incompatible pointer conversion"
187 };
188 return Name[Kind];
189}
190
191/// StandardConversionSequence - Set the standard conversion
192/// sequence to the identity conversion.
193void StandardConversionSequence::setAsIdentityConversion() {
194 First = ICK_Identity;
195 Second = ICK_Identity;
196 Third = ICK_Identity;
197 DeprecatedStringLiteralToCharPtr = false;
198 QualificationIncludesObjCLifetime = false;
199 ReferenceBinding = false;
200 DirectBinding = false;
201 IsLvalueReference = true;
202 BindsToFunctionLvalue = false;
203 BindsToRvalue = false;
204 BindsImplicitObjectArgumentWithoutRefQualifier = false;
205 ObjCLifetimeConversionBinding = false;
206 CopyConstructor = nullptr;
207}
208
209/// getRank - Retrieve the rank of this standard conversion sequence
210/// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the
211/// implicit conversions.
212ImplicitConversionRank StandardConversionSequence::getRank() const {
213 ImplicitConversionRank Rank = ICR_Exact_Match;
214 if (GetConversionRank(First) > Rank)
215 Rank = GetConversionRank(First);
216 if (GetConversionRank(Second) > Rank)
217 Rank = GetConversionRank(Second);
218 if (GetConversionRank(Third) > Rank)
219 Rank = GetConversionRank(Third);
220 return Rank;
221}
222
223/// isPointerConversionToBool - Determines whether this conversion is
224/// a conversion of a pointer or pointer-to-member to bool. This is
225/// used as part of the ranking of standard conversion sequences
226/// (C++ 13.3.3.2p4).
227bool StandardConversionSequence::isPointerConversionToBool() const {
228 // Note that FromType has not necessarily been transformed by the
229 // array-to-pointer or function-to-pointer implicit conversions, so
230 // check for their presence as well as checking whether FromType is
231 // a pointer.
232 if (getToType(1)->isBooleanType() &&
233 (getFromType()->isPointerType() ||
234 getFromType()->isMemberPointerType() ||
235 getFromType()->isObjCObjectPointerType() ||
236 getFromType()->isBlockPointerType() ||
237 First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer))
238 return true;
239
240 return false;
241}
242
243/// isPointerConversionToVoidPointer - Determines whether this
244/// conversion is a conversion of a pointer to a void pointer. This is
245/// used as part of the ranking of standard conversion sequences (C++
246/// 13.3.3.2p4).
247bool
248StandardConversionSequence::
249isPointerConversionToVoidPointer(ASTContext& Context) const {
250 QualType FromType = getFromType();
251 QualType ToType = getToType(1);
252
253 // Note that FromType has not necessarily been transformed by the
254 // array-to-pointer implicit conversion, so check for its presence
255 // and redo the conversion to get a pointer.
256 if (First == ICK_Array_To_Pointer)
257 FromType = Context.getArrayDecayedType(FromType);
258
259 if (Second == ICK_Pointer_Conversion && FromType->isAnyPointerType())
260 if (const PointerType* ToPtrType = ToType->getAs<PointerType>())
261 return ToPtrType->getPointeeType()->isVoidType();
262
263 return false;
264}
265
266/// Skip any implicit casts which could be either part of a narrowing conversion
267/// or after one in an implicit conversion.
268static const Expr *IgnoreNarrowingConversion(ASTContext &Ctx,
269 const Expr *Converted) {
270 // We can have cleanups wrapping the converted expression; these need to be
271 // preserved so that destructors run if necessary.
272 if (auto *EWC = dyn_cast<ExprWithCleanups>(Converted)) {
273 Expr *Inner =
274 const_cast<Expr *>(IgnoreNarrowingConversion(Ctx, EWC->getSubExpr()));
275 return ExprWithCleanups::Create(Ctx, Inner, EWC->cleanupsHaveSideEffects(),
276 EWC->getObjects());
277 }
278
279 while (auto *ICE = dyn_cast<ImplicitCastExpr>(Converted)) {
280 switch (ICE->getCastKind()) {
281 case CK_NoOp:
282 case CK_IntegralCast:
283 case CK_IntegralToBoolean:
284 case CK_IntegralToFloating:
285 case CK_BooleanToSignedIntegral:
286 case CK_FloatingToIntegral:
287 case CK_FloatingToBoolean:
288 case CK_FloatingCast:
289 Converted = ICE->getSubExpr();
290 continue;
291
292 default:
293 return Converted;
294 }
295 }
296
297 return Converted;
298}
299
300/// Check if this standard conversion sequence represents a narrowing
301/// conversion, according to C++11 [dcl.init.list]p7.
302///
303/// \param Ctx The AST context.
304/// \param Converted The result of applying this standard conversion sequence.
305/// \param ConstantValue If this is an NK_Constant_Narrowing conversion, the
306/// value of the expression prior to the narrowing conversion.
307/// \param ConstantType If this is an NK_Constant_Narrowing conversion, the
308/// type of the expression prior to the narrowing conversion.
309/// \param IgnoreFloatToIntegralConversion If true type-narrowing conversions
310/// from floating point types to integral types should be ignored.
311NarrowingKind StandardConversionSequence::getNarrowingKind(
312 ASTContext &Ctx, const Expr *Converted, APValue &ConstantValue,
313 QualType &ConstantType, bool IgnoreFloatToIntegralConversion) const {
314 assert(Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++")((Ctx.getLangOpts().CPlusPlus && "narrowing check outside C++"
) ? static_cast<void> (0) : __assert_fail ("Ctx.getLangOpts().CPlusPlus && \"narrowing check outside C++\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 314, __PRETTY_FUNCTION__))
;
315
316 // C++11 [dcl.init.list]p7:
317 // A narrowing conversion is an implicit conversion ...
318 QualType FromType = getToType(0);
319 QualType ToType = getToType(1);
320
321 // A conversion to an enumeration type is narrowing if the conversion to
322 // the underlying type is narrowing. This only arises for expressions of
323 // the form 'Enum{init}'.
324 if (auto *ET = ToType->getAs<EnumType>())
325 ToType = ET->getDecl()->getIntegerType();
326
327 switch (Second) {
328 // 'bool' is an integral type; dispatch to the right place to handle it.
329 case ICK_Boolean_Conversion:
330 if (FromType->isRealFloatingType())
331 goto FloatingIntegralConversion;
332 if (FromType->isIntegralOrUnscopedEnumerationType())
333 goto IntegralConversion;
334 // -- from a pointer type or pointer-to-member type to bool, or
335 return NK_Type_Narrowing;
336
337 // -- from a floating-point type to an integer type, or
338 //
339 // -- from an integer type or unscoped enumeration type to a floating-point
340 // type, except where the source is a constant expression and the actual
341 // value after conversion will fit into the target type and will produce
342 // the original value when converted back to the original type, or
343 case ICK_Floating_Integral:
344 FloatingIntegralConversion:
345 if (FromType->isRealFloatingType() && ToType->isIntegralType(Ctx)) {
346 return NK_Type_Narrowing;
347 } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
348 ToType->isRealFloatingType()) {
349 if (IgnoreFloatToIntegralConversion)
350 return NK_Not_Narrowing;
351 const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
352 assert(Initializer && "Unknown conversion expression")((Initializer && "Unknown conversion expression") ? static_cast
<void> (0) : __assert_fail ("Initializer && \"Unknown conversion expression\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 352, __PRETTY_FUNCTION__))
;
353
354 // If it's value-dependent, we can't tell whether it's narrowing.
355 if (Initializer->isValueDependent())
356 return NK_Dependent_Narrowing;
357
358 if (Optional<llvm::APSInt> IntConstantValue =
359 Initializer->getIntegerConstantExpr(Ctx)) {
360 // Convert the integer to the floating type.
361 llvm::APFloat Result(Ctx.getFloatTypeSemantics(ToType));
362 Result.convertFromAPInt(*IntConstantValue, IntConstantValue->isSigned(),
363 llvm::APFloat::rmNearestTiesToEven);
364 // And back.
365 llvm::APSInt ConvertedValue = *IntConstantValue;
366 bool ignored;
367 Result.convertToInteger(ConvertedValue,
368 llvm::APFloat::rmTowardZero, &ignored);
369 // If the resulting value is different, this was a narrowing conversion.
370 if (*IntConstantValue != ConvertedValue) {
371 ConstantValue = APValue(*IntConstantValue);
372 ConstantType = Initializer->getType();
373 return NK_Constant_Narrowing;
374 }
375 } else {
376 // Variables are always narrowings.
377 return NK_Variable_Narrowing;
378 }
379 }
380 return NK_Not_Narrowing;
381
382 // -- from long double to double or float, or from double to float, except
383 // where the source is a constant expression and the actual value after
384 // conversion is within the range of values that can be represented (even
385 // if it cannot be represented exactly), or
386 case ICK_Floating_Conversion:
387 if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
388 Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
389 // FromType is larger than ToType.
390 const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
391
392 // If it's value-dependent, we can't tell whether it's narrowing.
393 if (Initializer->isValueDependent())
394 return NK_Dependent_Narrowing;
395
396 if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
397 // Constant!
398 assert(ConstantValue.isFloat())((ConstantValue.isFloat()) ? static_cast<void> (0) : __assert_fail
("ConstantValue.isFloat()", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 398, __PRETTY_FUNCTION__))
;
399 llvm::APFloat FloatVal = ConstantValue.getFloat();
400 // Convert the source value into the target type.
401 bool ignored;
402 llvm::APFloat::opStatus ConvertStatus = FloatVal.convert(
403 Ctx.getFloatTypeSemantics(ToType),
404 llvm::APFloat::rmNearestTiesToEven, &ignored);
405 // If there was no overflow, the source value is within the range of
406 // values that can be represented.
407 if (ConvertStatus & llvm::APFloat::opOverflow) {
408 ConstantType = Initializer->getType();
409 return NK_Constant_Narrowing;
410 }
411 } else {
412 return NK_Variable_Narrowing;
413 }
414 }
415 return NK_Not_Narrowing;
416
417 // -- from an integer type or unscoped enumeration type to an integer type
418 // that cannot represent all the values of the original type, except where
419 // the source is a constant expression and the actual value after
420 // conversion will fit into the target type and will produce the original
421 // value when converted back to the original type.
422 case ICK_Integral_Conversion:
423 IntegralConversion: {
424 assert(FromType->isIntegralOrUnscopedEnumerationType())((FromType->isIntegralOrUnscopedEnumerationType()) ? static_cast
<void> (0) : __assert_fail ("FromType->isIntegralOrUnscopedEnumerationType()"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 424, __PRETTY_FUNCTION__))
;
425 assert(ToType->isIntegralOrUnscopedEnumerationType())((ToType->isIntegralOrUnscopedEnumerationType()) ? static_cast
<void> (0) : __assert_fail ("ToType->isIntegralOrUnscopedEnumerationType()"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 425, __PRETTY_FUNCTION__))
;
426 const bool FromSigned = FromType->isSignedIntegerOrEnumerationType();
427 const unsigned FromWidth = Ctx.getIntWidth(FromType);
428 const bool ToSigned = ToType->isSignedIntegerOrEnumerationType();
429 const unsigned ToWidth = Ctx.getIntWidth(ToType);
430
431 if (FromWidth > ToWidth ||
432 (FromWidth == ToWidth && FromSigned != ToSigned) ||
433 (FromSigned && !ToSigned)) {
434 // Not all values of FromType can be represented in ToType.
435 const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
436
437 // If it's value-dependent, we can't tell whether it's narrowing.
438 if (Initializer->isValueDependent())
439 return NK_Dependent_Narrowing;
440
441 Optional<llvm::APSInt> OptInitializerValue;
442 if (!(OptInitializerValue = Initializer->getIntegerConstantExpr(Ctx))) {
443 // Such conversions on variables are always narrowing.
444 return NK_Variable_Narrowing;
445 }
446 llvm::APSInt &InitializerValue = *OptInitializerValue;
447 bool Narrowing = false;
448 if (FromWidth < ToWidth) {
449 // Negative -> unsigned is narrowing. Otherwise, more bits is never
450 // narrowing.
451 if (InitializerValue.isSigned() && InitializerValue.isNegative())
452 Narrowing = true;
453 } else {
454 // Add a bit to the InitializerValue so we don't have to worry about
455 // signed vs. unsigned comparisons.
456 InitializerValue = InitializerValue.extend(
457 InitializerValue.getBitWidth() + 1);
458 // Convert the initializer to and from the target width and signed-ness.
459 llvm::APSInt ConvertedValue = InitializerValue;
460 ConvertedValue = ConvertedValue.trunc(ToWidth);
461 ConvertedValue.setIsSigned(ToSigned);
462 ConvertedValue = ConvertedValue.extend(InitializerValue.getBitWidth());
463 ConvertedValue.setIsSigned(InitializerValue.isSigned());
464 // If the result is different, this was a narrowing conversion.
465 if (ConvertedValue != InitializerValue)
466 Narrowing = true;
467 }
468 if (Narrowing) {
469 ConstantType = Initializer->getType();
470 ConstantValue = APValue(InitializerValue);
471 return NK_Constant_Narrowing;
472 }
473 }
474 return NK_Not_Narrowing;
475 }
476
477 default:
478 // Other kinds of conversions are not narrowings.
479 return NK_Not_Narrowing;
480 }
481}
482
483/// dump - Print this standard conversion sequence to standard
484/// error. Useful for debugging overloading issues.
485LLVM_DUMP_METHOD__attribute__((noinline)) __attribute__((__used__)) void StandardConversionSequence::dump() const {
486 raw_ostream &OS = llvm::errs();
487 bool PrintedSomething = false;
488 if (First != ICK_Identity) {
489 OS << GetImplicitConversionName(First);
490 PrintedSomething = true;
491 }
492
493 if (Second != ICK_Identity) {
494 if (PrintedSomething) {
495 OS << " -> ";
496 }
497 OS << GetImplicitConversionName(Second);
498
499 if (CopyConstructor) {
500 OS << " (by copy constructor)";
501 } else if (DirectBinding) {
502 OS << " (direct reference binding)";
503 } else if (ReferenceBinding) {
504 OS << " (reference binding)";
505 }
506 PrintedSomething = true;
507 }
508
509 if (Third != ICK_Identity) {
510 if (PrintedSomething) {
511 OS << " -> ";
512 }
513 OS << GetImplicitConversionName(Third);
514 PrintedSomething = true;
515 }
516
517 if (!PrintedSomething) {
518 OS << "No conversions required";
519 }
520}
521
522/// dump - Print this user-defined conversion sequence to standard
523/// error. Useful for debugging overloading issues.
524void UserDefinedConversionSequence::dump() const {
525 raw_ostream &OS = llvm::errs();
526 if (Before.First || Before.Second || Before.Third) {
527 Before.dump();
528 OS << " -> ";
529 }
530 if (ConversionFunction)
531 OS << '\'' << *ConversionFunction << '\'';
532 else
533 OS << "aggregate initialization";
534 if (After.First || After.Second || After.Third) {
535 OS << " -> ";
536 After.dump();
537 }
538}
539
540/// dump - Print this implicit conversion sequence to standard
541/// error. Useful for debugging overloading issues.
542void ImplicitConversionSequence::dump() const {
543 raw_ostream &OS = llvm::errs();
544 if (isStdInitializerListElement())
545 OS << "Worst std::initializer_list element conversion: ";
546 switch (ConversionKind) {
547 case StandardConversion:
548 OS << "Standard conversion: ";
549 Standard.dump();
550 break;
551 case UserDefinedConversion:
552 OS << "User-defined conversion: ";
553 UserDefined.dump();
554 break;
555 case EllipsisConversion:
556 OS << "Ellipsis conversion";
557 break;
558 case AmbiguousConversion:
559 OS << "Ambiguous conversion";
560 break;
561 case BadConversion:
562 OS << "Bad conversion";
563 break;
564 }
565
566 OS << "\n";
567}
568
569void AmbiguousConversionSequence::construct() {
570 new (&conversions()) ConversionSet();
571}
572
573void AmbiguousConversionSequence::destruct() {
574 conversions().~ConversionSet();
575}
576
577void
578AmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) {
579 FromTypePtr = O.FromTypePtr;
580 ToTypePtr = O.ToTypePtr;
581 new (&conversions()) ConversionSet(O.conversions());
582}
583
584namespace {
585 // Structure used by DeductionFailureInfo to store
586 // template argument information.
587 struct DFIArguments {
588 TemplateArgument FirstArg;
589 TemplateArgument SecondArg;
590 };
591 // Structure used by DeductionFailureInfo to store
592 // template parameter and template argument information.
593 struct DFIParamWithArguments : DFIArguments {
594 TemplateParameter Param;
595 };
596 // Structure used by DeductionFailureInfo to store template argument
597 // information and the index of the problematic call argument.
598 struct DFIDeducedMismatchArgs : DFIArguments {
599 TemplateArgumentList *TemplateArgs;
600 unsigned CallArgIndex;
601 };
602 // Structure used by DeductionFailureInfo to store information about
603 // unsatisfied constraints.
604 struct CNSInfo {
605 TemplateArgumentList *TemplateArgs;
606 ConstraintSatisfaction Satisfaction;
607 };
608}
609
610/// Convert from Sema's representation of template deduction information
611/// to the form used in overload-candidate information.
612DeductionFailureInfo
613clang::MakeDeductionFailureInfo(ASTContext &Context,
614 Sema::TemplateDeductionResult TDK,
615 TemplateDeductionInfo &Info) {
616 DeductionFailureInfo Result;
617 Result.Result = static_cast<unsigned>(TDK);
618 Result.HasDiagnostic = false;
619 switch (TDK) {
620 case Sema::TDK_Invalid:
621 case Sema::TDK_InstantiationDepth:
622 case Sema::TDK_TooManyArguments:
623 case Sema::TDK_TooFewArguments:
624 case Sema::TDK_MiscellaneousDeductionFailure:
625 case Sema::TDK_CUDATargetMismatch:
626 Result.Data = nullptr;
627 break;
628
629 case Sema::TDK_Incomplete:
630 case Sema::TDK_InvalidExplicitArguments:
631 Result.Data = Info.Param.getOpaqueValue();
632 break;
633
634 case Sema::TDK_DeducedMismatch:
635 case Sema::TDK_DeducedMismatchNested: {
636 // FIXME: Should allocate from normal heap so that we can free this later.
637 auto *Saved = new (Context) DFIDeducedMismatchArgs;
638 Saved->FirstArg = Info.FirstArg;
639 Saved->SecondArg = Info.SecondArg;
640 Saved->TemplateArgs = Info.take();
641 Saved->CallArgIndex = Info.CallArgIndex;
642 Result.Data = Saved;
643 break;
644 }
645
646 case Sema::TDK_NonDeducedMismatch: {
647 // FIXME: Should allocate from normal heap so that we can free this later.
648 DFIArguments *Saved = new (Context) DFIArguments;
649 Saved->FirstArg = Info.FirstArg;
650 Saved->SecondArg = Info.SecondArg;
651 Result.Data = Saved;
652 break;
653 }
654
655 case Sema::TDK_IncompletePack:
656 // FIXME: It's slightly wasteful to allocate two TemplateArguments for this.
657 case Sema::TDK_Inconsistent:
658 case Sema::TDK_Underqualified: {
659 // FIXME: Should allocate from normal heap so that we can free this later.
660 DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments;
661 Saved->Param = Info.Param;
662 Saved->FirstArg = Info.FirstArg;
663 Saved->SecondArg = Info.SecondArg;
664 Result.Data = Saved;
665 break;
666 }
667
668 case Sema::TDK_SubstitutionFailure:
669 Result.Data = Info.take();
670 if (Info.hasSFINAEDiagnostic()) {
671 PartialDiagnosticAt *Diag = new (Result.Diagnostic) PartialDiagnosticAt(
672 SourceLocation(), PartialDiagnostic::NullDiagnostic());
673 Info.takeSFINAEDiagnostic(*Diag);
674 Result.HasDiagnostic = true;
675 }
676 break;
677
678 case Sema::TDK_ConstraintsNotSatisfied: {
679 CNSInfo *Saved = new (Context) CNSInfo;
680 Saved->TemplateArgs = Info.take();
681 Saved->Satisfaction = Info.AssociatedConstraintsSatisfaction;
682 Result.Data = Saved;
683 break;
684 }
685
686 case Sema::TDK_Success:
687 case Sema::TDK_NonDependentConversionFailure:
688 llvm_unreachable("not a deduction failure")::llvm::llvm_unreachable_internal("not a deduction failure", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 688)
;
689 }
690
691 return Result;
692}
693
694void DeductionFailureInfo::Destroy() {
695 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
696 case Sema::TDK_Success:
697 case Sema::TDK_Invalid:
698 case Sema::TDK_InstantiationDepth:
699 case Sema::TDK_Incomplete:
700 case Sema::TDK_TooManyArguments:
701 case Sema::TDK_TooFewArguments:
702 case Sema::TDK_InvalidExplicitArguments:
703 case Sema::TDK_CUDATargetMismatch:
704 case Sema::TDK_NonDependentConversionFailure:
705 break;
706
707 case Sema::TDK_IncompletePack:
708 case Sema::TDK_Inconsistent:
709 case Sema::TDK_Underqualified:
710 case Sema::TDK_DeducedMismatch:
711 case Sema::TDK_DeducedMismatchNested:
712 case Sema::TDK_NonDeducedMismatch:
713 // FIXME: Destroy the data?
714 Data = nullptr;
715 break;
716
717 case Sema::TDK_SubstitutionFailure:
718 // FIXME: Destroy the template argument list?
719 Data = nullptr;
720 if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
721 Diag->~PartialDiagnosticAt();
722 HasDiagnostic = false;
723 }
724 break;
725
726 case Sema::TDK_ConstraintsNotSatisfied:
727 // FIXME: Destroy the template argument list?
728 Data = nullptr;
729 if (PartialDiagnosticAt *Diag = getSFINAEDiagnostic()) {
730 Diag->~PartialDiagnosticAt();
731 HasDiagnostic = false;
732 }
733 break;
734
735 // Unhandled
736 case Sema::TDK_MiscellaneousDeductionFailure:
737 break;
738 }
739}
740
741PartialDiagnosticAt *DeductionFailureInfo::getSFINAEDiagnostic() {
742 if (HasDiagnostic)
743 return static_cast<PartialDiagnosticAt*>(static_cast<void*>(Diagnostic));
744 return nullptr;
745}
746
747TemplateParameter DeductionFailureInfo::getTemplateParameter() {
748 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
749 case Sema::TDK_Success:
750 case Sema::TDK_Invalid:
751 case Sema::TDK_InstantiationDepth:
752 case Sema::TDK_TooManyArguments:
753 case Sema::TDK_TooFewArguments:
754 case Sema::TDK_SubstitutionFailure:
755 case Sema::TDK_DeducedMismatch:
756 case Sema::TDK_DeducedMismatchNested:
757 case Sema::TDK_NonDeducedMismatch:
758 case Sema::TDK_CUDATargetMismatch:
759 case Sema::TDK_NonDependentConversionFailure:
760 case Sema::TDK_ConstraintsNotSatisfied:
761 return TemplateParameter();
762
763 case Sema::TDK_Incomplete:
764 case Sema::TDK_InvalidExplicitArguments:
765 return TemplateParameter::getFromOpaqueValue(Data);
766
767 case Sema::TDK_IncompletePack:
768 case Sema::TDK_Inconsistent:
769 case Sema::TDK_Underqualified:
770 return static_cast<DFIParamWithArguments*>(Data)->Param;
771
772 // Unhandled
773 case Sema::TDK_MiscellaneousDeductionFailure:
774 break;
775 }
776
777 return TemplateParameter();
778}
779
780TemplateArgumentList *DeductionFailureInfo::getTemplateArgumentList() {
781 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
782 case Sema::TDK_Success:
783 case Sema::TDK_Invalid:
784 case Sema::TDK_InstantiationDepth:
785 case Sema::TDK_TooManyArguments:
786 case Sema::TDK_TooFewArguments:
787 case Sema::TDK_Incomplete:
788 case Sema::TDK_IncompletePack:
789 case Sema::TDK_InvalidExplicitArguments:
790 case Sema::TDK_Inconsistent:
791 case Sema::TDK_Underqualified:
792 case Sema::TDK_NonDeducedMismatch:
793 case Sema::TDK_CUDATargetMismatch:
794 case Sema::TDK_NonDependentConversionFailure:
795 return nullptr;
796
797 case Sema::TDK_DeducedMismatch:
798 case Sema::TDK_DeducedMismatchNested:
799 return static_cast<DFIDeducedMismatchArgs*>(Data)->TemplateArgs;
800
801 case Sema::TDK_SubstitutionFailure:
802 return static_cast<TemplateArgumentList*>(Data);
803
804 case Sema::TDK_ConstraintsNotSatisfied:
805 return static_cast<CNSInfo*>(Data)->TemplateArgs;
806
807 // Unhandled
808 case Sema::TDK_MiscellaneousDeductionFailure:
809 break;
810 }
811
812 return nullptr;
813}
814
815const TemplateArgument *DeductionFailureInfo::getFirstArg() {
816 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
817 case Sema::TDK_Success:
818 case Sema::TDK_Invalid:
819 case Sema::TDK_InstantiationDepth:
820 case Sema::TDK_Incomplete:
821 case Sema::TDK_TooManyArguments:
822 case Sema::TDK_TooFewArguments:
823 case Sema::TDK_InvalidExplicitArguments:
824 case Sema::TDK_SubstitutionFailure:
825 case Sema::TDK_CUDATargetMismatch:
826 case Sema::TDK_NonDependentConversionFailure:
827 case Sema::TDK_ConstraintsNotSatisfied:
828 return nullptr;
829
830 case Sema::TDK_IncompletePack:
831 case Sema::TDK_Inconsistent:
832 case Sema::TDK_Underqualified:
833 case Sema::TDK_DeducedMismatch:
834 case Sema::TDK_DeducedMismatchNested:
835 case Sema::TDK_NonDeducedMismatch:
836 return &static_cast<DFIArguments*>(Data)->FirstArg;
837
838 // Unhandled
839 case Sema::TDK_MiscellaneousDeductionFailure:
840 break;
841 }
842
843 return nullptr;
844}
845
846const TemplateArgument *DeductionFailureInfo::getSecondArg() {
847 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
848 case Sema::TDK_Success:
849 case Sema::TDK_Invalid:
850 case Sema::TDK_InstantiationDepth:
851 case Sema::TDK_Incomplete:
852 case Sema::TDK_IncompletePack:
853 case Sema::TDK_TooManyArguments:
854 case Sema::TDK_TooFewArguments:
855 case Sema::TDK_InvalidExplicitArguments:
856 case Sema::TDK_SubstitutionFailure:
857 case Sema::TDK_CUDATargetMismatch:
858 case Sema::TDK_NonDependentConversionFailure:
859 case Sema::TDK_ConstraintsNotSatisfied:
860 return nullptr;
861
862 case Sema::TDK_Inconsistent:
863 case Sema::TDK_Underqualified:
864 case Sema::TDK_DeducedMismatch:
865 case Sema::TDK_DeducedMismatchNested:
866 case Sema::TDK_NonDeducedMismatch:
867 return &static_cast<DFIArguments*>(Data)->SecondArg;
868
869 // Unhandled
870 case Sema::TDK_MiscellaneousDeductionFailure:
871 break;
872 }
873
874 return nullptr;
875}
876
877llvm::Optional<unsigned> DeductionFailureInfo::getCallArgIndex() {
878 switch (static_cast<Sema::TemplateDeductionResult>(Result)) {
879 case Sema::TDK_DeducedMismatch:
880 case Sema::TDK_DeducedMismatchNested:
881 return static_cast<DFIDeducedMismatchArgs*>(Data)->CallArgIndex;
882
883 default:
884 return llvm::None;
885 }
886}
887
888bool OverloadCandidateSet::OperatorRewriteInfo::shouldAddReversed(
889 OverloadedOperatorKind Op) {
890 if (!AllowRewrittenCandidates)
891 return false;
892 return Op == OO_EqualEqual || Op == OO_Spaceship;
893}
894
895bool OverloadCandidateSet::OperatorRewriteInfo::shouldAddReversed(
896 ASTContext &Ctx, const FunctionDecl *FD) {
897 if (!shouldAddReversed(FD->getDeclName().getCXXOverloadedOperator()))
898 return false;
899 // Don't bother adding a reversed candidate that can never be a better
900 // match than the non-reversed version.
901 return FD->getNumParams() != 2 ||
902 !Ctx.hasSameUnqualifiedType(FD->getParamDecl(0)->getType(),
903 FD->getParamDecl(1)->getType()) ||
904 FD->hasAttr<EnableIfAttr>();
905}
906
907void OverloadCandidateSet::destroyCandidates() {
908 for (iterator i = begin(), e = end(); i != e; ++i) {
909 for (auto &C : i->Conversions)
910 C.~ImplicitConversionSequence();
911 if (!i->Viable && i->FailureKind == ovl_fail_bad_deduction)
912 i->DeductionFailure.Destroy();
913 }
914}
915
916void OverloadCandidateSet::clear(CandidateSetKind CSK) {
917 destroyCandidates();
918 SlabAllocator.Reset();
919 NumInlineBytesUsed = 0;
920 Candidates.clear();
921 Functions.clear();
922 Kind = CSK;
923}
924
925namespace {
926 class UnbridgedCastsSet {
927 struct Entry {
928 Expr **Addr;
929 Expr *Saved;
930 };
931 SmallVector<Entry, 2> Entries;
932
933 public:
934 void save(Sema &S, Expr *&E) {
935 assert(E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast))((E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)) ? static_cast
<void> (0) : __assert_fail ("E->hasPlaceholderType(BuiltinType::ARCUnbridgedCast)"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 935, __PRETTY_FUNCTION__))
;
936 Entry entry = { &E, E };
937 Entries.push_back(entry);
938 E = S.stripARCUnbridgedCast(E);
939 }
940
941 void restore() {
942 for (SmallVectorImpl<Entry>::iterator
943 i = Entries.begin(), e = Entries.end(); i != e; ++i)
944 *i->Addr = i->Saved;
945 }
946 };
947}
948
949/// checkPlaceholderForOverload - Do any interesting placeholder-like
950/// preprocessing on the given expression.
951///
952/// \param unbridgedCasts a collection to which to add unbridged casts;
953/// without this, they will be immediately diagnosed as errors
954///
955/// Return true on unrecoverable error.
956static bool
957checkPlaceholderForOverload(Sema &S, Expr *&E,
958 UnbridgedCastsSet *unbridgedCasts = nullptr) {
959 if (const BuiltinType *placeholder = E->getType()->getAsPlaceholderType()) {
960 // We can't handle overloaded expressions here because overload
961 // resolution might reasonably tweak them.
962 if (placeholder->getKind() == BuiltinType::Overload) return false;
963
964 // If the context potentially accepts unbridged ARC casts, strip
965 // the unbridged cast and add it to the collection for later restoration.
966 if (placeholder->getKind() == BuiltinType::ARCUnbridgedCast &&
967 unbridgedCasts) {
968 unbridgedCasts->save(S, E);
969 return false;
970 }
971
972 // Go ahead and check everything else.
973 ExprResult result = S.CheckPlaceholderExpr(E);
974 if (result.isInvalid())
975 return true;
976
977 E = result.get();
978 return false;
979 }
980
981 // Nothing to do.
982 return false;
983}
984
985/// checkArgPlaceholdersForOverload - Check a set of call operands for
986/// placeholders.
987static bool checkArgPlaceholdersForOverload(Sema &S,
988 MultiExprArg Args,
989 UnbridgedCastsSet &unbridged) {
990 for (unsigned i = 0, e = Args.size(); i != e; ++i)
991 if (checkPlaceholderForOverload(S, Args[i], &unbridged))
992 return true;
993
994 return false;
995}
996
997/// Determine whether the given New declaration is an overload of the
998/// declarations in Old. This routine returns Ovl_Match or Ovl_NonFunction if
999/// New and Old cannot be overloaded, e.g., if New has the same signature as
1000/// some function in Old (C++ 1.3.10) or if the Old declarations aren't
1001/// functions (or function templates) at all. When it does return Ovl_Match or
1002/// Ovl_NonFunction, MatchedDecl will point to the decl that New cannot be
1003/// overloaded with. This decl may be a UsingShadowDecl on top of the underlying
1004/// declaration.
1005///
1006/// Example: Given the following input:
1007///
1008/// void f(int, float); // #1
1009/// void f(int, int); // #2
1010/// int f(int, int); // #3
1011///
1012/// When we process #1, there is no previous declaration of "f", so IsOverload
1013/// will not be used.
1014///
1015/// When we process #2, Old contains only the FunctionDecl for #1. By comparing
1016/// the parameter types, we see that #1 and #2 are overloaded (since they have
1017/// different signatures), so this routine returns Ovl_Overload; MatchedDecl is
1018/// unchanged.
1019///
1020/// When we process #3, Old is an overload set containing #1 and #2. We compare
1021/// the signatures of #3 to #1 (they're overloaded, so we do nothing) and then
1022/// #3 to #2. Since the signatures of #3 and #2 are identical (return types of
1023/// functions are not part of the signature), IsOverload returns Ovl_Match and
1024/// MatchedDecl will be set to point to the FunctionDecl for #2.
1025///
1026/// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced into a class
1027/// by a using declaration. The rules for whether to hide shadow declarations
1028/// ignore some properties which otherwise figure into a function template's
1029/// signature.
1030Sema::OverloadKind
1031Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old,
1032 NamedDecl *&Match, bool NewIsUsingDecl) {
1033 for (LookupResult::iterator I = Old.begin(), E = Old.end();
1034 I != E; ++I) {
1035 NamedDecl *OldD = *I;
1036
1037 bool OldIsUsingDecl = false;
1038 if (isa<UsingShadowDecl>(OldD)) {
1039 OldIsUsingDecl = true;
1040
1041 // We can always introduce two using declarations into the same
1042 // context, even if they have identical signatures.
1043 if (NewIsUsingDecl) continue;
1044
1045 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl();
1046 }
1047
1048 // A using-declaration does not conflict with another declaration
1049 // if one of them is hidden.
1050 if ((OldIsUsingDecl || NewIsUsingDecl) && !isVisible(*I))
1051 continue;
1052
1053 // If either declaration was introduced by a using declaration,
1054 // we'll need to use slightly different rules for matching.
1055 // Essentially, these rules are the normal rules, except that
1056 // function templates hide function templates with different
1057 // return types or template parameter lists.
1058 bool UseMemberUsingDeclRules =
1059 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord() &&
1060 !New->getFriendObjectKind();
1061
1062 if (FunctionDecl *OldF = OldD->getAsFunction()) {
1063 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) {
1064 if (UseMemberUsingDeclRules && OldIsUsingDecl) {
1065 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I));
1066 continue;
1067 }
1068
1069 if (!isa<FunctionTemplateDecl>(OldD) &&
1070 !shouldLinkPossiblyHiddenDecl(*I, New))
1071 continue;
1072
1073 Match = *I;
1074 return Ovl_Match;
1075 }
1076
1077 // Builtins that have custom typechecking or have a reference should
1078 // not be overloadable or redeclarable.
1079 if (!getASTContext().canBuiltinBeRedeclared(OldF)) {
1080 Match = *I;
1081 return Ovl_NonFunction;
1082 }
1083 } else if (isa<UsingDecl>(OldD) || isa<UsingPackDecl>(OldD)) {
1084 // We can overload with these, which can show up when doing
1085 // redeclaration checks for UsingDecls.
1086 assert(Old.getLookupKind() == LookupUsingDeclName)((Old.getLookupKind() == LookupUsingDeclName) ? static_cast<
void> (0) : __assert_fail ("Old.getLookupKind() == LookupUsingDeclName"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1086, __PRETTY_FUNCTION__))
;
1087 } else if (isa<TagDecl>(OldD)) {
1088 // We can always overload with tags by hiding them.
1089 } else if (auto *UUD = dyn_cast<UnresolvedUsingValueDecl>(OldD)) {
1090 // Optimistically assume that an unresolved using decl will
1091 // overload; if it doesn't, we'll have to diagnose during
1092 // template instantiation.
1093 //
1094 // Exception: if the scope is dependent and this is not a class
1095 // member, the using declaration can only introduce an enumerator.
1096 if (UUD->getQualifier()->isDependent() && !UUD->isCXXClassMember()) {
1097 Match = *I;
1098 return Ovl_NonFunction;
1099 }
1100 } else {
1101 // (C++ 13p1):
1102 // Only function declarations can be overloaded; object and type
1103 // declarations cannot be overloaded.
1104 Match = *I;
1105 return Ovl_NonFunction;
1106 }
1107 }
1108
1109 // C++ [temp.friend]p1:
1110 // For a friend function declaration that is not a template declaration:
1111 // -- if the name of the friend is a qualified or unqualified template-id,
1112 // [...], otherwise
1113 // -- if the name of the friend is a qualified-id and a matching
1114 // non-template function is found in the specified class or namespace,
1115 // the friend declaration refers to that function, otherwise,
1116 // -- if the name of the friend is a qualified-id and a matching function
1117 // template is found in the specified class or namespace, the friend
1118 // declaration refers to the deduced specialization of that function
1119 // template, otherwise
1120 // -- the name shall be an unqualified-id [...]
1121 // If we get here for a qualified friend declaration, we've just reached the
1122 // third bullet. If the type of the friend is dependent, skip this lookup
1123 // until instantiation.
1124 if (New->getFriendObjectKind() && New->getQualifier() &&
1125 !New->getDescribedFunctionTemplate() &&
1126 !New->getDependentSpecializationInfo() &&
1127 !New->getType()->isDependentType()) {
1128 LookupResult TemplateSpecResult(LookupResult::Temporary, Old);
1129 TemplateSpecResult.addAllDecls(Old);
1130 if (CheckFunctionTemplateSpecialization(New, nullptr, TemplateSpecResult,
1131 /*QualifiedFriend*/true)) {
1132 New->setInvalidDecl();
1133 return Ovl_Overload;
1134 }
1135
1136 Match = TemplateSpecResult.getAsSingle<FunctionDecl>();
1137 return Ovl_Match;
1138 }
1139
1140 return Ovl_Overload;
1141}
1142
1143bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old,
1144 bool UseMemberUsingDeclRules, bool ConsiderCudaAttrs,
1145 bool ConsiderRequiresClauses) {
1146 // C++ [basic.start.main]p2: This function shall not be overloaded.
1147 if (New->isMain())
1148 return false;
1149
1150 // MSVCRT user defined entry points cannot be overloaded.
1151 if (New->isMSVCRTEntryPoint())
1152 return false;
1153
1154 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate();
1155 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate();
1156
1157 // C++ [temp.fct]p2:
1158 // A function template can be overloaded with other function templates
1159 // and with normal (non-template) functions.
1160 if ((OldTemplate == nullptr) != (NewTemplate == nullptr))
1161 return true;
1162
1163 // Is the function New an overload of the function Old?
1164 QualType OldQType = Context.getCanonicalType(Old->getType());
1165 QualType NewQType = Context.getCanonicalType(New->getType());
1166
1167 // Compare the signatures (C++ 1.3.10) of the two functions to
1168 // determine whether they are overloads. If we find any mismatch
1169 // in the signature, they are overloads.
1170
1171 // If either of these functions is a K&R-style function (no
1172 // prototype), then we consider them to have matching signatures.
1173 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) ||
1174 isa<FunctionNoProtoType>(NewQType.getTypePtr()))
1175 return false;
1176
1177 const FunctionProtoType *OldType = cast<FunctionProtoType>(OldQType);
1178 const FunctionProtoType *NewType = cast<FunctionProtoType>(NewQType);
1179
1180 // The signature of a function includes the types of its
1181 // parameters (C++ 1.3.10), which includes the presence or absence
1182 // of the ellipsis; see C++ DR 357).
1183 if (OldQType != NewQType &&
1184 (OldType->getNumParams() != NewType->getNumParams() ||
1185 OldType->isVariadic() != NewType->isVariadic() ||
1186 !FunctionParamTypesAreEqual(OldType, NewType)))
1187 return true;
1188
1189 // C++ [temp.over.link]p4:
1190 // The signature of a function template consists of its function
1191 // signature, its return type and its template parameter list. The names
1192 // of the template parameters are significant only for establishing the
1193 // relationship between the template parameters and the rest of the
1194 // signature.
1195 //
1196 // We check the return type and template parameter lists for function
1197 // templates first; the remaining checks follow.
1198 //
1199 // However, we don't consider either of these when deciding whether
1200 // a member introduced by a shadow declaration is hidden.
1201 if (!UseMemberUsingDeclRules && NewTemplate &&
1202 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(),
1203 OldTemplate->getTemplateParameters(),
1204 false, TPL_TemplateMatch) ||
1205 !Context.hasSameType(Old->getDeclaredReturnType(),
1206 New->getDeclaredReturnType())))
1207 return true;
1208
1209 // If the function is a class member, its signature includes the
1210 // cv-qualifiers (if any) and ref-qualifier (if any) on the function itself.
1211 //
1212 // As part of this, also check whether one of the member functions
1213 // is static, in which case they are not overloads (C++
1214 // 13.1p2). While not part of the definition of the signature,
1215 // this check is important to determine whether these functions
1216 // can be overloaded.
1217 CXXMethodDecl *OldMethod = dyn_cast<CXXMethodDecl>(Old);
1218 CXXMethodDecl *NewMethod = dyn_cast<CXXMethodDecl>(New);
1219 if (OldMethod && NewMethod &&
1220 !OldMethod->isStatic() && !NewMethod->isStatic()) {
1221 if (OldMethod->getRefQualifier() != NewMethod->getRefQualifier()) {
1222 if (!UseMemberUsingDeclRules &&
1223 (OldMethod->getRefQualifier() == RQ_None ||
1224 NewMethod->getRefQualifier() == RQ_None)) {
1225 // C++0x [over.load]p2:
1226 // - Member function declarations with the same name and the same
1227 // parameter-type-list as well as member function template
1228 // declarations with the same name, the same parameter-type-list, and
1229 // the same template parameter lists cannot be overloaded if any of
1230 // them, but not all, have a ref-qualifier (8.3.5).
1231 Diag(NewMethod->getLocation(), diag::err_ref_qualifier_overload)
1232 << NewMethod->getRefQualifier() << OldMethod->getRefQualifier();
1233 Diag(OldMethod->getLocation(), diag::note_previous_declaration);
1234 }
1235 return true;
1236 }
1237
1238 // We may not have applied the implicit const for a constexpr member
1239 // function yet (because we haven't yet resolved whether this is a static
1240 // or non-static member function). Add it now, on the assumption that this
1241 // is a redeclaration of OldMethod.
1242 auto OldQuals = OldMethod->getMethodQualifiers();
1243 auto NewQuals = NewMethod->getMethodQualifiers();
1244 if (!getLangOpts().CPlusPlus14 && NewMethod->isConstexpr() &&
1245 !isa<CXXConstructorDecl>(NewMethod))
1246 NewQuals.addConst();
1247 // We do not allow overloading based off of '__restrict'.
1248 OldQuals.removeRestrict();
1249 NewQuals.removeRestrict();
1250 if (OldQuals != NewQuals)
1251 return true;
1252 }
1253
1254 // Though pass_object_size is placed on parameters and takes an argument, we
1255 // consider it to be a function-level modifier for the sake of function
1256 // identity. Either the function has one or more parameters with
1257 // pass_object_size or it doesn't.
1258 if (functionHasPassObjectSizeParams(New) !=
1259 functionHasPassObjectSizeParams(Old))
1260 return true;
1261
1262 // enable_if attributes are an order-sensitive part of the signature.
1263 for (specific_attr_iterator<EnableIfAttr>
1264 NewI = New->specific_attr_begin<EnableIfAttr>(),
1265 NewE = New->specific_attr_end<EnableIfAttr>(),
1266 OldI = Old->specific_attr_begin<EnableIfAttr>(),
1267 OldE = Old->specific_attr_end<EnableIfAttr>();
1268 NewI != NewE || OldI != OldE; ++NewI, ++OldI) {
1269 if (NewI == NewE || OldI == OldE)
1270 return true;
1271 llvm::FoldingSetNodeID NewID, OldID;
1272 NewI->getCond()->Profile(NewID, Context, true);
1273 OldI->getCond()->Profile(OldID, Context, true);
1274 if (NewID != OldID)
1275 return true;
1276 }
1277
1278 if (getLangOpts().CUDA && ConsiderCudaAttrs) {
1279 // Don't allow overloading of destructors. (In theory we could, but it
1280 // would be a giant change to clang.)
1281 if (!isa<CXXDestructorDecl>(New)) {
1282 CUDAFunctionTarget NewTarget = IdentifyCUDATarget(New),
1283 OldTarget = IdentifyCUDATarget(Old);
1284 if (NewTarget != CFT_InvalidTarget) {
1285 assert((OldTarget != CFT_InvalidTarget) &&(((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target."
) ? static_cast<void> (0) : __assert_fail ("(OldTarget != CFT_InvalidTarget) && \"Unexpected invalid target.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1286, __PRETTY_FUNCTION__))
1286 "Unexpected invalid target.")(((OldTarget != CFT_InvalidTarget) && "Unexpected invalid target."
) ? static_cast<void> (0) : __assert_fail ("(OldTarget != CFT_InvalidTarget) && \"Unexpected invalid target.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1286, __PRETTY_FUNCTION__))
;
1287
1288 // Allow overloading of functions with same signature and different CUDA
1289 // target attributes.
1290 if (NewTarget != OldTarget)
1291 return true;
1292 }
1293 }
1294 }
1295
1296 if (ConsiderRequiresClauses) {
1297 Expr *NewRC = New->getTrailingRequiresClause(),
1298 *OldRC = Old->getTrailingRequiresClause();
1299 if ((NewRC != nullptr) != (OldRC != nullptr))
1300 // RC are most certainly different - these are overloads.
1301 return true;
1302
1303 if (NewRC) {
1304 llvm::FoldingSetNodeID NewID, OldID;
1305 NewRC->Profile(NewID, Context, /*Canonical=*/true);
1306 OldRC->Profile(OldID, Context, /*Canonical=*/true);
1307 if (NewID != OldID)
1308 // RCs are not equivalent - these are overloads.
1309 return true;
1310 }
1311 }
1312
1313 // The signatures match; this is not an overload.
1314 return false;
1315}
1316
1317/// Tries a user-defined conversion from From to ToType.
1318///
1319/// Produces an implicit conversion sequence for when a standard conversion
1320/// is not an option. See TryImplicitConversion for more information.
1321static ImplicitConversionSequence
1322TryUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
1323 bool SuppressUserConversions,
1324 AllowedExplicit AllowExplicit,
1325 bool InOverloadResolution,
1326 bool CStyle,
1327 bool AllowObjCWritebackConversion,
1328 bool AllowObjCConversionOnExplicit) {
1329 ImplicitConversionSequence ICS;
1330
1331 if (SuppressUserConversions) {
1332 // We're not in the case above, so there is no conversion that
1333 // we can perform.
1334 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1335 return ICS;
1336 }
1337
1338 // Attempt user-defined conversion.
1339 OverloadCandidateSet Conversions(From->getExprLoc(),
1340 OverloadCandidateSet::CSK_Normal);
1341 switch (IsUserDefinedConversion(S, From, ToType, ICS.UserDefined,
1342 Conversions, AllowExplicit,
1343 AllowObjCConversionOnExplicit)) {
1344 case OR_Success:
1345 case OR_Deleted:
1346 ICS.setUserDefined();
1347 // C++ [over.ics.user]p4:
1348 // A conversion of an expression of class type to the same class
1349 // type is given Exact Match rank, and a conversion of an
1350 // expression of class type to a base class of that type is
1351 // given Conversion rank, in spite of the fact that a copy
1352 // constructor (i.e., a user-defined conversion function) is
1353 // called for those cases.
1354 if (CXXConstructorDecl *Constructor
1355 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) {
1356 QualType FromCanon
1357 = S.Context.getCanonicalType(From->getType().getUnqualifiedType());
1358 QualType ToCanon
1359 = S.Context.getCanonicalType(ToType).getUnqualifiedType();
1360 if (Constructor->isCopyConstructor() &&
1361 (FromCanon == ToCanon ||
1362 S.IsDerivedFrom(From->getBeginLoc(), FromCanon, ToCanon))) {
1363 // Turn this into a "standard" conversion sequence, so that it
1364 // gets ranked with standard conversion sequences.
1365 DeclAccessPair Found = ICS.UserDefined.FoundConversionFunction;
1366 ICS.setStandard();
1367 ICS.Standard.setAsIdentityConversion();
1368 ICS.Standard.setFromType(From->getType());
1369 ICS.Standard.setAllToTypes(ToType);
1370 ICS.Standard.CopyConstructor = Constructor;
1371 ICS.Standard.FoundCopyConstructor = Found;
1372 if (ToCanon != FromCanon)
1373 ICS.Standard.Second = ICK_Derived_To_Base;
1374 }
1375 }
1376 break;
1377
1378 case OR_Ambiguous:
1379 ICS.setAmbiguous();
1380 ICS.Ambiguous.setFromType(From->getType());
1381 ICS.Ambiguous.setToType(ToType);
1382 for (OverloadCandidateSet::iterator Cand = Conversions.begin();
1383 Cand != Conversions.end(); ++Cand)
1384 if (Cand->Best)
1385 ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
1386 break;
1387
1388 // Fall through.
1389 case OR_No_Viable_Function:
1390 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1391 break;
1392 }
1393
1394 return ICS;
1395}
1396
1397/// TryImplicitConversion - Attempt to perform an implicit conversion
1398/// from the given expression (Expr) to the given type (ToType). This
1399/// function returns an implicit conversion sequence that can be used
1400/// to perform the initialization. Given
1401///
1402/// void f(float f);
1403/// void g(int i) { f(i); }
1404///
1405/// this routine would produce an implicit conversion sequence to
1406/// describe the initialization of f from i, which will be a standard
1407/// conversion sequence containing an lvalue-to-rvalue conversion (C++
1408/// 4.1) followed by a floating-integral conversion (C++ 4.9).
1409//
1410/// Note that this routine only determines how the conversion can be
1411/// performed; it does not actually perform the conversion. As such,
1412/// it will not produce any diagnostics if no conversion is available,
1413/// but will instead return an implicit conversion sequence of kind
1414/// "BadConversion".
1415///
1416/// If @p SuppressUserConversions, then user-defined conversions are
1417/// not permitted.
1418/// If @p AllowExplicit, then explicit user-defined conversions are
1419/// permitted.
1420///
1421/// \param AllowObjCWritebackConversion Whether we allow the Objective-C
1422/// writeback conversion, which allows __autoreleasing id* parameters to
1423/// be initialized with __strong id* or __weak id* arguments.
1424static ImplicitConversionSequence
1425TryImplicitConversion(Sema &S, Expr *From, QualType ToType,
1426 bool SuppressUserConversions,
1427 AllowedExplicit AllowExplicit,
1428 bool InOverloadResolution,
1429 bool CStyle,
1430 bool AllowObjCWritebackConversion,
1431 bool AllowObjCConversionOnExplicit) {
1432 ImplicitConversionSequence ICS;
1433 if (IsStandardConversion(S, From, ToType, InOverloadResolution,
1434 ICS.Standard, CStyle, AllowObjCWritebackConversion)){
1435 ICS.setStandard();
1436 return ICS;
1437 }
1438
1439 if (!S.getLangOpts().CPlusPlus) {
1440 ICS.setBad(BadConversionSequence::no_conversion, From, ToType);
1441 return ICS;
1442 }
1443
1444 // C++ [over.ics.user]p4:
1445 // A conversion of an expression of class type to the same class
1446 // type is given Exact Match rank, and a conversion of an
1447 // expression of class type to a base class of that type is
1448 // given Conversion rank, in spite of the fact that a copy/move
1449 // constructor (i.e., a user-defined conversion function) is
1450 // called for those cases.
1451 QualType FromType = From->getType();
1452 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() &&
1453 (S.Context.hasSameUnqualifiedType(FromType, ToType) ||
1454 S.IsDerivedFrom(From->getBeginLoc(), FromType, ToType))) {
1455 ICS.setStandard();
1456 ICS.Standard.setAsIdentityConversion();
1457 ICS.Standard.setFromType(FromType);
1458 ICS.Standard.setAllToTypes(ToType);
1459
1460 // We don't actually check at this point whether there is a valid
1461 // copy/move constructor, since overloading just assumes that it
1462 // exists. When we actually perform initialization, we'll find the
1463 // appropriate constructor to copy the returned object, if needed.
1464 ICS.Standard.CopyConstructor = nullptr;
1465
1466 // Determine whether this is considered a derived-to-base conversion.
1467 if (!S.Context.hasSameUnqualifiedType(FromType, ToType))
1468 ICS.Standard.Second = ICK_Derived_To_Base;
1469
1470 return ICS;
1471 }
1472
1473 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
1474 AllowExplicit, InOverloadResolution, CStyle,
1475 AllowObjCWritebackConversion,
1476 AllowObjCConversionOnExplicit);
1477}
1478
1479ImplicitConversionSequence
1480Sema::TryImplicitConversion(Expr *From, QualType ToType,
1481 bool SuppressUserConversions,
1482 AllowedExplicit AllowExplicit,
1483 bool InOverloadResolution,
1484 bool CStyle,
1485 bool AllowObjCWritebackConversion) {
1486 return ::TryImplicitConversion(*this, From, ToType, SuppressUserConversions,
1487 AllowExplicit, InOverloadResolution, CStyle,
1488 AllowObjCWritebackConversion,
1489 /*AllowObjCConversionOnExplicit=*/false);
1490}
1491
1492/// PerformImplicitConversion - Perform an implicit conversion of the
1493/// expression From to the type ToType. Returns the
1494/// converted expression. Flavor is the kind of conversion we're
1495/// performing, used in the error message. If @p AllowExplicit,
1496/// explicit user-defined conversions are permitted.
1497ExprResult Sema::PerformImplicitConversion(Expr *From, QualType ToType,
1498 AssignmentAction Action,
1499 bool AllowExplicit) {
1500 if (checkPlaceholderForOverload(*this, From))
1501 return ExprError();
1502
1503 // Objective-C ARC: Determine whether we will allow the writeback conversion.
1504 bool AllowObjCWritebackConversion
1505 = getLangOpts().ObjCAutoRefCount &&
1506 (Action == AA_Passing || Action == AA_Sending);
1507 if (getLangOpts().ObjC)
1508 CheckObjCBridgeRelatedConversions(From->getBeginLoc(), ToType,
1509 From->getType(), From);
1510 ImplicitConversionSequence ICS = ::TryImplicitConversion(
1511 *this, From, ToType,
1512 /*SuppressUserConversions=*/false,
1513 AllowExplicit ? AllowedExplicit::All : AllowedExplicit::None,
1514 /*InOverloadResolution=*/false,
1515 /*CStyle=*/false, AllowObjCWritebackConversion,
1516 /*AllowObjCConversionOnExplicit=*/false);
1517 return PerformImplicitConversion(From, ToType, ICS, Action);
1518}
1519
1520/// Determine whether the conversion from FromType to ToType is a valid
1521/// conversion that strips "noexcept" or "noreturn" off the nested function
1522/// type.
1523bool Sema::IsFunctionConversion(QualType FromType, QualType ToType,
1524 QualType &ResultTy) {
1525 if (Context.hasSameUnqualifiedType(FromType, ToType))
1526 return false;
1527
1528 // Permit the conversion F(t __attribute__((noreturn))) -> F(t)
1529 // or F(t noexcept) -> F(t)
1530 // where F adds one of the following at most once:
1531 // - a pointer
1532 // - a member pointer
1533 // - a block pointer
1534 // Changes here need matching changes in FindCompositePointerType.
1535 CanQualType CanTo = Context.getCanonicalType(ToType);
1536 CanQualType CanFrom = Context.getCanonicalType(FromType);
1537 Type::TypeClass TyClass = CanTo->getTypeClass();
1538 if (TyClass != CanFrom->getTypeClass()) return false;
1539 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto) {
1540 if (TyClass == Type::Pointer) {
1541 CanTo = CanTo.castAs<PointerType>()->getPointeeType();
1542 CanFrom = CanFrom.castAs<PointerType>()->getPointeeType();
1543 } else if (TyClass == Type::BlockPointer) {
1544 CanTo = CanTo.castAs<BlockPointerType>()->getPointeeType();
1545 CanFrom = CanFrom.castAs<BlockPointerType>()->getPointeeType();
1546 } else if (TyClass == Type::MemberPointer) {
1547 auto ToMPT = CanTo.castAs<MemberPointerType>();
1548 auto FromMPT = CanFrom.castAs<MemberPointerType>();
1549 // A function pointer conversion cannot change the class of the function.
1550 if (ToMPT->getClass() != FromMPT->getClass())
1551 return false;
1552 CanTo = ToMPT->getPointeeType();
1553 CanFrom = FromMPT->getPointeeType();
1554 } else {
1555 return false;
1556 }
1557
1558 TyClass = CanTo->getTypeClass();
1559 if (TyClass != CanFrom->getTypeClass()) return false;
1560 if (TyClass != Type::FunctionProto && TyClass != Type::FunctionNoProto)
1561 return false;
1562 }
1563
1564 const auto *FromFn = cast<FunctionType>(CanFrom);
1565 FunctionType::ExtInfo FromEInfo = FromFn->getExtInfo();
1566
1567 const auto *ToFn = cast<FunctionType>(CanTo);
1568 FunctionType::ExtInfo ToEInfo = ToFn->getExtInfo();
1569
1570 bool Changed = false;
1571
1572 // Drop 'noreturn' if not present in target type.
1573 if (FromEInfo.getNoReturn() && !ToEInfo.getNoReturn()) {
1574 FromFn = Context.adjustFunctionType(FromFn, FromEInfo.withNoReturn(false));
1575 Changed = true;
1576 }
1577
1578 // Drop 'noexcept' if not present in target type.
1579 if (const auto *FromFPT = dyn_cast<FunctionProtoType>(FromFn)) {
1580 const auto *ToFPT = cast<FunctionProtoType>(ToFn);
1581 if (FromFPT->isNothrow() && !ToFPT->isNothrow()) {
1582 FromFn = cast<FunctionType>(
1583 Context.getFunctionTypeWithExceptionSpec(QualType(FromFPT, 0),
1584 EST_None)
1585 .getTypePtr());
1586 Changed = true;
1587 }
1588
1589 // Convert FromFPT's ExtParameterInfo if necessary. The conversion is valid
1590 // only if the ExtParameterInfo lists of the two function prototypes can be
1591 // merged and the merged list is identical to ToFPT's ExtParameterInfo list.
1592 SmallVector<FunctionProtoType::ExtParameterInfo, 4> NewParamInfos;
1593 bool CanUseToFPT, CanUseFromFPT;
1594 if (Context.mergeExtParameterInfo(ToFPT, FromFPT, CanUseToFPT,
1595 CanUseFromFPT, NewParamInfos) &&
1596 CanUseToFPT && !CanUseFromFPT) {
1597 FunctionProtoType::ExtProtoInfo ExtInfo = FromFPT->getExtProtoInfo();
1598 ExtInfo.ExtParameterInfos =
1599 NewParamInfos.empty() ? nullptr : NewParamInfos.data();
1600 QualType QT = Context.getFunctionType(FromFPT->getReturnType(),
1601 FromFPT->getParamTypes(), ExtInfo);
1602 FromFn = QT->getAs<FunctionType>();
1603 Changed = true;
1604 }
1605 }
1606
1607 if (!Changed)
1608 return false;
1609
1610 assert(QualType(FromFn, 0).isCanonical())((QualType(FromFn, 0).isCanonical()) ? static_cast<void>
(0) : __assert_fail ("QualType(FromFn, 0).isCanonical()", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1610, __PRETTY_FUNCTION__))
;
1611 if (QualType(FromFn, 0) != CanTo) return false;
1612
1613 ResultTy = ToType;
1614 return true;
1615}
1616
1617/// Determine whether the conversion from FromType to ToType is a valid
1618/// vector conversion.
1619///
1620/// \param ICK Will be set to the vector conversion kind, if this is a vector
1621/// conversion.
1622static bool IsVectorConversion(Sema &S, QualType FromType,
1623 QualType ToType, ImplicitConversionKind &ICK) {
1624 // We need at least one of these types to be a vector type to have a vector
1625 // conversion.
1626 if (!ToType->isVectorType() && !FromType->isVectorType())
1627 return false;
1628
1629 // Identical types require no conversions.
1630 if (S.Context.hasSameUnqualifiedType(FromType, ToType))
1631 return false;
1632
1633 // There are no conversions between extended vector types, only identity.
1634 if (ToType->isExtVectorType()) {
1635 // There are no conversions between extended vector types other than the
1636 // identity conversion.
1637 if (FromType->isExtVectorType())
1638 return false;
1639
1640 // Vector splat from any arithmetic type to a vector.
1641 if (FromType->isArithmeticType()) {
1642 ICK = ICK_Vector_Splat;
1643 return true;
1644 }
1645 }
1646
1647 if ((ToType->isSizelessBuiltinType() || FromType->isSizelessBuiltinType()) &&
1648 S.Context.areCompatibleSveTypes(FromType, ToType)) {
1649 ICK = ICK_SVE_Vector_Conversion;
1650 return true;
1651 }
1652
1653 // We can perform the conversion between vector types in the following cases:
1654 // 1)vector types are equivalent AltiVec and GCC vector types
1655 // 2)lax vector conversions are permitted and the vector types are of the
1656 // same size
1657 // 3)the destination type does not have the ARM MVE strict-polymorphism
1658 // attribute, which inhibits lax vector conversion for overload resolution
1659 // only
1660 if (ToType->isVectorType() && FromType->isVectorType()) {
1661 if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
1662 (S.isLaxVectorConversion(FromType, ToType) &&
1663 !ToType->hasAttr(attr::ArmMveStrictPolymorphism))) {
1664 ICK = ICK_Vector_Conversion;
1665 return true;
1666 }
1667 }
1668
1669 return false;
1670}
1671
1672static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
1673 bool InOverloadResolution,
1674 StandardConversionSequence &SCS,
1675 bool CStyle);
1676
1677/// IsStandardConversion - Determines whether there is a standard
1678/// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the
1679/// expression From to the type ToType. Standard conversion sequences
1680/// only consider non-class types; for conversions that involve class
1681/// types, use TryImplicitConversion. If a conversion exists, SCS will
1682/// contain the standard conversion sequence required to perform this
1683/// conversion and this routine will return true. Otherwise, this
1684/// routine will return false and the value of SCS is unspecified.
1685static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType,
1686 bool InOverloadResolution,
1687 StandardConversionSequence &SCS,
1688 bool CStyle,
1689 bool AllowObjCWritebackConversion) {
1690 QualType FromType = From->getType();
1691
1692 // Standard conversions (C++ [conv])
1693 SCS.setAsIdentityConversion();
1694 SCS.IncompatibleObjC = false;
1695 SCS.setFromType(FromType);
1696 SCS.CopyConstructor = nullptr;
1697
1698 // There are no standard conversions for class types in C++, so
1699 // abort early. When overloading in C, however, we do permit them.
1700 if (S.getLangOpts().CPlusPlus &&
1701 (FromType->isRecordType() || ToType->isRecordType()))
1702 return false;
1703
1704 // The first conversion can be an lvalue-to-rvalue conversion,
1705 // array-to-pointer conversion, or function-to-pointer conversion
1706 // (C++ 4p1).
1707
1708 if (FromType == S.Context.OverloadTy) {
1709 DeclAccessPair AccessPair;
1710 if (FunctionDecl *Fn
1711 = S.ResolveAddressOfOverloadedFunction(From, ToType, false,
1712 AccessPair)) {
1713 // We were able to resolve the address of the overloaded function,
1714 // so we can convert to the type of that function.
1715 FromType = Fn->getType();
1716 SCS.setFromType(FromType);
1717
1718 // we can sometimes resolve &foo<int> regardless of ToType, so check
1719 // if the type matches (identity) or we are converting to bool
1720 if (!S.Context.hasSameUnqualifiedType(
1721 S.ExtractUnqualifiedFunctionType(ToType), FromType)) {
1722 QualType resultTy;
1723 // if the function type matches except for [[noreturn]], it's ok
1724 if (!S.IsFunctionConversion(FromType,
1725 S.ExtractUnqualifiedFunctionType(ToType), resultTy))
1726 // otherwise, only a boolean conversion is standard
1727 if (!ToType->isBooleanType())
1728 return false;
1729 }
1730
1731 // Check if the "from" expression is taking the address of an overloaded
1732 // function and recompute the FromType accordingly. Take advantage of the
1733 // fact that non-static member functions *must* have such an address-of
1734 // expression.
1735 CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn);
1736 if (Method && !Method->isStatic()) {
1737 assert(isa<UnaryOperator>(From->IgnoreParens()) &&((isa<UnaryOperator>(From->IgnoreParens()) &&
"Non-unary operator on non-static member address") ? static_cast
<void> (0) : __assert_fail ("isa<UnaryOperator>(From->IgnoreParens()) && \"Non-unary operator on non-static member address\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1738, __PRETTY_FUNCTION__))
1738 "Non-unary operator on non-static member address")((isa<UnaryOperator>(From->IgnoreParens()) &&
"Non-unary operator on non-static member address") ? static_cast
<void> (0) : __assert_fail ("isa<UnaryOperator>(From->IgnoreParens()) && \"Non-unary operator on non-static member address\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1738, __PRETTY_FUNCTION__))
;
1739 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode()((cast<UnaryOperator>(From->IgnoreParens())->getOpcode
() == UO_AddrOf && "Non-address-of operator on non-static member address"
) ? static_cast<void> (0) : __assert_fail ("cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == UO_AddrOf && \"Non-address-of operator on non-static member address\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1741, __PRETTY_FUNCTION__))
1740 == UO_AddrOf &&((cast<UnaryOperator>(From->IgnoreParens())->getOpcode
() == UO_AddrOf && "Non-address-of operator on non-static member address"
) ? static_cast<void> (0) : __assert_fail ("cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == UO_AddrOf && \"Non-address-of operator on non-static member address\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1741, __PRETTY_FUNCTION__))
1741 "Non-address-of operator on non-static member address")((cast<UnaryOperator>(From->IgnoreParens())->getOpcode
() == UO_AddrOf && "Non-address-of operator on non-static member address"
) ? static_cast<void> (0) : __assert_fail ("cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == UO_AddrOf && \"Non-address-of operator on non-static member address\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1741, __PRETTY_FUNCTION__))
;
1742 const Type *ClassType
1743 = S.Context.getTypeDeclType(Method->getParent()).getTypePtr();
1744 FromType = S.Context.getMemberPointerType(FromType, ClassType);
1745 } else if (isa<UnaryOperator>(From->IgnoreParens())) {
1746 assert(cast<UnaryOperator>(From->IgnoreParens())->getOpcode() ==((cast<UnaryOperator>(From->IgnoreParens())->getOpcode
() == UO_AddrOf && "Non-address-of operator for overloaded function expression"
) ? static_cast<void> (0) : __assert_fail ("cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == UO_AddrOf && \"Non-address-of operator for overloaded function expression\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1748, __PRETTY_FUNCTION__))
1747 UO_AddrOf &&((cast<UnaryOperator>(From->IgnoreParens())->getOpcode
() == UO_AddrOf && "Non-address-of operator for overloaded function expression"
) ? static_cast<void> (0) : __assert_fail ("cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == UO_AddrOf && \"Non-address-of operator for overloaded function expression\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1748, __PRETTY_FUNCTION__))
1748 "Non-address-of operator for overloaded function expression")((cast<UnaryOperator>(From->IgnoreParens())->getOpcode
() == UO_AddrOf && "Non-address-of operator for overloaded function expression"
) ? static_cast<void> (0) : __assert_fail ("cast<UnaryOperator>(From->IgnoreParens())->getOpcode() == UO_AddrOf && \"Non-address-of operator for overloaded function expression\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1748, __PRETTY_FUNCTION__))
;
1749 FromType = S.Context.getPointerType(FromType);
1750 }
1751
1752 // Check that we've computed the proper type after overload resolution.
1753 // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
1754 // be calling it from within an NDEBUG block.
1755 assert(S.Context.hasSameType(((S.Context.hasSameType( FromType, S.FixOverloadedFunctionReference
(From, AccessPair, Fn)->getType())) ? static_cast<void>
(0) : __assert_fail ("S.Context.hasSameType( FromType, S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType())"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1757, __PRETTY_FUNCTION__))
1756 FromType,((S.Context.hasSameType( FromType, S.FixOverloadedFunctionReference
(From, AccessPair, Fn)->getType())) ? static_cast<void>
(0) : __assert_fail ("S.Context.hasSameType( FromType, S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType())"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1757, __PRETTY_FUNCTION__))
1757 S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()))((S.Context.hasSameType( FromType, S.FixOverloadedFunctionReference
(From, AccessPair, Fn)->getType())) ? static_cast<void>
(0) : __assert_fail ("S.Context.hasSameType( FromType, S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType())"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 1757, __PRETTY_FUNCTION__))
;
1758 } else {
1759 return false;
1760 }
1761 }
1762 // Lvalue-to-rvalue conversion (C++11 4.1):
1763 // A glvalue (3.10) of a non-function, non-array type T can
1764 // be converted to a prvalue.
1765 bool argIsLValue = From->isGLValue();
1766 if (argIsLValue &&
1767 !FromType->isFunctionType() && !FromType->isArrayType() &&
1768 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) {
1769 SCS.First = ICK_Lvalue_To_Rvalue;
1770
1771 // C11 6.3.2.1p2:
1772 // ... if the lvalue has atomic type, the value has the non-atomic version
1773 // of the type of the lvalue ...
1774 if (const AtomicType *Atomic = FromType->getAs<AtomicType>())
1775 FromType = Atomic->getValueType();
1776
1777 // If T is a non-class type, the type of the rvalue is the
1778 // cv-unqualified version of T. Otherwise, the type of the rvalue
1779 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we
1780 // just strip the qualifiers because they don't matter.
1781 FromType = FromType.getUnqualifiedType();
1782 } else if (FromType->isArrayType()) {
1783 // Array-to-pointer conversion (C++ 4.2)
1784 SCS.First = ICK_Array_To_Pointer;
1785
1786 // An lvalue or rvalue of type "array of N T" or "array of unknown
1787 // bound of T" can be converted to an rvalue of type "pointer to
1788 // T" (C++ 4.2p1).
1789 FromType = S.Context.getArrayDecayedType(FromType);
1790
1791 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) {
1792 // This conversion is deprecated in C++03 (D.4)
1793 SCS.DeprecatedStringLiteralToCharPtr = true;
1794
1795 // For the purpose of ranking in overload resolution
1796 // (13.3.3.1.1), this conversion is considered an
1797 // array-to-pointer conversion followed by a qualification
1798 // conversion (4.4). (C++ 4.2p2)
1799 SCS.Second = ICK_Identity;
1800 SCS.Third = ICK_Qualification;
1801 SCS.QualificationIncludesObjCLifetime = false;
1802 SCS.setAllToTypes(FromType);
1803 return true;
1804 }
1805 } else if (FromType->isFunctionType() && argIsLValue) {
1806 // Function-to-pointer conversion (C++ 4.3).
1807 SCS.First = ICK_Function_To_Pointer;
1808
1809 if (auto *DRE = dyn_cast<DeclRefExpr>(From->IgnoreParenCasts()))
1810 if (auto *FD = dyn_cast<FunctionDecl>(DRE->getDecl()))
1811 if (!S.checkAddressOfFunctionIsAvailable(FD))
1812 return false;
1813
1814 // An lvalue of function type T can be converted to an rvalue of
1815 // type "pointer to T." The result is a pointer to the
1816 // function. (C++ 4.3p1).
1817 FromType = S.Context.getPointerType(FromType);
1818 } else {
1819 // We don't require any conversions for the first step.
1820 SCS.First = ICK_Identity;
1821 }
1822 SCS.setToType(0, FromType);
1823
1824 // The second conversion can be an integral promotion, floating
1825 // point promotion, integral conversion, floating point conversion,
1826 // floating-integral conversion, pointer conversion,
1827 // pointer-to-member conversion, or boolean conversion (C++ 4p1).
1828 // For overloading in C, this can also be a "compatible-type"
1829 // conversion.
1830 bool IncompatibleObjC = false;
1831 ImplicitConversionKind SecondICK = ICK_Identity;
1832 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
1833 // The unqualified versions of the types are the same: there's no
1834 // conversion to do.
1835 SCS.Second = ICK_Identity;
1836 } else if (S.IsIntegralPromotion(From, FromType, ToType)) {
1837 // Integral promotion (C++ 4.5).
1838 SCS.Second = ICK_Integral_Promotion;
1839 FromType = ToType.getUnqualifiedType();
1840 } else if (S.IsFloatingPointPromotion(FromType, ToType)) {
1841 // Floating point promotion (C++ 4.6).
1842 SCS.Second = ICK_Floating_Promotion;
1843 FromType = ToType.getUnqualifiedType();
1844 } else if (S.IsComplexPromotion(FromType, ToType)) {
1845 // Complex promotion (Clang extension)
1846 SCS.Second = ICK_Complex_Promotion;
1847 FromType = ToType.getUnqualifiedType();
1848 } else if (ToType->isBooleanType() &&
1849 (FromType->isArithmeticType() ||
1850 FromType->isAnyPointerType() ||
1851 FromType->isBlockPointerType() ||
1852 FromType->isMemberPointerType())) {
1853 // Boolean conversions (C++ 4.12).
1854 SCS.Second = ICK_Boolean_Conversion;
1855 FromType = S.Context.BoolTy;
1856 } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
1857 ToType->isIntegralType(S.Context)) {
1858 // Integral conversions (C++ 4.7).
1859 SCS.Second = ICK_Integral_Conversion;
1860 FromType = ToType.getUnqualifiedType();
1861 } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
1862 // Complex conversions (C99 6.3.1.6)
1863 SCS.Second = ICK_Complex_Conversion;
1864 FromType = ToType.getUnqualifiedType();
1865 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
1866 (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
1867 // Complex-real conversions (C99 6.3.1.7)
1868 SCS.Second = ICK_Complex_Real;
1869 FromType = ToType.getUnqualifiedType();
1870 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
1871 // FIXME: disable conversions between long double and __float128 if
1872 // their representation is different until there is back end support
1873 // We of course allow this conversion if long double is really double.
1874
1875 // Conversions between bfloat and other floats are not permitted.
1876 if (FromType == S.Context.BFloat16Ty || ToType == S.Context.BFloat16Ty)
1877 return false;
1878 if (&S.Context.getFloatTypeSemantics(FromType) !=
1879 &S.Context.getFloatTypeSemantics(ToType)) {
1880 bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
1881 ToType == S.Context.LongDoubleTy) ||
1882 (FromType == S.Context.LongDoubleTy &&
1883 ToType == S.Context.Float128Ty));
1884 if (Float128AndLongDouble &&
1885 (&S.Context.getFloatTypeSemantics(S.Context.LongDoubleTy) ==
1886 &llvm::APFloat::PPCDoubleDouble()))
1887 return false;
1888 }
1889 // Floating point conversions (C++ 4.8).
1890 SCS.Second = ICK_Floating_Conversion;
1891 FromType = ToType.getUnqualifiedType();
1892 } else if ((FromType->isRealFloatingType() &&
1893 ToType->isIntegralType(S.Context)) ||
1894 (FromType->isIntegralOrUnscopedEnumerationType() &&
1895 ToType->isRealFloatingType())) {
1896 // Conversions between bfloat and int are not permitted.
1897 if (FromType->isBFloat16Type() || ToType->isBFloat16Type())
1898 return false;
1899
1900 // Floating-integral conversions (C++ 4.9).
1901 SCS.Second = ICK_Floating_Integral;
1902 FromType = ToType.getUnqualifiedType();
1903 } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
1904 SCS.Second = ICK_Block_Pointer_Conversion;
1905 } else if (AllowObjCWritebackConversion &&
1906 S.isObjCWritebackConversion(FromType, ToType, FromType)) {
1907 SCS.Second = ICK_Writeback_Conversion;
1908 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
1909 FromType, IncompatibleObjC)) {
1910 // Pointer conversions (C++ 4.10).
1911 SCS.Second = ICK_Pointer_Conversion;
1912 SCS.IncompatibleObjC = IncompatibleObjC;
1913 FromType = FromType.getUnqualifiedType();
1914 } else if (S.IsMemberPointerConversion(From, FromType, ToType,
1915 InOverloadResolution, FromType)) {
1916 // Pointer to member conversions (4.11).
1917 SCS.Second = ICK_Pointer_Member;
1918 } else if (IsVectorConversion(S, FromType, ToType, SecondICK)) {
1919 SCS.Second = SecondICK;
1920 FromType = ToType.getUnqualifiedType();
1921 } else if (!S.getLangOpts().CPlusPlus &&
1922 S.Context.typesAreCompatible(ToType, FromType)) {
1923 // Compatible conversions (Clang extension for C function overloading)
1924 SCS.Second = ICK_Compatible_Conversion;
1925 FromType = ToType.getUnqualifiedType();
1926 } else if (IsTransparentUnionStandardConversion(S, From, ToType,
1927 InOverloadResolution,
1928 SCS, CStyle)) {
1929 SCS.Second = ICK_TransparentUnionConversion;
1930 FromType = ToType;
1931 } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
1932 CStyle)) {
1933 // tryAtomicConversion has updated the standard conversion sequence
1934 // appropriately.
1935 return true;
1936 } else if (ToType->isEventT() &&
1937 From->isIntegerConstantExpr(S.getASTContext()) &&
1938 From->EvaluateKnownConstInt(S.getASTContext()) == 0) {
1939 SCS.Second = ICK_Zero_Event_Conversion;
1940 FromType = ToType;
1941 } else if (ToType->isQueueT() &&
1942 From->isIntegerConstantExpr(S.getASTContext()) &&
1943 (From->EvaluateKnownConstInt(S.getASTContext()) == 0)) {
1944 SCS.Second = ICK_Zero_Queue_Conversion;
1945 FromType = ToType;
1946 } else if (ToType->isSamplerT() &&
1947 From->isIntegerConstantExpr(S.getASTContext())) {
1948 SCS.Second = ICK_Compatible_Conversion;
1949 FromType = ToType;
1950 } else {
1951 // No second conversion required.
1952 SCS.Second = ICK_Identity;
1953 }
1954 SCS.setToType(1, FromType);
1955
1956 // The third conversion can be a function pointer conversion or a
1957 // qualification conversion (C++ [conv.fctptr], [conv.qual]).
1958 bool ObjCLifetimeConversion;
1959 if (S.IsFunctionConversion(FromType, ToType, FromType)) {
1960 // Function pointer conversions (removing 'noexcept') including removal of
1961 // 'noreturn' (Clang extension).
1962 SCS.Third = ICK_Function_Conversion;
1963 } else if (S.IsQualificationConversion(FromType, ToType, CStyle,
1964 ObjCLifetimeConversion)) {
1965 SCS.Third = ICK_Qualification;
1966 SCS.QualificationIncludesObjCLifetime = ObjCLifetimeConversion;
1967 FromType = ToType;
1968 } else {
1969 // No conversion required
1970 SCS.Third = ICK_Identity;
1971 }
1972
1973 // C++ [over.best.ics]p6:
1974 // [...] Any difference in top-level cv-qualification is
1975 // subsumed by the initialization itself and does not constitute
1976 // a conversion. [...]
1977 QualType CanonFrom = S.Context.getCanonicalType(FromType);
1978 QualType CanonTo = S.Context.getCanonicalType(ToType);
1979 if (CanonFrom.getLocalUnqualifiedType()
1980 == CanonTo.getLocalUnqualifiedType() &&
1981 CanonFrom.getLocalQualifiers() != CanonTo.getLocalQualifiers()) {
1982 FromType = ToType;
1983 CanonFrom = CanonTo;
1984 }
1985
1986 SCS.setToType(2, FromType);
1987
1988 if (CanonFrom == CanonTo)
1989 return true;
1990
1991 // If we have not converted the argument type to the parameter type,
1992 // this is a bad conversion sequence, unless we're resolving an overload in C.
1993 if (S.getLangOpts().CPlusPlus || !InOverloadResolution)
1994 return false;
1995
1996 ExprResult ER = ExprResult{From};
1997 Sema::AssignConvertType Conv =
1998 S.CheckSingleAssignmentConstraints(ToType, ER,
1999 /*Diagnose=*/false,
2000 /*DiagnoseCFAudited=*/false,
2001 /*ConvertRHS=*/false);
2002 ImplicitConversionKind SecondConv;
2003 switch (Conv) {
2004 case Sema::Compatible:
2005 SecondConv = ICK_C_Only_Conversion;
2006 break;
2007 // For our purposes, discarding qualifiers is just as bad as using an
2008 // incompatible pointer. Note that an IncompatiblePointer conversion can drop
2009 // qualifiers, as well.
2010 case Sema::CompatiblePointerDiscardsQualifiers:
2011 case Sema::IncompatiblePointer:
2012 case Sema::IncompatiblePointerSign:
2013 SecondConv = ICK_Incompatible_Pointer_Conversion;
2014 break;
2015 default:
2016 return false;
2017 }
2018
2019 // First can only be an lvalue conversion, so we pretend that this was the
2020 // second conversion. First should already be valid from earlier in the
2021 // function.
2022 SCS.Second = SecondConv;
2023 SCS.setToType(1, ToType);
2024
2025 // Third is Identity, because Second should rank us worse than any other
2026 // conversion. This could also be ICK_Qualification, but it's simpler to just
2027 // lump everything in with the second conversion, and we don't gain anything
2028 // from making this ICK_Qualification.
2029 SCS.Third = ICK_Identity;
2030 SCS.setToType(2, ToType);
2031 return true;
2032}
2033
2034static bool
2035IsTransparentUnionStandardConversion(Sema &S, Expr* From,
2036 QualType &ToType,
2037 bool InOverloadResolution,
2038 StandardConversionSequence &SCS,
2039 bool CStyle) {
2040
2041 const RecordType *UT = ToType->getAsUnionType();
2042 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>())
2043 return false;
2044 // The field to initialize within the transparent union.
2045 RecordDecl *UD = UT->getDecl();
2046 // It's compatible if the expression matches any of the fields.
2047 for (const auto *it : UD->fields()) {
2048 if (IsStandardConversion(S, From, it->getType(), InOverloadResolution, SCS,
2049 CStyle, /*AllowObjCWritebackConversion=*/false)) {
2050 ToType = it->getType();
2051 return true;
2052 }
2053 }
2054 return false;
2055}
2056
2057/// IsIntegralPromotion - Determines whether the conversion from the
2058/// expression From (whose potentially-adjusted type is FromType) to
2059/// ToType is an integral promotion (C++ 4.5). If so, returns true and
2060/// sets PromotedType to the promoted type.
2061bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
2062 const BuiltinType *To = ToType->getAs<BuiltinType>();
2063 // All integers are built-in.
2064 if (!To) {
2065 return false;
2066 }
2067
2068 // An rvalue of type char, signed char, unsigned char, short int, or
2069 // unsigned short int can be converted to an rvalue of type int if
2070 // int can represent all the values of the source type; otherwise,
2071 // the source rvalue can be converted to an rvalue of type unsigned
2072 // int (C++ 4.5p1).
2073 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() &&
2074 !FromType->isEnumeralType()) {
2075 if (// We can promote any signed, promotable integer type to an int
2076 (FromType->isSignedIntegerType() ||
2077 // We can promote any unsigned integer type whose size is
2078 // less than int to an int.
2079 Context.getTypeSize(FromType) < Context.getTypeSize(ToType))) {
2080 return To->getKind() == BuiltinType::Int;
2081 }
2082
2083 return To->getKind() == BuiltinType::UInt;
2084 }
2085
2086 // C++11 [conv.prom]p3:
2087 // A prvalue of an unscoped enumeration type whose underlying type is not
2088 // fixed (7.2) can be converted to an rvalue a prvalue of the first of the
2089 // following types that can represent all the values of the enumeration
2090 // (i.e., the values in the range bmin to bmax as described in 7.2): int,
2091 // unsigned int, long int, unsigned long int, long long int, or unsigned
2092 // long long int. If none of the types in that list can represent all the
2093 // values of the enumeration, an rvalue a prvalue of an unscoped enumeration
2094 // type can be converted to an rvalue a prvalue of the extended integer type
2095 // with lowest integer conversion rank (4.13) greater than the rank of long
2096 // long in which all the values of the enumeration can be represented. If
2097 // there are two such extended types, the signed one is chosen.
2098 // C++11 [conv.prom]p4:
2099 // A prvalue of an unscoped enumeration type whose underlying type is fixed
2100 // can be converted to a prvalue of its underlying type. Moreover, if
2101 // integral promotion can be applied to its underlying type, a prvalue of an
2102 // unscoped enumeration type whose underlying type is fixed can also be
2103 // converted to a prvalue of the promoted underlying type.
2104 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) {
2105 // C++0x 7.2p9: Note that this implicit enum to int conversion is not
2106 // provided for a scoped enumeration.
2107 if (FromEnumType->getDecl()->isScoped())
2108 return false;
2109
2110 // We can perform an integral promotion to the underlying type of the enum,
2111 // even if that's not the promoted type. Note that the check for promoting
2112 // the underlying type is based on the type alone, and does not consider
2113 // the bitfield-ness of the actual source expression.
2114 if (FromEnumType->getDecl()->isFixed()) {
2115 QualType Underlying = FromEnumType->getDecl()->getIntegerType();
2116 return Context.hasSameUnqualifiedType(Underlying, ToType) ||
2117 IsIntegralPromotion(nullptr, Underlying, ToType);
2118 }
2119
2120 // We have already pre-calculated the promotion type, so this is trivial.
2121 if (ToType->isIntegerType() &&
2122 isCompleteType(From->getBeginLoc(), FromType))
2123 return Context.hasSameUnqualifiedType(
2124 ToType, FromEnumType->getDecl()->getPromotionType());
2125
2126 // C++ [conv.prom]p5:
2127 // If the bit-field has an enumerated type, it is treated as any other
2128 // value of that type for promotion purposes.
2129 //
2130 // ... so do not fall through into the bit-field checks below in C++.
2131 if (getLangOpts().CPlusPlus)
2132 return false;
2133 }
2134
2135 // C++0x [conv.prom]p2:
2136 // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted
2137 // to an rvalue a prvalue of the first of the following types that can
2138 // represent all the values of its underlying type: int, unsigned int,
2139 // long int, unsigned long int, long long int, or unsigned long long int.
2140 // If none of the types in that list can represent all the values of its
2141 // underlying type, an rvalue a prvalue of type char16_t, char32_t,
2142 // or wchar_t can be converted to an rvalue a prvalue of its underlying
2143 // type.
2144 if (FromType->isAnyCharacterType() && !FromType->isCharType() &&
2145 ToType->isIntegerType()) {
2146 // Determine whether the type we're converting from is signed or
2147 // unsigned.
2148 bool FromIsSigned = FromType->isSignedIntegerType();
2149 uint64_t FromSize = Context.getTypeSize(FromType);
2150
2151 // The types we'll try to promote to, in the appropriate
2152 // order. Try each of these types.
2153 QualType PromoteTypes[6] = {
2154 Context.IntTy, Context.UnsignedIntTy,
2155 Context.LongTy, Context.UnsignedLongTy ,
2156 Context.LongLongTy, Context.UnsignedLongLongTy
2157 };
2158 for (int Idx = 0; Idx < 6; ++Idx) {
2159 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]);
2160 if (FromSize < ToSize ||
2161 (FromSize == ToSize &&
2162 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) {
2163 // We found the type that we can promote to. If this is the
2164 // type we wanted, we have a promotion. Otherwise, no
2165 // promotion.
2166 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]);
2167 }
2168 }
2169 }
2170
2171 // An rvalue for an integral bit-field (9.6) can be converted to an
2172 // rvalue of type int if int can represent all the values of the
2173 // bit-field; otherwise, it can be converted to unsigned int if
2174 // unsigned int can represent all the values of the bit-field. If
2175 // the bit-field is larger yet, no integral promotion applies to
2176 // it. If the bit-field has an enumerated type, it is treated as any
2177 // other value of that type for promotion purposes (C++ 4.5p3).
2178 // FIXME: We should delay checking of bit-fields until we actually perform the
2179 // conversion.
2180 //
2181 // FIXME: In C, only bit-fields of types _Bool, int, or unsigned int may be
2182 // promoted, per C11 6.3.1.1/2. We promote all bit-fields (including enum
2183 // bit-fields and those whose underlying type is larger than int) for GCC
2184 // compatibility.
2185 if (From) {
2186 if (FieldDecl *MemberDecl = From->getSourceBitField()) {
2187 Optional<llvm::APSInt> BitWidth;
2188 if (FromType->isIntegralType(Context) &&
2189 (BitWidth =
2190 MemberDecl->getBitWidth()->getIntegerConstantExpr(Context))) {
2191 llvm::APSInt ToSize(BitWidth->getBitWidth(), BitWidth->isUnsigned());
2192 ToSize = Context.getTypeSize(ToType);
2193
2194 // Are we promoting to an int from a bitfield that fits in an int?
2195 if (*BitWidth < ToSize ||
2196 (FromType->isSignedIntegerType() && *BitWidth <= ToSize)) {
2197 return To->getKind() == BuiltinType::Int;
2198 }
2199
2200 // Are we promoting to an unsigned int from an unsigned bitfield
2201 // that fits into an unsigned int?
2202 if (FromType->isUnsignedIntegerType() && *BitWidth <= ToSize) {
2203 return To->getKind() == BuiltinType::UInt;
2204 }
2205
2206 return false;
2207 }
2208 }
2209 }
2210
2211 // An rvalue of type bool can be converted to an rvalue of type int,
2212 // with false becoming zero and true becoming one (C++ 4.5p4).
2213 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
2214 return true;
2215 }
2216
2217 return false;
2218}
2219
2220/// IsFloatingPointPromotion - Determines whether the conversion from
2221/// FromType to ToType is a floating point promotion (C++ 4.6). If so,
2222/// returns true and sets PromotedType to the promoted type.
2223bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
2224 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
2225 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
2226 /// An rvalue of type float can be converted to an rvalue of type
2227 /// double. (C++ 4.6p1).
2228 if (FromBuiltin->getKind() == BuiltinType::Float &&
2229 ToBuiltin->getKind() == BuiltinType::Double)
2230 return true;
2231
2232 // C99 6.3.1.5p1:
2233 // When a float is promoted to double or long double, or a
2234 // double is promoted to long double [...].
2235 if (!getLangOpts().CPlusPlus &&
2236 (FromBuiltin->getKind() == BuiltinType::Float ||
2237 FromBuiltin->getKind() == BuiltinType::Double) &&
2238 (ToBuiltin->getKind() == BuiltinType::LongDouble ||
2239 ToBuiltin->getKind() == BuiltinType::Float128))
2240 return true;
2241
2242 // Half can be promoted to float.
2243 if (!getLangOpts().NativeHalfType &&
2244 FromBuiltin->getKind() == BuiltinType::Half &&
2245 ToBuiltin->getKind() == BuiltinType::Float)
2246 return true;
2247 }
2248
2249 return false;
2250}
2251
2252/// Determine if a conversion is a complex promotion.
2253///
2254/// A complex promotion is defined as a complex -> complex conversion
2255/// where the conversion between the underlying real types is a
2256/// floating-point or integral promotion.
2257bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) {
2258 const ComplexType *FromComplex = FromType->getAs<ComplexType>();
2259 if (!FromComplex)
2260 return false;
2261
2262 const ComplexType *ToComplex = ToType->getAs<ComplexType>();
2263 if (!ToComplex)
2264 return false;
2265
2266 return IsFloatingPointPromotion(FromComplex->getElementType(),
2267 ToComplex->getElementType()) ||
2268 IsIntegralPromotion(nullptr, FromComplex->getElementType(),
2269 ToComplex->getElementType());
2270}
2271
2272/// BuildSimilarlyQualifiedPointerType - In a pointer conversion from
2273/// the pointer type FromPtr to a pointer to type ToPointee, with the
2274/// same type qualifiers as FromPtr has on its pointee type. ToType,
2275/// if non-empty, will be a pointer to ToType that may or may not have
2276/// the right set of qualifiers on its pointee.
2277///
2278static QualType
2279BuildSimilarlyQualifiedPointerType(const Type *FromPtr,
2280 QualType ToPointee, QualType ToType,
2281 ASTContext &Context,
2282 bool StripObjCLifetime = false) {
2283 assert((FromPtr->getTypeClass() == Type::Pointer ||(((FromPtr->getTypeClass() == Type::Pointer || FromPtr->
getTypeClass() == Type::ObjCObjectPointer) && "Invalid similarly-qualified pointer type"
) ? static_cast<void> (0) : __assert_fail ("(FromPtr->getTypeClass() == Type::Pointer || FromPtr->getTypeClass() == Type::ObjCObjectPointer) && \"Invalid similarly-qualified pointer type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 2285, __PRETTY_FUNCTION__))
2284 FromPtr->getTypeClass() == Type::ObjCObjectPointer) &&(((FromPtr->getTypeClass() == Type::Pointer || FromPtr->
getTypeClass() == Type::ObjCObjectPointer) && "Invalid similarly-qualified pointer type"
) ? static_cast<void> (0) : __assert_fail ("(FromPtr->getTypeClass() == Type::Pointer || FromPtr->getTypeClass() == Type::ObjCObjectPointer) && \"Invalid similarly-qualified pointer type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 2285, __PRETTY_FUNCTION__))
2285 "Invalid similarly-qualified pointer type")(((FromPtr->getTypeClass() == Type::Pointer || FromPtr->
getTypeClass() == Type::ObjCObjectPointer) && "Invalid similarly-qualified pointer type"
) ? static_cast<void> (0) : __assert_fail ("(FromPtr->getTypeClass() == Type::Pointer || FromPtr->getTypeClass() == Type::ObjCObjectPointer) && \"Invalid similarly-qualified pointer type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 2285, __PRETTY_FUNCTION__))
;
2286
2287 /// Conversions to 'id' subsume cv-qualifier conversions.
2288 if (ToType->isObjCIdType() || ToType->isObjCQualifiedIdType())
2289 return ToType.getUnqualifiedType();
2290
2291 QualType CanonFromPointee
2292 = Context.getCanonicalType(FromPtr->getPointeeType());
2293 QualType CanonToPointee = Context.getCanonicalType(ToPointee);
2294 Qualifiers Quals = CanonFromPointee.getQualifiers();
2295
2296 if (StripObjCLifetime)
2297 Quals.removeObjCLifetime();
2298
2299 // Exact qualifier match -> return the pointer type we're converting to.
2300 if (CanonToPointee.getLocalQualifiers() == Quals) {
2301 // ToType is exactly what we need. Return it.
2302 if (!ToType.isNull())
2303 return ToType.getUnqualifiedType();
2304
2305 // Build a pointer to ToPointee. It has the right qualifiers
2306 // already.
2307 if (isa<ObjCObjectPointerType>(ToType))
2308 return Context.getObjCObjectPointerType(ToPointee);
2309 return Context.getPointerType(ToPointee);
2310 }
2311
2312 // Just build a canonical type that has the right qualifiers.
2313 QualType QualifiedCanonToPointee
2314 = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals);
2315
2316 if (isa<ObjCObjectPointerType>(ToType))
2317 return Context.getObjCObjectPointerType(QualifiedCanonToPointee);
2318 return Context.getPointerType(QualifiedCanonToPointee);
2319}
2320
2321static bool isNullPointerConstantForConversion(Expr *Expr,
2322 bool InOverloadResolution,
2323 ASTContext &Context) {
2324 // Handle value-dependent integral null pointer constants correctly.
2325 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903
2326 if (Expr->isValueDependent() && !Expr->isTypeDependent() &&
2327 Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType())
2328 return !InOverloadResolution;
2329
2330 return Expr->isNullPointerConstant(Context,
2331 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
2332 : Expr::NPC_ValueDependentIsNull);
2333}
2334
2335/// IsPointerConversion - Determines whether the conversion of the
2336/// expression From, which has the (possibly adjusted) type FromType,
2337/// can be converted to the type ToType via a pointer conversion (C++
2338/// 4.10). If so, returns true and places the converted type (that
2339/// might differ from ToType in its cv-qualifiers at some level) into
2340/// ConvertedType.
2341///
2342/// This routine also supports conversions to and from block pointers
2343/// and conversions with Objective-C's 'id', 'id<protocols...>', and
2344/// pointers to interfaces. FIXME: Once we've determined the
2345/// appropriate overloading rules for Objective-C, we may want to
2346/// split the Objective-C checks into a different routine; however,
2347/// GCC seems to consider all of these conversions to be pointer
2348/// conversions, so for now they live here. IncompatibleObjC will be
2349/// set if the conversion is an allowed Objective-C conversion that
2350/// should result in a warning.
2351bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType,
2352 bool InOverloadResolution,
2353 QualType& ConvertedType,
2354 bool &IncompatibleObjC) {
2355 IncompatibleObjC = false;
2356 if (isObjCPointerConversion(FromType, ToType, ConvertedType,
2357 IncompatibleObjC))
2358 return true;
2359
2360 // Conversion from a null pointer constant to any Objective-C pointer type.
2361 if (ToType->isObjCObjectPointerType() &&
2362 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2363 ConvertedType = ToType;
2364 return true;
2365 }
2366
2367 // Blocks: Block pointers can be converted to void*.
2368 if (FromType->isBlockPointerType() && ToType->isPointerType() &&
2369 ToType->castAs<PointerType>()->getPointeeType()->isVoidType()) {
2370 ConvertedType = ToType;
2371 return true;
2372 }
2373 // Blocks: A null pointer constant can be converted to a block
2374 // pointer type.
2375 if (ToType->isBlockPointerType() &&
2376 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2377 ConvertedType = ToType;
2378 return true;
2379 }
2380
2381 // If the left-hand-side is nullptr_t, the right side can be a null
2382 // pointer constant.
2383 if (ToType->isNullPtrType() &&
2384 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2385 ConvertedType = ToType;
2386 return true;
2387 }
2388
2389 const PointerType* ToTypePtr = ToType->getAs<PointerType>();
2390 if (!ToTypePtr)
2391 return false;
2392
2393 // A null pointer constant can be converted to a pointer type (C++ 4.10p1).
2394 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) {
2395 ConvertedType = ToType;
2396 return true;
2397 }
2398
2399 // Beyond this point, both types need to be pointers
2400 // , including objective-c pointers.
2401 QualType ToPointeeType = ToTypePtr->getPointeeType();
2402 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType() &&
2403 !getLangOpts().ObjCAutoRefCount) {
2404 ConvertedType = BuildSimilarlyQualifiedPointerType(
2405 FromType->getAs<ObjCObjectPointerType>(),
2406 ToPointeeType,
2407 ToType, Context);
2408 return true;
2409 }
2410 const PointerType *FromTypePtr = FromType->getAs<PointerType>();
2411 if (!FromTypePtr)
2412 return false;
2413
2414 QualType FromPointeeType = FromTypePtr->getPointeeType();
2415
2416 // If the unqualified pointee types are the same, this can't be a
2417 // pointer conversion, so don't do all of the work below.
2418 if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType))
2419 return false;
2420
2421 // An rvalue of type "pointer to cv T," where T is an object type,
2422 // can be converted to an rvalue of type "pointer to cv void" (C++
2423 // 4.10p2).
2424 if (FromPointeeType->isIncompleteOrObjectType() &&
2425 ToPointeeType->isVoidType()) {
2426 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2427 ToPointeeType,
2428 ToType, Context,
2429 /*StripObjCLifetime=*/true);
2430 return true;
2431 }
2432
2433 // MSVC allows implicit function to void* type conversion.
2434 if (getLangOpts().MSVCCompat && FromPointeeType->isFunctionType() &&
2435 ToPointeeType->isVoidType()) {
2436 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2437 ToPointeeType,
2438 ToType, Context);
2439 return true;
2440 }
2441
2442 // When we're overloading in C, we allow a special kind of pointer
2443 // conversion for compatible-but-not-identical pointee types.
2444 if (!getLangOpts().CPlusPlus &&
2445 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) {
2446 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2447 ToPointeeType,
2448 ToType, Context);
2449 return true;
2450 }
2451
2452 // C++ [conv.ptr]p3:
2453 //
2454 // An rvalue of type "pointer to cv D," where D is a class type,
2455 // can be converted to an rvalue of type "pointer to cv B," where
2456 // B is a base class (clause 10) of D. If B is an inaccessible
2457 // (clause 11) or ambiguous (10.2) base class of D, a program that
2458 // necessitates this conversion is ill-formed. The result of the
2459 // conversion is a pointer to the base class sub-object of the
2460 // derived class object. The null pointer value is converted to
2461 // the null pointer value of the destination type.
2462 //
2463 // Note that we do not check for ambiguity or inaccessibility
2464 // here. That is handled by CheckPointerConversion.
2465 if (getLangOpts().CPlusPlus && FromPointeeType->isRecordType() &&
2466 ToPointeeType->isRecordType() &&
2467 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) &&
2468 IsDerivedFrom(From->getBeginLoc(), FromPointeeType, ToPointeeType)) {
2469 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2470 ToPointeeType,
2471 ToType, Context);
2472 return true;
2473 }
2474
2475 if (FromPointeeType->isVectorType() && ToPointeeType->isVectorType() &&
2476 Context.areCompatibleVectorTypes(FromPointeeType, ToPointeeType)) {
2477 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr,
2478 ToPointeeType,
2479 ToType, Context);
2480 return true;
2481 }
2482
2483 return false;
2484}
2485
2486/// Adopt the given qualifiers for the given type.
2487static QualType AdoptQualifiers(ASTContext &Context, QualType T, Qualifiers Qs){
2488 Qualifiers TQs = T.getQualifiers();
2489
2490 // Check whether qualifiers already match.
2491 if (TQs == Qs)
2492 return T;
2493
2494 if (Qs.compatiblyIncludes(TQs))
2495 return Context.getQualifiedType(T, Qs);
2496
2497 return Context.getQualifiedType(T.getUnqualifiedType(), Qs);
2498}
2499
2500/// isObjCPointerConversion - Determines whether this is an
2501/// Objective-C pointer conversion. Subroutine of IsPointerConversion,
2502/// with the same arguments and return values.
2503bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType,
2504 QualType& ConvertedType,
2505 bool &IncompatibleObjC) {
2506 if (!getLangOpts().ObjC)
2507 return false;
2508
2509 // The set of qualifiers on the type we're converting from.
2510 Qualifiers FromQualifiers = FromType.getQualifiers();
2511
2512 // First, we handle all conversions on ObjC object pointer types.
2513 const ObjCObjectPointerType* ToObjCPtr =
2514 ToType->getAs<ObjCObjectPointerType>();
2515 const ObjCObjectPointerType *FromObjCPtr =
2516 FromType->getAs<ObjCObjectPointerType>();
2517
2518 if (ToObjCPtr && FromObjCPtr) {
2519 // If the pointee types are the same (ignoring qualifications),
2520 // then this is not a pointer conversion.
2521 if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(),
2522 FromObjCPtr->getPointeeType()))
2523 return false;
2524
2525 // Conversion between Objective-C pointers.
2526 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) {
2527 const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType();
2528 const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType();
2529 if (getLangOpts().CPlusPlus && LHS && RHS &&
2530 !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs(
2531 FromObjCPtr->getPointeeType()))
2532 return false;
2533 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2534 ToObjCPtr->getPointeeType(),
2535 ToType, Context);
2536 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2537 return true;
2538 }
2539
2540 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) {
2541 // Okay: this is some kind of implicit downcast of Objective-C
2542 // interfaces, which is permitted. However, we're going to
2543 // complain about it.
2544 IncompatibleObjC = true;
2545 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr,
2546 ToObjCPtr->getPointeeType(),
2547 ToType, Context);
2548 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2549 return true;
2550 }
2551 }
2552 // Beyond this point, both types need to be C pointers or block pointers.
2553 QualType ToPointeeType;
2554 if (const PointerType *ToCPtr = ToType->getAs<PointerType>())
2555 ToPointeeType = ToCPtr->getPointeeType();
2556 else if (const BlockPointerType *ToBlockPtr =
2557 ToType->getAs<BlockPointerType>()) {
2558 // Objective C++: We're able to convert from a pointer to any object
2559 // to a block pointer type.
2560 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) {
2561 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2562 return true;
2563 }
2564 ToPointeeType = ToBlockPtr->getPointeeType();
2565 }
2566 else if (FromType->getAs<BlockPointerType>() &&
2567 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) {
2568 // Objective C++: We're able to convert from a block pointer type to a
2569 // pointer to any object.
2570 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2571 return true;
2572 }
2573 else
2574 return false;
2575
2576 QualType FromPointeeType;
2577 if (const PointerType *FromCPtr = FromType->getAs<PointerType>())
2578 FromPointeeType = FromCPtr->getPointeeType();
2579 else if (const BlockPointerType *FromBlockPtr =
2580 FromType->getAs<BlockPointerType>())
2581 FromPointeeType = FromBlockPtr->getPointeeType();
2582 else
2583 return false;
2584
2585 // If we have pointers to pointers, recursively check whether this
2586 // is an Objective-C conversion.
2587 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() &&
2588 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2589 IncompatibleObjC)) {
2590 // We always complain about this conversion.
2591 IncompatibleObjC = true;
2592 ConvertedType = Context.getPointerType(ConvertedType);
2593 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2594 return true;
2595 }
2596 // Allow conversion of pointee being objective-c pointer to another one;
2597 // as in I* to id.
2598 if (FromPointeeType->getAs<ObjCObjectPointerType>() &&
2599 ToPointeeType->getAs<ObjCObjectPointerType>() &&
2600 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType,
2601 IncompatibleObjC)) {
2602
2603 ConvertedType = Context.getPointerType(ConvertedType);
2604 ConvertedType = AdoptQualifiers(Context, ConvertedType, FromQualifiers);
2605 return true;
2606 }
2607
2608 // If we have pointers to functions or blocks, check whether the only
2609 // differences in the argument and result types are in Objective-C
2610 // pointer conversions. If so, we permit the conversion (but
2611 // complain about it).
2612 const FunctionProtoType *FromFunctionType
2613 = FromPointeeType->getAs<FunctionProtoType>();
2614 const FunctionProtoType *ToFunctionType
2615 = ToPointeeType->getAs<FunctionProtoType>();
2616 if (FromFunctionType && ToFunctionType) {
2617 // If the function types are exactly the same, this isn't an
2618 // Objective-C pointer conversion.
2619 if (Context.getCanonicalType(FromPointeeType)
2620 == Context.getCanonicalType(ToPointeeType))
2621 return false;
2622
2623 // Perform the quick checks that will tell us whether these
2624 // function types are obviously different.
2625 if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2626 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() ||
2627 FromFunctionType->getMethodQuals() != ToFunctionType->getMethodQuals())
2628 return false;
2629
2630 bool HasObjCConversion = false;
2631 if (Context.getCanonicalType(FromFunctionType->getReturnType()) ==
2632 Context.getCanonicalType(ToFunctionType->getReturnType())) {
2633 // Okay, the types match exactly. Nothing to do.
2634 } else if (isObjCPointerConversion(FromFunctionType->getReturnType(),
2635 ToFunctionType->getReturnType(),
2636 ConvertedType, IncompatibleObjC)) {
2637 // Okay, we have an Objective-C pointer conversion.
2638 HasObjCConversion = true;
2639 } else {
2640 // Function types are too different. Abort.
2641 return false;
2642 }
2643
2644 // Check argument types.
2645 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2646 ArgIdx != NumArgs; ++ArgIdx) {
2647 QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2648 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2649 if (Context.getCanonicalType(FromArgType)
2650 == Context.getCanonicalType(ToArgType)) {
2651 // Okay, the types match exactly. Nothing to do.
2652 } else if (isObjCPointerConversion(FromArgType, ToArgType,
2653 ConvertedType, IncompatibleObjC)) {
2654 // Okay, we have an Objective-C pointer conversion.
2655 HasObjCConversion = true;
2656 } else {
2657 // Argument types are too different. Abort.
2658 return false;
2659 }
2660 }
2661
2662 if (HasObjCConversion) {
2663 // We had an Objective-C conversion. Allow this pointer
2664 // conversion, but complain about it.
2665 ConvertedType = AdoptQualifiers(Context, ToType, FromQualifiers);
2666 IncompatibleObjC = true;
2667 return true;
2668 }
2669 }
2670
2671 return false;
2672}
2673
2674/// Determine whether this is an Objective-C writeback conversion,
2675/// used for parameter passing when performing automatic reference counting.
2676///
2677/// \param FromType The type we're converting form.
2678///
2679/// \param ToType The type we're converting to.
2680///
2681/// \param ConvertedType The type that will be produced after applying
2682/// this conversion.
2683bool Sema::isObjCWritebackConversion(QualType FromType, QualType ToType,
2684 QualType &ConvertedType) {
2685 if (!getLangOpts().ObjCAutoRefCount ||
2686 Context.hasSameUnqualifiedType(FromType, ToType))
2687 return false;
2688
2689 // Parameter must be a pointer to __autoreleasing (with no other qualifiers).
2690 QualType ToPointee;
2691 if (const PointerType *ToPointer = ToType->getAs<PointerType>())
2692 ToPointee = ToPointer->getPointeeType();
2693 else
2694 return false;
2695
2696 Qualifiers ToQuals = ToPointee.getQualifiers();
2697 if (!ToPointee->isObjCLifetimeType() ||
2698 ToQuals.getObjCLifetime() != Qualifiers::OCL_Autoreleasing ||
2699 !ToQuals.withoutObjCLifetime().empty())
2700 return false;
2701
2702 // Argument must be a pointer to __strong to __weak.
2703 QualType FromPointee;
2704 if (const PointerType *FromPointer = FromType->getAs<PointerType>())
2705 FromPointee = FromPointer->getPointeeType();
2706 else
2707 return false;
2708
2709 Qualifiers FromQuals = FromPointee.getQualifiers();
2710 if (!FromPointee->isObjCLifetimeType() ||
2711 (FromQuals.getObjCLifetime() != Qualifiers::OCL_Strong &&
2712 FromQuals.getObjCLifetime() != Qualifiers::OCL_Weak))
2713 return false;
2714
2715 // Make sure that we have compatible qualifiers.
2716 FromQuals.setObjCLifetime(Qualifiers::OCL_Autoreleasing);
2717 if (!ToQuals.compatiblyIncludes(FromQuals))
2718 return false;
2719
2720 // Remove qualifiers from the pointee type we're converting from; they
2721 // aren't used in the compatibility check belong, and we'll be adding back
2722 // qualifiers (with __autoreleasing) if the compatibility check succeeds.
2723 FromPointee = FromPointee.getUnqualifiedType();
2724
2725 // The unqualified form of the pointee types must be compatible.
2726 ToPointee = ToPointee.getUnqualifiedType();
2727 bool IncompatibleObjC;
2728 if (Context.typesAreCompatible(FromPointee, ToPointee))
2729 FromPointee = ToPointee;
2730 else if (!isObjCPointerConversion(FromPointee, ToPointee, FromPointee,
2731 IncompatibleObjC))
2732 return false;
2733
2734 /// Construct the type we're converting to, which is a pointer to
2735 /// __autoreleasing pointee.
2736 FromPointee = Context.getQualifiedType(FromPointee, FromQuals);
2737 ConvertedType = Context.getPointerType(FromPointee);
2738 return true;
2739}
2740
2741bool Sema::IsBlockPointerConversion(QualType FromType, QualType ToType,
2742 QualType& ConvertedType) {
2743 QualType ToPointeeType;
2744 if (const BlockPointerType *ToBlockPtr =
2745 ToType->getAs<BlockPointerType>())
2746 ToPointeeType = ToBlockPtr->getPointeeType();
2747 else
2748 return false;
2749
2750 QualType FromPointeeType;
2751 if (const BlockPointerType *FromBlockPtr =
2752 FromType->getAs<BlockPointerType>())
2753 FromPointeeType = FromBlockPtr->getPointeeType();
2754 else
2755 return false;
2756 // We have pointer to blocks, check whether the only
2757 // differences in the argument and result types are in Objective-C
2758 // pointer conversions. If so, we permit the conversion.
2759
2760 const FunctionProtoType *FromFunctionType
2761 = FromPointeeType->getAs<FunctionProtoType>();
2762 const FunctionProtoType *ToFunctionType
2763 = ToPointeeType->getAs<FunctionProtoType>();
2764
2765 if (!FromFunctionType || !ToFunctionType)
2766 return false;
2767
2768 if (Context.hasSameType(FromPointeeType, ToPointeeType))
2769 return true;
2770
2771 // Perform the quick checks that will tell us whether these
2772 // function types are obviously different.
2773 if (FromFunctionType->getNumParams() != ToFunctionType->getNumParams() ||
2774 FromFunctionType->isVariadic() != ToFunctionType->isVariadic())
2775 return false;
2776
2777 FunctionType::ExtInfo FromEInfo = FromFunctionType->getExtInfo();
2778 FunctionType::ExtInfo ToEInfo = ToFunctionType->getExtInfo();
2779 if (FromEInfo != ToEInfo)
2780 return false;
2781
2782 bool IncompatibleObjC = false;
2783 if (Context.hasSameType(FromFunctionType->getReturnType(),
2784 ToFunctionType->getReturnType())) {
2785 // Okay, the types match exactly. Nothing to do.
2786 } else {
2787 QualType RHS = FromFunctionType->getReturnType();
2788 QualType LHS = ToFunctionType->getReturnType();
2789 if ((!getLangOpts().CPlusPlus || !RHS->isRecordType()) &&
2790 !RHS.hasQualifiers() && LHS.hasQualifiers())
2791 LHS = LHS.getUnqualifiedType();
2792
2793 if (Context.hasSameType(RHS,LHS)) {
2794 // OK exact match.
2795 } else if (isObjCPointerConversion(RHS, LHS,
2796 ConvertedType, IncompatibleObjC)) {
2797 if (IncompatibleObjC)
2798 return false;
2799 // Okay, we have an Objective-C pointer conversion.
2800 }
2801 else
2802 return false;
2803 }
2804
2805 // Check argument types.
2806 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumParams();
2807 ArgIdx != NumArgs; ++ArgIdx) {
2808 IncompatibleObjC = false;
2809 QualType FromArgType = FromFunctionType->getParamType(ArgIdx);
2810 QualType ToArgType = ToFunctionType->getParamType(ArgIdx);
2811 if (Context.hasSameType(FromArgType, ToArgType)) {
2812 // Okay, the types match exactly. Nothing to do.
2813 } else if (isObjCPointerConversion(ToArgType, FromArgType,
2814 ConvertedType, IncompatibleObjC)) {
2815 if (IncompatibleObjC)
2816 return false;
2817 // Okay, we have an Objective-C pointer conversion.
2818 } else
2819 // Argument types are too different. Abort.
2820 return false;
2821 }
2822
2823 SmallVector<FunctionProtoType::ExtParameterInfo, 4> NewParamInfos;
2824 bool CanUseToFPT, CanUseFromFPT;
2825 if (!Context.mergeExtParameterInfo(ToFunctionType, FromFunctionType,
2826 CanUseToFPT, CanUseFromFPT,
2827 NewParamInfos))
2828 return false;
2829
2830 ConvertedType = ToType;
2831 return true;
2832}
2833
2834enum {
2835 ft_default,
2836 ft_different_class,
2837 ft_parameter_arity,
2838 ft_parameter_mismatch,
2839 ft_return_type,
2840 ft_qualifer_mismatch,
2841 ft_noexcept
2842};
2843
2844/// Attempts to get the FunctionProtoType from a Type. Handles
2845/// MemberFunctionPointers properly.
2846static const FunctionProtoType *tryGetFunctionProtoType(QualType FromType) {
2847 if (auto *FPT = FromType->getAs<FunctionProtoType>())
2848 return FPT;
2849
2850 if (auto *MPT = FromType->getAs<MemberPointerType>())
2851 return MPT->getPointeeType()->getAs<FunctionProtoType>();
2852
2853 return nullptr;
2854}
2855
2856/// HandleFunctionTypeMismatch - Gives diagnostic information for differeing
2857/// function types. Catches different number of parameter, mismatch in
2858/// parameter types, and different return types.
2859void Sema::HandleFunctionTypeMismatch(PartialDiagnostic &PDiag,
2860 QualType FromType, QualType ToType) {
2861 // If either type is not valid, include no extra info.
2862 if (FromType.isNull() || ToType.isNull()) {
2863 PDiag << ft_default;
2864 return;
2865 }
2866
2867 // Get the function type from the pointers.
2868 if (FromType->isMemberPointerType() && ToType->isMemberPointerType()) {
2869 const auto *FromMember = FromType->castAs<MemberPointerType>(),
2870 *ToMember = ToType->castAs<MemberPointerType>();
2871 if (!Context.hasSameType(FromMember->getClass(), ToMember->getClass())) {
2872 PDiag << ft_different_class << QualType(ToMember->getClass(), 0)
2873 << QualType(FromMember->getClass(), 0);
2874 return;
2875 }
2876 FromType = FromMember->getPointeeType();
2877 ToType = ToMember->getPointeeType();
2878 }
2879
2880 if (FromType->isPointerType())
2881 FromType = FromType->getPointeeType();
2882 if (ToType->isPointerType())
2883 ToType = ToType->getPointeeType();
2884
2885 // Remove references.
2886 FromType = FromType.getNonReferenceType();
2887 ToType = ToType.getNonReferenceType();
2888
2889 // Don't print extra info for non-specialized template functions.
2890 if (FromType->isInstantiationDependentType() &&
2891 !FromType->getAs<TemplateSpecializationType>()) {
2892 PDiag << ft_default;
2893 return;
2894 }
2895
2896 // No extra info for same types.
2897 if (Context.hasSameType(FromType, ToType)) {
2898 PDiag << ft_default;
2899 return;
2900 }
2901
2902 const FunctionProtoType *FromFunction = tryGetFunctionProtoType(FromType),
2903 *ToFunction = tryGetFunctionProtoType(ToType);
2904
2905 // Both types need to be function types.
2906 if (!FromFunction || !ToFunction) {
2907 PDiag << ft_default;
2908 return;
2909 }
2910
2911 if (FromFunction->getNumParams() != ToFunction->getNumParams()) {
2912 PDiag << ft_parameter_arity << ToFunction->getNumParams()
2913 << FromFunction->getNumParams();
2914 return;
2915 }
2916
2917 // Handle different parameter types.
2918 unsigned ArgPos;
2919 if (!FunctionParamTypesAreEqual(FromFunction, ToFunction, &ArgPos)) {
2920 PDiag << ft_parameter_mismatch << ArgPos + 1
2921 << ToFunction->getParamType(ArgPos)
2922 << FromFunction->getParamType(ArgPos);
2923 return;
2924 }
2925
2926 // Handle different return type.
2927 if (!Context.hasSameType(FromFunction->getReturnType(),
2928 ToFunction->getReturnType())) {
2929 PDiag << ft_return_type << ToFunction->getReturnType()
2930 << FromFunction->getReturnType();
2931 return;
2932 }
2933
2934 if (FromFunction->getMethodQuals() != ToFunction->getMethodQuals()) {
2935 PDiag << ft_qualifer_mismatch << ToFunction->getMethodQuals()
2936 << FromFunction->getMethodQuals();
2937 return;
2938 }
2939
2940 // Handle exception specification differences on canonical type (in C++17
2941 // onwards).
2942 if (cast<FunctionProtoType>(FromFunction->getCanonicalTypeUnqualified())
2943 ->isNothrow() !=
2944 cast<FunctionProtoType>(ToFunction->getCanonicalTypeUnqualified())
2945 ->isNothrow()) {
2946 PDiag << ft_noexcept;
2947 return;
2948 }
2949
2950 // Unable to find a difference, so add no extra info.
2951 PDiag << ft_default;
2952}
2953
2954/// FunctionParamTypesAreEqual - This routine checks two function proto types
2955/// for equality of their argument types. Caller has already checked that
2956/// they have same number of arguments. If the parameters are different,
2957/// ArgPos will have the parameter index of the first different parameter.
2958bool Sema::FunctionParamTypesAreEqual(const FunctionProtoType *OldType,
2959 const FunctionProtoType *NewType,
2960 unsigned *ArgPos) {
2961 for (FunctionProtoType::param_type_iterator O = OldType->param_type_begin(),
2962 N = NewType->param_type_begin(),
2963 E = OldType->param_type_end();
2964 O && (O != E); ++O, ++N) {
2965 // Ignore address spaces in pointee type. This is to disallow overloading
2966 // on __ptr32/__ptr64 address spaces.
2967 QualType Old = Context.removePtrSizeAddrSpace(O->getUnqualifiedType());
2968 QualType New = Context.removePtrSizeAddrSpace(N->getUnqualifiedType());
2969
2970 if (!Context.hasSameType(Old, New)) {
2971 if (ArgPos)
2972 *ArgPos = O - OldType->param_type_begin();
2973 return false;
2974 }
2975 }
2976 return true;
2977}
2978
2979/// CheckPointerConversion - Check the pointer conversion from the
2980/// expression From to the type ToType. This routine checks for
2981/// ambiguous or inaccessible derived-to-base pointer
2982/// conversions for which IsPointerConversion has already returned
2983/// true. It returns true and produces a diagnostic if there was an
2984/// error, or returns false otherwise.
2985bool Sema::CheckPointerConversion(Expr *From, QualType ToType,
2986 CastKind &Kind,
2987 CXXCastPath& BasePath,
2988 bool IgnoreBaseAccess,
2989 bool Diagnose) {
2990 QualType FromType = From->getType();
2991 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess;
2992
2993 Kind = CK_BitCast;
2994
2995 if (Diagnose && !IsCStyleOrFunctionalCast && !FromType->isAnyPointerType() &&
2996 From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNotNull) ==
2997 Expr::NPCK_ZeroExpression) {
2998 if (Context.hasSameUnqualifiedType(From->getType(), Context.BoolTy))
2999 DiagRuntimeBehavior(From->getExprLoc(), From,
3000 PDiag(diag::warn_impcast_bool_to_null_pointer)
3001 << ToType << From->getSourceRange());
3002 else if (!isUnevaluatedContext())
3003 Diag(From->getExprLoc(), diag::warn_non_literal_null_pointer)
3004 << ToType << From->getSourceRange();
3005 }
3006 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) {
3007 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) {
3008 QualType FromPointeeType = FromPtrType->getPointeeType(),
3009 ToPointeeType = ToPtrType->getPointeeType();
3010
3011 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() &&
3012 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) {
3013 // We must have a derived-to-base conversion. Check an
3014 // ambiguous or inaccessible conversion.
3015 unsigned InaccessibleID = 0;
3016 unsigned AmbiguousID = 0;
3017 if (Diagnose) {
3018 InaccessibleID = diag::err_upcast_to_inaccessible_base;
3019 AmbiguousID = diag::err_ambiguous_derived_to_base_conv;
3020 }
3021 if (CheckDerivedToBaseConversion(
3022 FromPointeeType, ToPointeeType, InaccessibleID, AmbiguousID,
3023 From->getExprLoc(), From->getSourceRange(), DeclarationName(),
3024 &BasePath, IgnoreBaseAccess))
3025 return true;
3026
3027 // The conversion was successful.
3028 Kind = CK_DerivedToBase;
3029 }
3030
3031 if (Diagnose && !IsCStyleOrFunctionalCast &&
3032 FromPointeeType->isFunctionType() && ToPointeeType->isVoidType()) {
3033 assert(getLangOpts().MSVCCompat &&((getLangOpts().MSVCCompat && "this should only be possible with MSVCCompat!"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().MSVCCompat && \"this should only be possible with MSVCCompat!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3034, __PRETTY_FUNCTION__))
3034 "this should only be possible with MSVCCompat!")((getLangOpts().MSVCCompat && "this should only be possible with MSVCCompat!"
) ? static_cast<void> (0) : __assert_fail ("getLangOpts().MSVCCompat && \"this should only be possible with MSVCCompat!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3034, __PRETTY_FUNCTION__))
;
3035 Diag(From->getExprLoc(), diag::ext_ms_impcast_fn_obj)
3036 << From->getSourceRange();
3037 }
3038 }
3039 } else if (const ObjCObjectPointerType *ToPtrType =
3040 ToType->getAs<ObjCObjectPointerType>()) {
3041 if (const ObjCObjectPointerType *FromPtrType =
3042 FromType->getAs<ObjCObjectPointerType>()) {
3043 // Objective-C++ conversions are always okay.
3044 // FIXME: We should have a different class of conversions for the
3045 // Objective-C++ implicit conversions.
3046 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType())
3047 return false;
3048 } else if (FromType->isBlockPointerType()) {
3049 Kind = CK_BlockPointerToObjCPointerCast;
3050 } else {
3051 Kind = CK_CPointerToObjCPointerCast;
3052 }
3053 } else if (ToType->isBlockPointerType()) {
3054 if (!FromType->isBlockPointerType())
3055 Kind = CK_AnyPointerToBlockPointerCast;
3056 }
3057
3058 // We shouldn't fall into this case unless it's valid for other
3059 // reasons.
3060 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull))
3061 Kind = CK_NullToPointer;
3062
3063 return false;
3064}
3065
3066/// IsMemberPointerConversion - Determines whether the conversion of the
3067/// expression From, which has the (possibly adjusted) type FromType, can be
3068/// converted to the type ToType via a member pointer conversion (C++ 4.11).
3069/// If so, returns true and places the converted type (that might differ from
3070/// ToType in its cv-qualifiers at some level) into ConvertedType.
3071bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType,
3072 QualType ToType,
3073 bool InOverloadResolution,
3074 QualType &ConvertedType) {
3075 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>();
3076 if (!ToTypePtr)
3077 return false;
3078
3079 // A null pointer constant can be converted to a member pointer (C++ 4.11p1)
3080 if (From->isNullPointerConstant(Context,
3081 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull
3082 : Expr::NPC_ValueDependentIsNull)) {
3083 ConvertedType = ToType;
3084 return true;
3085 }
3086
3087 // Otherwise, both types have to be member pointers.
3088 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>();
3089 if (!FromTypePtr)
3090 return false;
3091
3092 // A pointer to member of B can be converted to a pointer to member of D,
3093 // where D is derived from B (C++ 4.11p2).
3094 QualType FromClass(FromTypePtr->getClass(), 0);
3095 QualType ToClass(ToTypePtr->getClass(), 0);
3096
3097 if (!Context.hasSameUnqualifiedType(FromClass, ToClass) &&
3098 IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass)) {
3099 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(),
3100 ToClass.getTypePtr());
3101 return true;
3102 }
3103
3104 return false;
3105}
3106
3107/// CheckMemberPointerConversion - Check the member pointer conversion from the
3108/// expression From to the type ToType. This routine checks for ambiguous or
3109/// virtual or inaccessible base-to-derived member pointer conversions
3110/// for which IsMemberPointerConversion has already returned true. It returns
3111/// true and produces a diagnostic if there was an error, or returns false
3112/// otherwise.
3113bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType,
3114 CastKind &Kind,
3115 CXXCastPath &BasePath,
3116 bool IgnoreBaseAccess) {
3117 QualType FromType = From->getType();
3118 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>();
3119 if (!FromPtrType) {
3120 // This must be a null pointer to member pointer conversion
3121 assert(From->isNullPointerConstant(Context,((From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull
) && "Expr must be null pointer constant!") ? static_cast
<void> (0) : __assert_fail ("From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull) && \"Expr must be null pointer constant!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3123, __PRETTY_FUNCTION__))
3122 Expr::NPC_ValueDependentIsNull) &&((From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull
) && "Expr must be null pointer constant!") ? static_cast
<void> (0) : __assert_fail ("From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull) && \"Expr must be null pointer constant!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3123, __PRETTY_FUNCTION__))
3123 "Expr must be null pointer constant!")((From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull
) && "Expr must be null pointer constant!") ? static_cast
<void> (0) : __assert_fail ("From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull) && \"Expr must be null pointer constant!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3123, __PRETTY_FUNCTION__))
;
3124 Kind = CK_NullToMemberPointer;
3125 return false;
3126 }
3127
3128 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>();
3129 assert(ToPtrType && "No member pointer cast has a target type "((ToPtrType && "No member pointer cast has a target type "
"that is not a member pointer.") ? static_cast<void> (
0) : __assert_fail ("ToPtrType && \"No member pointer cast has a target type \" \"that is not a member pointer.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3130, __PRETTY_FUNCTION__))
3130 "that is not a member pointer.")((ToPtrType && "No member pointer cast has a target type "
"that is not a member pointer.") ? static_cast<void> (
0) : __assert_fail ("ToPtrType && \"No member pointer cast has a target type \" \"that is not a member pointer.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3130, __PRETTY_FUNCTION__))
;
3131
3132 QualType FromClass = QualType(FromPtrType->getClass(), 0);
3133 QualType ToClass = QualType(ToPtrType->getClass(), 0);
3134
3135 // FIXME: What about dependent types?
3136 assert(FromClass->isRecordType() && "Pointer into non-class.")((FromClass->isRecordType() && "Pointer into non-class."
) ? static_cast<void> (0) : __assert_fail ("FromClass->isRecordType() && \"Pointer into non-class.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3136, __PRETTY_FUNCTION__))
;
3137 assert(ToClass->isRecordType() && "Pointer into non-class.")((ToClass->isRecordType() && "Pointer into non-class."
) ? static_cast<void> (0) : __assert_fail ("ToClass->isRecordType() && \"Pointer into non-class.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3137, __PRETTY_FUNCTION__))
;
3138
3139 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true,
3140 /*DetectVirtual=*/true);
3141 bool DerivationOkay =
3142 IsDerivedFrom(From->getBeginLoc(), ToClass, FromClass, Paths);
3143 assert(DerivationOkay &&((DerivationOkay && "Should not have been called if derivation isn't OK."
) ? static_cast<void> (0) : __assert_fail ("DerivationOkay && \"Should not have been called if derivation isn't OK.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3144, __PRETTY_FUNCTION__))
3144 "Should not have been called if derivation isn't OK.")((DerivationOkay && "Should not have been called if derivation isn't OK."
) ? static_cast<void> (0) : __assert_fail ("DerivationOkay && \"Should not have been called if derivation isn't OK.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3144, __PRETTY_FUNCTION__))
;
3145 (void)DerivationOkay;
3146
3147 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass).
3148 getUnqualifiedType())) {
3149 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths);
3150 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv)
3151 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange();
3152 return true;
3153 }
3154
3155 if (const RecordType *VBase = Paths.getDetectedVirtual()) {
3156 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual)
3157 << FromClass << ToClass << QualType(VBase, 0)
3158 << From->getSourceRange();
3159 return true;
3160 }
3161
3162 if (!IgnoreBaseAccess)
3163 CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass,
3164 Paths.front(),
3165 diag::err_downcast_from_inaccessible_base);
3166
3167 // Must be a base to derived member conversion.
3168 BuildBasePathArray(Paths, BasePath);
3169 Kind = CK_BaseToDerivedMemberPointer;
3170 return false;
3171}
3172
3173/// Determine whether the lifetime conversion between the two given
3174/// qualifiers sets is nontrivial.
3175static bool isNonTrivialObjCLifetimeConversion(Qualifiers FromQuals,
3176 Qualifiers ToQuals) {
3177 // Converting anything to const __unsafe_unretained is trivial.
3178 if (ToQuals.hasConst() &&
3179 ToQuals.getObjCLifetime() == Qualifiers::OCL_ExplicitNone)
3180 return false;
3181
3182 return true;
3183}
3184
3185/// Perform a single iteration of the loop for checking if a qualification
3186/// conversion is valid.
3187///
3188/// Specifically, check whether any change between the qualifiers of \p
3189/// FromType and \p ToType is permissible, given knowledge about whether every
3190/// outer layer is const-qualified.
3191static bool isQualificationConversionStep(QualType FromType, QualType ToType,
3192 bool CStyle, bool IsTopLevel,
3193 bool &PreviousToQualsIncludeConst,
3194 bool &ObjCLifetimeConversion) {
3195 Qualifiers FromQuals = FromType.getQualifiers();
3196 Qualifiers ToQuals = ToType.getQualifiers();
3197
3198 // Ignore __unaligned qualifier if this type is void.
3199 if (ToType.getUnqualifiedType()->isVoidType())
3200 FromQuals.removeUnaligned();
3201
3202 // Objective-C ARC:
3203 // Check Objective-C lifetime conversions.
3204 if (FromQuals.getObjCLifetime() != ToQuals.getObjCLifetime()) {
3205 if (ToQuals.compatiblyIncludesObjCLifetime(FromQuals)) {
3206 if (isNonTrivialObjCLifetimeConversion(FromQuals, ToQuals))
3207 ObjCLifetimeConversion = true;
3208 FromQuals.removeObjCLifetime();
3209 ToQuals.removeObjCLifetime();
3210 } else {
3211 // Qualification conversions cannot cast between different
3212 // Objective-C lifetime qualifiers.
3213 return false;
3214 }
3215 }
3216
3217 // Allow addition/removal of GC attributes but not changing GC attributes.
3218 if (FromQuals.getObjCGCAttr() != ToQuals.getObjCGCAttr() &&
3219 (!FromQuals.hasObjCGCAttr() || !ToQuals.hasObjCGCAttr())) {
3220 FromQuals.removeObjCGCAttr();
3221 ToQuals.removeObjCGCAttr();
3222 }
3223
3224 // -- for every j > 0, if const is in cv 1,j then const is in cv
3225 // 2,j, and similarly for volatile.
3226 if (!CStyle && !ToQuals.compatiblyIncludes(FromQuals))
3227 return false;
3228
3229 // If address spaces mismatch:
3230 // - in top level it is only valid to convert to addr space that is a
3231 // superset in all cases apart from C-style casts where we allow
3232 // conversions between overlapping address spaces.
3233 // - in non-top levels it is not a valid conversion.
3234 if (ToQuals.getAddressSpace() != FromQuals.getAddressSpace() &&
3235 (!IsTopLevel ||
3236 !(ToQuals.isAddressSpaceSupersetOf(FromQuals) ||
3237 (CStyle && FromQuals.isAddressSpaceSupersetOf(ToQuals)))))
3238 return false;
3239
3240 // -- if the cv 1,j and cv 2,j are different, then const is in
3241 // every cv for 0 < k < j.
3242 if (!CStyle && FromQuals.getCVRQualifiers() != ToQuals.getCVRQualifiers() &&
3243 !PreviousToQualsIncludeConst)
3244 return false;
3245
3246 // Keep track of whether all prior cv-qualifiers in the "to" type
3247 // include const.
3248 PreviousToQualsIncludeConst =
3249 PreviousToQualsIncludeConst && ToQuals.hasConst();
3250 return true;
3251}
3252
3253/// IsQualificationConversion - Determines whether the conversion from
3254/// an rvalue of type FromType to ToType is a qualification conversion
3255/// (C++ 4.4).
3256///
3257/// \param ObjCLifetimeConversion Output parameter that will be set to indicate
3258/// when the qualification conversion involves a change in the Objective-C
3259/// object lifetime.
3260bool
3261Sema::IsQualificationConversion(QualType FromType, QualType ToType,
3262 bool CStyle, bool &ObjCLifetimeConversion) {
3263 FromType = Context.getCanonicalType(FromType);
3264 ToType = Context.getCanonicalType(ToType);
3265 ObjCLifetimeConversion = false;
3266
3267 // If FromType and ToType are the same type, this is not a
3268 // qualification conversion.
3269 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType())
3270 return false;
3271
3272 // (C++ 4.4p4):
3273 // A conversion can add cv-qualifiers at levels other than the first
3274 // in multi-level pointers, subject to the following rules: [...]
3275 bool PreviousToQualsIncludeConst = true;
3276 bool UnwrappedAnyPointer = false;
3277 while (Context.UnwrapSimilarTypes(FromType, ToType)) {
3278 if (!isQualificationConversionStep(
3279 FromType, ToType, CStyle, !UnwrappedAnyPointer,
3280 PreviousToQualsIncludeConst, ObjCLifetimeConversion))
3281 return false;
3282 UnwrappedAnyPointer = true;
3283 }
3284
3285 // We are left with FromType and ToType being the pointee types
3286 // after unwrapping the original FromType and ToType the same number
3287 // of times. If we unwrapped any pointers, and if FromType and
3288 // ToType have the same unqualified type (since we checked
3289 // qualifiers above), then this is a qualification conversion.
3290 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType);
3291}
3292
3293/// - Determine whether this is a conversion from a scalar type to an
3294/// atomic type.
3295///
3296/// If successful, updates \c SCS's second and third steps in the conversion
3297/// sequence to finish the conversion.
3298static bool tryAtomicConversion(Sema &S, Expr *From, QualType ToType,
3299 bool InOverloadResolution,
3300 StandardConversionSequence &SCS,
3301 bool CStyle) {
3302 const AtomicType *ToAtomic = ToType->getAs<AtomicType>();
3303 if (!ToAtomic)
3304 return false;
3305
3306 StandardConversionSequence InnerSCS;
3307 if (!IsStandardConversion(S, From, ToAtomic->getValueType(),
3308 InOverloadResolution, InnerSCS,
3309 CStyle, /*AllowObjCWritebackConversion=*/false))
3310 return false;
3311
3312 SCS.Second = InnerSCS.Second;
3313 SCS.setToType(1, InnerSCS.getToType(1));
3314 SCS.Third = InnerSCS.Third;
3315 SCS.QualificationIncludesObjCLifetime
3316 = InnerSCS.QualificationIncludesObjCLifetime;
3317 SCS.setToType(2, InnerSCS.getToType(2));
3318 return true;
3319}
3320
3321static bool isFirstArgumentCompatibleWithType(ASTContext &Context,
3322 CXXConstructorDecl *Constructor,
3323 QualType Type) {
3324 const auto *CtorType = Constructor->getType()->castAs<FunctionProtoType>();
3325 if (CtorType->getNumParams() > 0) {
3326 QualType FirstArg = CtorType->getParamType(0);
3327 if (Context.hasSameUnqualifiedType(Type, FirstArg.getNonReferenceType()))
3328 return true;
3329 }
3330 return false;
3331}
3332
3333static OverloadingResult
3334IsInitializerListConstructorConversion(Sema &S, Expr *From, QualType ToType,
3335 CXXRecordDecl *To,
3336 UserDefinedConversionSequence &User,
3337 OverloadCandidateSet &CandidateSet,
3338 bool AllowExplicit) {
3339 CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
3340 for (auto *D : S.LookupConstructors(To)) {
3341 auto Info = getConstructorInfo(D);
3342 if (!Info)
3343 continue;
3344
3345 bool Usable = !Info.Constructor->isInvalidDecl() &&
3346 S.isInitListConstructor(Info.Constructor);
3347 if (Usable) {
3348 // If the first argument is (a reference to) the target type,
3349 // suppress conversions.
3350 bool SuppressUserConversions = isFirstArgumentCompatibleWithType(
3351 S.Context, Info.Constructor, ToType);
3352 if (Info.ConstructorTmpl)
3353 S.AddTemplateOverloadCandidate(Info.ConstructorTmpl, Info.FoundDecl,
3354 /*ExplicitArgs*/ nullptr, From,
3355 CandidateSet, SuppressUserConversions,
3356 /*PartialOverloading*/ false,
3357 AllowExplicit);
3358 else
3359 S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl, From,
3360 CandidateSet, SuppressUserConversions,
3361 /*PartialOverloading*/ false, AllowExplicit);
3362 }
3363 }
3364
3365 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3366
3367 OverloadCandidateSet::iterator Best;
3368 switch (auto Result =
3369 CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
3370 case OR_Deleted:
3371 case OR_Success: {
3372 // Record the standard conversion we used and the conversion function.
3373 CXXConstructorDecl *Constructor = cast<CXXConstructorDecl>(Best->Function);
3374 QualType ThisType = Constructor->getThisType();
3375 // Initializer lists don't have conversions as such.
3376 User.Before.setAsIdentityConversion();
3377 User.HadMultipleCandidates = HadMultipleCandidates;
3378 User.ConversionFunction = Constructor;
3379 User.FoundConversionFunction = Best->FoundDecl;
3380 User.After.setAsIdentityConversion();
3381 User.After.setFromType(ThisType->castAs<PointerType>()->getPointeeType());
3382 User.After.setAllToTypes(ToType);
3383 return Result;
3384 }
3385
3386 case OR_No_Viable_Function:
3387 return OR_No_Viable_Function;
3388 case OR_Ambiguous:
3389 return OR_Ambiguous;
3390 }
3391
3392 llvm_unreachable("Invalid OverloadResult!")::llvm::llvm_unreachable_internal("Invalid OverloadResult!", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3392)
;
3393}
3394
3395/// Determines whether there is a user-defined conversion sequence
3396/// (C++ [over.ics.user]) that converts expression From to the type
3397/// ToType. If such a conversion exists, User will contain the
3398/// user-defined conversion sequence that performs such a conversion
3399/// and this routine will return true. Otherwise, this routine returns
3400/// false and User is unspecified.
3401///
3402/// \param AllowExplicit true if the conversion should consider C++0x
3403/// "explicit" conversion functions as well as non-explicit conversion
3404/// functions (C++0x [class.conv.fct]p2).
3405///
3406/// \param AllowObjCConversionOnExplicit true if the conversion should
3407/// allow an extra Objective-C pointer conversion on uses of explicit
3408/// constructors. Requires \c AllowExplicit to also be set.
3409static OverloadingResult
3410IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType,
3411 UserDefinedConversionSequence &User,
3412 OverloadCandidateSet &CandidateSet,
3413 AllowedExplicit AllowExplicit,
3414 bool AllowObjCConversionOnExplicit) {
3415 assert(AllowExplicit != AllowedExplicit::None ||((AllowExplicit != AllowedExplicit::None || !AllowObjCConversionOnExplicit
) ? static_cast<void> (0) : __assert_fail ("AllowExplicit != AllowedExplicit::None || !AllowObjCConversionOnExplicit"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3416, __PRETTY_FUNCTION__))
3416 !AllowObjCConversionOnExplicit)((AllowExplicit != AllowedExplicit::None || !AllowObjCConversionOnExplicit
) ? static_cast<void> (0) : __assert_fail ("AllowExplicit != AllowedExplicit::None || !AllowObjCConversionOnExplicit"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3416, __PRETTY_FUNCTION__))
;
3417 CandidateSet.clear(OverloadCandidateSet::CSK_InitByUserDefinedConversion);
3418
3419 // Whether we will only visit constructors.
3420 bool ConstructorsOnly = false;
3421
3422 // If the type we are conversion to is a class type, enumerate its
3423 // constructors.
3424 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) {
3425 // C++ [over.match.ctor]p1:
3426 // When objects of class type are direct-initialized (8.5), or
3427 // copy-initialized from an expression of the same or a
3428 // derived class type (8.5), overload resolution selects the
3429 // constructor. [...] For copy-initialization, the candidate
3430 // functions are all the converting constructors (12.3.1) of
3431 // that class. The argument list is the expression-list within
3432 // the parentheses of the initializer.
3433 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) ||
3434 (From->getType()->getAs<RecordType>() &&
3435 S.IsDerivedFrom(From->getBeginLoc(), From->getType(), ToType)))
3436 ConstructorsOnly = true;
3437
3438 if (!S.isCompleteType(From->getExprLoc(), ToType)) {
3439 // We're not going to find any constructors.
3440 } else if (CXXRecordDecl *ToRecordDecl
3441 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) {
3442
3443 Expr **Args = &From;
3444 unsigned NumArgs = 1;
3445 bool ListInitializing = false;
3446 if (InitListExpr *InitList = dyn_cast<InitListExpr>(From)) {
3447 // But first, see if there is an init-list-constructor that will work.
3448 OverloadingResult Result = IsInitializerListConstructorConversion(
3449 S, From, ToType, ToRecordDecl, User, CandidateSet,
3450 AllowExplicit == AllowedExplicit::All);
3451 if (Result != OR_No_Viable_Function)
3452 return Result;
3453 // Never mind.
3454 CandidateSet.clear(
3455 OverloadCandidateSet::CSK_InitByUserDefinedConversion);
3456
3457 // If we're list-initializing, we pass the individual elements as
3458 // arguments, not the entire list.
3459 Args = InitList->getInits();
3460 NumArgs = InitList->getNumInits();
3461 ListInitializing = true;
3462 }
3463
3464 for (auto *D : S.LookupConstructors(ToRecordDecl)) {
3465 auto Info = getConstructorInfo(D);
3466 if (!Info)
3467 continue;
3468
3469 bool Usable = !Info.Constructor->isInvalidDecl();
3470 if (!ListInitializing)
3471 Usable = Usable && Info.Constructor->isConvertingConstructor(
3472 /*AllowExplicit*/ true);
3473 if (Usable) {
3474 bool SuppressUserConversions = !ConstructorsOnly;
3475 if (SuppressUserConversions && ListInitializing) {
3476 SuppressUserConversions = false;
3477 if (NumArgs == 1) {
3478 // If the first argument is (a reference to) the target type,
3479 // suppress conversions.
3480 SuppressUserConversions = isFirstArgumentCompatibleWithType(
3481 S.Context, Info.Constructor, ToType);
3482 }
3483 }
3484 if (Info.ConstructorTmpl)
3485 S.AddTemplateOverloadCandidate(
3486 Info.ConstructorTmpl, Info.FoundDecl,
3487 /*ExplicitArgs*/ nullptr, llvm::makeArrayRef(Args, NumArgs),
3488 CandidateSet, SuppressUserConversions,
3489 /*PartialOverloading*/ false,
3490 AllowExplicit == AllowedExplicit::All);
3491 else
3492 // Allow one user-defined conversion when user specifies a
3493 // From->ToType conversion via an static cast (c-style, etc).
3494 S.AddOverloadCandidate(Info.Constructor, Info.FoundDecl,
3495 llvm::makeArrayRef(Args, NumArgs),
3496 CandidateSet, SuppressUserConversions,
3497 /*PartialOverloading*/ false,
3498 AllowExplicit == AllowedExplicit::All);
3499 }
3500 }
3501 }
3502 }
3503
3504 // Enumerate conversion functions, if we're allowed to.
3505 if (ConstructorsOnly || isa<InitListExpr>(From)) {
3506 } else if (!S.isCompleteType(From->getBeginLoc(), From->getType())) {
3507 // No conversion functions from incomplete types.
3508 } else if (const RecordType *FromRecordType =
3509 From->getType()->getAs<RecordType>()) {
3510 if (CXXRecordDecl *FromRecordDecl
3511 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) {
3512 // Add all of the conversion functions as candidates.
3513 const auto &Conversions = FromRecordDecl->getVisibleConversionFunctions();
3514 for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
3515 DeclAccessPair FoundDecl = I.getPair();
3516 NamedDecl *D = FoundDecl.getDecl();
3517 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
3518 if (isa<UsingShadowDecl>(D))
3519 D = cast<UsingShadowDecl>(D)->getTargetDecl();
3520
3521 CXXConversionDecl *Conv;
3522 FunctionTemplateDecl *ConvTemplate;
3523 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
3524 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
3525 else
3526 Conv = cast<CXXConversionDecl>(D);
3527
3528 if (ConvTemplate)
3529 S.AddTemplateConversionCandidate(
3530 ConvTemplate, FoundDecl, ActingContext, From, ToType,
3531 CandidateSet, AllowObjCConversionOnExplicit,
3532 AllowExplicit != AllowedExplicit::None);
3533 else
3534 S.AddConversionCandidate(Conv, FoundDecl, ActingContext, From, ToType,
3535 CandidateSet, AllowObjCConversionOnExplicit,
3536 AllowExplicit != AllowedExplicit::None);
3537 }
3538 }
3539 }
3540
3541 bool HadMultipleCandidates = (CandidateSet.size() > 1);
3542
3543 OverloadCandidateSet::iterator Best;
3544 switch (auto Result =
3545 CandidateSet.BestViableFunction(S, From->getBeginLoc(), Best)) {
3546 case OR_Success:
3547 case OR_Deleted:
3548 // Record the standard conversion we used and the conversion function.
3549 if (CXXConstructorDecl *Constructor
3550 = dyn_cast<CXXConstructorDecl>(Best->Function)) {
3551 // C++ [over.ics.user]p1:
3552 // If the user-defined conversion is specified by a
3553 // constructor (12.3.1), the initial standard conversion
3554 // sequence converts the source type to the type required by
3555 // the argument of the constructor.
3556 //
3557 QualType ThisType = Constructor->getThisType();
3558 if (isa<InitListExpr>(From)) {
3559 // Initializer lists don't have conversions as such.
3560 User.Before.setAsIdentityConversion();
3561 } else {
3562 if (Best->Conversions[0].isEllipsis())
3563 User.EllipsisConversion = true;
3564 else {
3565 User.Before = Best->Conversions[0].Standard;
3566 User.EllipsisConversion = false;
3567 }
3568 }
3569 User.HadMultipleCandidates = HadMultipleCandidates;
3570 User.ConversionFunction = Constructor;
3571 User.FoundConversionFunction = Best->FoundDecl;
3572 User.After.setAsIdentityConversion();
3573 User.After.setFromType(ThisType->castAs<PointerType>()->getPointeeType());
3574 User.After.setAllToTypes(ToType);
3575 return Result;
3576 }
3577 if (CXXConversionDecl *Conversion
3578 = dyn_cast<CXXConversionDecl>(Best->Function)) {
3579 // C++ [over.ics.user]p1:
3580 //
3581 // [...] If the user-defined conversion is specified by a
3582 // conversion function (12.3.2), the initial standard
3583 // conversion sequence converts the source type to the
3584 // implicit object parameter of the conversion function.
3585 User.Before = Best->Conversions[0].Standard;
3586 User.HadMultipleCandidates = HadMultipleCandidates;
3587 User.ConversionFunction = Conversion;
3588 User.FoundConversionFunction = Best->FoundDecl;
3589 User.EllipsisConversion = false;
3590
3591 // C++ [over.ics.user]p2:
3592 // The second standard conversion sequence converts the
3593 // result of the user-defined conversion to the target type
3594 // for the sequence. Since an implicit conversion sequence
3595 // is an initialization, the special rules for
3596 // initialization by user-defined conversion apply when
3597 // selecting the best user-defined conversion for a
3598 // user-defined conversion sequence (see 13.3.3 and
3599 // 13.3.3.1).
3600 User.After = Best->FinalConversion;
3601 return Result;
3602 }
3603 llvm_unreachable("Not a constructor or conversion function?")::llvm::llvm_unreachable_internal("Not a constructor or conversion function?"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3603)
;
3604
3605 case OR_No_Viable_Function:
3606 return OR_No_Viable_Function;
3607
3608 case OR_Ambiguous:
3609 return OR_Ambiguous;
3610 }
3611
3612 llvm_unreachable("Invalid OverloadResult!")::llvm::llvm_unreachable_internal("Invalid OverloadResult!", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 3612)
;
3613}
3614
3615bool
3616Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) {
3617 ImplicitConversionSequence ICS;
3618 OverloadCandidateSet CandidateSet(From->getExprLoc(),
3619 OverloadCandidateSet::CSK_Normal);
3620 OverloadingResult OvResult =
3621 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined,
3622 CandidateSet, AllowedExplicit::None, false);
3623
3624 if (!(OvResult == OR_Ambiguous ||
3625 (OvResult == OR_No_Viable_Function && !CandidateSet.empty())))
3626 return false;
3627
3628 auto Cands = CandidateSet.CompleteCandidates(
3629 *this,
3630 OvResult == OR_Ambiguous ? OCD_AmbiguousCandidates : OCD_AllCandidates,
3631 From);
3632 if (OvResult == OR_Ambiguous)
3633 Diag(From->getBeginLoc(), diag::err_typecheck_ambiguous_condition)
3634 << From->getType() << ToType << From->getSourceRange();
3635 else { // OR_No_Viable_Function && !CandidateSet.empty()
3636 if (!RequireCompleteType(From->getBeginLoc(), ToType,
3637 diag::err_typecheck_nonviable_condition_incomplete,
3638 From->getType(), From->getSourceRange()))
3639 Diag(From->getBeginLoc(), diag::err_typecheck_nonviable_condition)
3640 << false << From->getType() << From->getSourceRange() << ToType;
3641 }
3642
3643 CandidateSet.NoteCandidates(
3644 *this, From, Cands);
3645 return true;
3646}
3647
3648/// Compare the user-defined conversion functions or constructors
3649/// of two user-defined conversion sequences to determine whether any ordering
3650/// is possible.
3651static ImplicitConversionSequence::CompareKind
3652compareConversionFunctions(Sema &S, FunctionDecl *Function1,
3653 FunctionDecl *Function2) {
3654 if (!S.getLangOpts().ObjC || !S.getLangOpts().CPlusPlus11)
3655 return ImplicitConversionSequence::Indistinguishable;
3656
3657 // Objective-C++:
3658 // If both conversion functions are implicitly-declared conversions from
3659 // a lambda closure type to a function pointer and a block pointer,
3660 // respectively, always prefer the conversion to a function pointer,
3661 // because the function pointer is more lightweight and is more likely
3662 // to keep code working.
3663 CXXConversionDecl *Conv1 = dyn_cast_or_null<CXXConversionDecl>(Function1);
3664 if (!Conv1)
3665 return ImplicitConversionSequence::Indistinguishable;
3666
3667 CXXConversionDecl *Conv2 = dyn_cast<CXXConversionDecl>(Function2);
3668 if (!Conv2)
3669 return ImplicitConversionSequence::Indistinguishable;
3670
3671 if (Conv1->getParent()->isLambda() && Conv2->getParent()->isLambda()) {
3672 bool Block1 = Conv1->getConversionType()->isBlockPointerType();
3673 bool Block2 = Conv2->getConversionType()->isBlockPointerType();
3674 if (Block1 != Block2)
3675 return Block1 ? ImplicitConversionSequence::Worse
3676 : ImplicitConversionSequence::Better;
3677 }
3678
3679 return ImplicitConversionSequence::Indistinguishable;
3680}
3681
3682static bool hasDeprecatedStringLiteralToCharPtrConversion(
3683 const ImplicitConversionSequence &ICS) {
3684 return (ICS.isStandard() && ICS.Standard.DeprecatedStringLiteralToCharPtr) ||
3685 (ICS.isUserDefined() &&
3686 ICS.UserDefined.Before.DeprecatedStringLiteralToCharPtr);
3687}
3688
3689/// CompareImplicitConversionSequences - Compare two implicit
3690/// conversion sequences to determine whether one is better than the
3691/// other or if they are indistinguishable (C++ 13.3.3.2).
3692static ImplicitConversionSequence::CompareKind
3693CompareImplicitConversionSequences(Sema &S, SourceLocation Loc,
3694 const ImplicitConversionSequence& ICS1,
3695 const ImplicitConversionSequence& ICS2)
3696{
3697 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit
3698 // conversion sequences (as defined in 13.3.3.1)
3699 // -- a standard conversion sequence (13.3.3.1.1) is a better
3700 // conversion sequence than a user-defined conversion sequence or
3701 // an ellipsis conversion sequence, and
3702 // -- a user-defined conversion sequence (13.3.3.1.2) is a better
3703 // conversion sequence than an ellipsis conversion sequence
3704 // (13.3.3.1.3).
3705 //
3706 // C++0x [over.best.ics]p10:
3707 // For the purpose of ranking implicit conversion sequences as
3708 // described in 13.3.3.2, the ambiguous conversion sequence is
3709 // treated as a user-defined sequence that is indistinguishable
3710 // from any other user-defined conversion sequence.
3711
3712 // String literal to 'char *' conversion has been deprecated in C++03. It has
3713 // been removed from C++11. We still accept this conversion, if it happens at
3714 // the best viable function. Otherwise, this conversion is considered worse
3715 // than ellipsis conversion. Consider this as an extension; this is not in the
3716 // standard. For example:
3717 //
3718 // int &f(...); // #1
3719 // void f(char*); // #2
3720 // void g() { int &r = f("foo"); }
3721 //
3722 // In C++03, we pick #2 as the best viable function.
3723 // In C++11, we pick #1 as the best viable function, because ellipsis
3724 // conversion is better than string-literal to char* conversion (since there
3725 // is no such conversion in C++11). If there was no #1 at all or #1 couldn't
3726 // convert arguments, #2 would be the best viable function in C++11.
3727 // If the best viable function has this conversion, a warning will be issued
3728 // in C++03, or an ExtWarn (+SFINAE failure) will be issued in C++11.
3729
3730 if (S.getLangOpts().CPlusPlus11 && !S.getLangOpts().WritableStrings &&
3731 hasDeprecatedStringLiteralToCharPtrConversion(ICS1) !=
3732 hasDeprecatedStringLiteralToCharPtrConversion(ICS2))
3733 return hasDeprecatedStringLiteralToCharPtrConversion(ICS1)
3734 ? ImplicitConversionSequence::Worse
3735 : ImplicitConversionSequence::Better;
3736
3737 if (ICS1.getKindRank() < ICS2.getKindRank())
3738 return ImplicitConversionSequence::Better;
3739 if (ICS2.getKindRank() < ICS1.getKindRank())
3740 return ImplicitConversionSequence::Worse;
3741
3742 // The following checks require both conversion sequences to be of
3743 // the same kind.
3744 if (ICS1.getKind() != ICS2.getKind())
3745 return ImplicitConversionSequence::Indistinguishable;
3746
3747 ImplicitConversionSequence::CompareKind Result =
3748 ImplicitConversionSequence::Indistinguishable;
3749
3750 // Two implicit conversion sequences of the same form are
3751 // indistinguishable conversion sequences unless one of the
3752 // following rules apply: (C++ 13.3.3.2p3):
3753
3754 // List-initialization sequence L1 is a better conversion sequence than
3755 // list-initialization sequence L2 if:
3756 // - L1 converts to std::initializer_list<X> for some X and L2 does not, or,
3757 // if not that,
3758 // - L1 converts to type "array of N1 T", L2 converts to type "array of N2 T",
3759 // and N1 is smaller than N2.,
3760 // even if one of the other rules in this paragraph would otherwise apply.
3761 if (!ICS1.isBad()) {
3762 if (ICS1.isStdInitializerListElement() &&
3763 !ICS2.isStdInitializerListElement())
3764 return ImplicitConversionSequence::Better;
3765 if (!ICS1.isStdInitializerListElement() &&
3766 ICS2.isStdInitializerListElement())
3767 return ImplicitConversionSequence::Worse;
3768 }
3769
3770 if (ICS1.isStandard())
3771 // Standard conversion sequence S1 is a better conversion sequence than
3772 // standard conversion sequence S2 if [...]
3773 Result = CompareStandardConversionSequences(S, Loc,
3774 ICS1.Standard, ICS2.Standard);
3775 else if (ICS1.isUserDefined()) {
3776 // User-defined conversion sequence U1 is a better conversion
3777 // sequence than another user-defined conversion sequence U2 if
3778 // they contain the same user-defined conversion function or
3779 // constructor and if the second standard conversion sequence of
3780 // U1 is better than the second standard conversion sequence of
3781 // U2 (C++ 13.3.3.2p3).
3782 if (ICS1.UserDefined.ConversionFunction ==
3783 ICS2.UserDefined.ConversionFunction)
3784 Result = CompareStandardConversionSequences(S, Loc,
3785 ICS1.UserDefined.After,
3786 ICS2.UserDefined.After);
3787 else
3788 Result = compareConversionFunctions(S,
3789 ICS1.UserDefined.ConversionFunction,
3790 ICS2.UserDefined.ConversionFunction);
3791 }
3792
3793 return Result;
3794}
3795
3796// Per 13.3.3.2p3, compare the given standard conversion sequences to
3797// determine if one is a proper subset of the other.
3798static ImplicitConversionSequence::CompareKind
3799compareStandardConversionSubsets(ASTContext &Context,
3800 const StandardConversionSequence& SCS1,
3801 const StandardConversionSequence& SCS2) {
3802 ImplicitConversionSequence::CompareKind Result
3803 = ImplicitConversionSequence::Indistinguishable;
3804
3805 // the identity conversion sequence is considered to be a subsequence of
3806 // any non-identity conversion sequence
3807 if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion())
3808 return ImplicitConversionSequence::Better;
3809 else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion())
3810 return ImplicitConversionSequence::Worse;
3811
3812 if (SCS1.Second != SCS2.Second) {
3813 if (SCS1.Second == ICK_Identity)
3814 Result = ImplicitConversionSequence::Better;
3815 else if (SCS2.Second == ICK_Identity)
3816 Result = ImplicitConversionSequence::Worse;
3817 else
3818 return ImplicitConversionSequence::Indistinguishable;
3819 } else if (!Context.hasSimilarType(SCS1.getToType(1), SCS2.getToType(1)))
3820 return ImplicitConversionSequence::Indistinguishable;
3821
3822 if (SCS1.Third == SCS2.Third) {
3823 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result
3824 : ImplicitConversionSequence::Indistinguishable;
3825 }
3826
3827 if (SCS1.Third == ICK_Identity)
3828 return Result == ImplicitConversionSequence::Worse
3829 ? ImplicitConversionSequence::Indistinguishable
3830 : ImplicitConversionSequence::Better;
3831
3832 if (SCS2.Third == ICK_Identity)
3833 return Result == ImplicitConversionSequence::Better
3834 ? ImplicitConversionSequence::Indistinguishable
3835 : ImplicitConversionSequence::Worse;
3836
3837 return ImplicitConversionSequence::Indistinguishable;
3838}
3839
3840/// Determine whether one of the given reference bindings is better
3841/// than the other based on what kind of bindings they are.
3842static bool
3843isBetterReferenceBindingKind(const StandardConversionSequence &SCS1,
3844 const StandardConversionSequence &SCS2) {
3845 // C++0x [over.ics.rank]p3b4:
3846 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an
3847 // implicit object parameter of a non-static member function declared
3848 // without a ref-qualifier, and *either* S1 binds an rvalue reference
3849 // to an rvalue and S2 binds an lvalue reference *or S1 binds an
3850 // lvalue reference to a function lvalue and S2 binds an rvalue
3851 // reference*.
3852 //
3853 // FIXME: Rvalue references. We're going rogue with the above edits,
3854 // because the semantics in the current C++0x working paper (N3225 at the
3855 // time of this writing) break the standard definition of std::forward
3856 // and std::reference_wrapper when dealing with references to functions.
3857 // Proposed wording changes submitted to CWG for consideration.
3858 if (SCS1.BindsImplicitObjectArgumentWithoutRefQualifier ||
3859 SCS2.BindsImplicitObjectArgumentWithoutRefQualifier)
3860 return false;
3861
3862 return (!SCS1.IsLvalueReference && SCS1.BindsToRvalue &&
3863 SCS2.IsLvalueReference) ||
3864 (SCS1.IsLvalueReference && SCS1.BindsToFunctionLvalue &&
3865 !SCS2.IsLvalueReference && SCS2.BindsToFunctionLvalue);
3866}
3867
3868enum class FixedEnumPromotion {
3869 None,
3870 ToUnderlyingType,
3871 ToPromotedUnderlyingType
3872};
3873
3874/// Returns kind of fixed enum promotion the \a SCS uses.
3875static FixedEnumPromotion
3876getFixedEnumPromtion(Sema &S, const StandardConversionSequence &SCS) {
3877
3878 if (SCS.Second != ICK_Integral_Promotion)
3879 return FixedEnumPromotion::None;
3880
3881 QualType FromType = SCS.getFromType();
3882 if (!FromType->isEnumeralType())
3883 return FixedEnumPromotion::None;
3884
3885 EnumDecl *Enum = FromType->getAs<EnumType>()->getDecl();
3886 if (!Enum->isFixed())
3887 return FixedEnumPromotion::None;
3888
3889 QualType UnderlyingType = Enum->getIntegerType();
3890 if (S.Context.hasSameType(SCS.getToType(1), UnderlyingType))
3891 return FixedEnumPromotion::ToUnderlyingType;
3892
3893 return FixedEnumPromotion::ToPromotedUnderlyingType;
3894}
3895
3896/// CompareStandardConversionSequences - Compare two standard
3897/// conversion sequences to determine whether one is better than the
3898/// other or if they are indistinguishable (C++ 13.3.3.2p3).
3899static ImplicitConversionSequence::CompareKind
3900CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
3901 const StandardConversionSequence& SCS1,
3902 const StandardConversionSequence& SCS2)
3903{
3904 // Standard conversion sequence S1 is a better conversion sequence
3905 // than standard conversion sequence S2 if (C++ 13.3.3.2p3):
3906
3907 // -- S1 is a proper subsequence of S2 (comparing the conversion
3908 // sequences in the canonical form defined by 13.3.3.1.1,
3909 // excluding any Lvalue Transformation; the identity conversion
3910 // sequence is considered to be a subsequence of any
3911 // non-identity conversion sequence) or, if not that,
3912 if (ImplicitConversionSequence::CompareKind CK
3913 = compareStandardConversionSubsets(S.Context, SCS1, SCS2))
3914 return CK;
3915
3916 // -- the rank of S1 is better than the rank of S2 (by the rules
3917 // defined below), or, if not that,
3918 ImplicitConversionRank Rank1 = SCS1.getRank();
3919 ImplicitConversionRank Rank2 = SCS2.getRank();
3920 if (Rank1 < Rank2)
3921 return ImplicitConversionSequence::Better;
3922 else if (Rank2 < Rank1)
3923 return ImplicitConversionSequence::Worse;
3924
3925 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank
3926 // are indistinguishable unless one of the following rules
3927 // applies:
3928
3929 // A conversion that is not a conversion of a pointer, or
3930 // pointer to member, to bool is better than another conversion
3931 // that is such a conversion.
3932 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool())
3933 return SCS2.isPointerConversionToBool()
3934 ? ImplicitConversionSequence::Better
3935 : ImplicitConversionSequence::Worse;
3936
3937 // C++14 [over.ics.rank]p4b2:
3938 // This is retroactively applied to C++11 by CWG 1601.
3939 //
3940 // A conversion that promotes an enumeration whose underlying type is fixed
3941 // to its underlying type is better than one that promotes to the promoted
3942 // underlying type, if the two are different.
3943 FixedEnumPromotion FEP1 = getFixedEnumPromtion(S, SCS1);
3944 FixedEnumPromotion FEP2 = getFixedEnumPromtion(S, SCS2);
3945 if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
3946 FEP1 != FEP2)
3947 return FEP1 == FixedEnumPromotion::ToUnderlyingType
3948 ? ImplicitConversionSequence::Better
3949 : ImplicitConversionSequence::Worse;
3950
3951 // C++ [over.ics.rank]p4b2:
3952 //
3953 // If class B is derived directly or indirectly from class A,
3954 // conversion of B* to A* is better than conversion of B* to
3955 // void*, and conversion of A* to void* is better than conversion
3956 // of B* to void*.
3957 bool SCS1ConvertsToVoid
3958 = SCS1.isPointerConversionToVoidPointer(S.Context);
3959 bool SCS2ConvertsToVoid
3960 = SCS2.isPointerConversionToVoidPointer(S.Context);
3961 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) {
3962 // Exactly one of the conversion sequences is a conversion to
3963 // a void pointer; it's the worse conversion.
3964 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better
3965 : ImplicitConversionSequence::Worse;
3966 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) {
3967 // Neither conversion sequence converts to a void pointer; compare
3968 // their derived-to-base conversions.
3969 if (ImplicitConversionSequence::CompareKind DerivedCK
3970 = CompareDerivedToBaseConversions(S, Loc, SCS1, SCS2))
3971 return DerivedCK;
3972 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid &&
3973 !S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
3974 // Both conversion sequences are conversions to void
3975 // pointers. Compare the source types to determine if there's an
3976 // inheritance relationship in their sources.
3977 QualType FromType1 = SCS1.getFromType();
3978 QualType FromType2 = SCS2.getFromType();
3979
3980 // Adjust the types we're converting from via the array-to-pointer
3981 // conversion, if we need to.
3982 if (SCS1.First == ICK_Array_To_Pointer)
3983 FromType1 = S.Context.getArrayDecayedType(FromType1);
3984 if (SCS2.First == ICK_Array_To_Pointer)
3985 FromType2 = S.Context.getArrayDecayedType(FromType2);
3986
3987 QualType FromPointee1 = FromType1->getPointeeType().getUnqualifiedType();
3988 QualType FromPointee2 = FromType2->getPointeeType().getUnqualifiedType();
3989
3990 if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
3991 return ImplicitConversionSequence::Better;
3992 else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
3993 return ImplicitConversionSequence::Worse;
3994
3995 // Objective-C++: If one interface is more specific than the
3996 // other, it is the better one.
3997 const ObjCObjectPointerType* FromObjCPtr1
3998 = FromType1->getAs<ObjCObjectPointerType>();
3999 const ObjCObjectPointerType* FromObjCPtr2
4000 = FromType2->getAs<ObjCObjectPointerType>();
4001 if (FromObjCPtr1 && FromObjCPtr2) {
4002 bool AssignLeft = S.Context.canAssignObjCInterfaces(FromObjCPtr1,
4003 FromObjCPtr2);
4004 bool AssignRight = S.Context.canAssignObjCInterfaces(FromObjCPtr2,
4005 FromObjCPtr1);
4006 if (AssignLeft != AssignRight) {
4007 return AssignLeft? ImplicitConversionSequence::Better
4008 : ImplicitConversionSequence::Worse;
4009 }
4010 }
4011 }
4012
4013 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
4014 // Check for a better reference binding based on the kind of bindings.
4015 if (isBetterReferenceBindingKind(SCS1, SCS2))
4016 return ImplicitConversionSequence::Better;
4017 else if (isBetterReferenceBindingKind(SCS2, SCS1))
4018 return ImplicitConversionSequence::Worse;
4019 }
4020
4021 // Compare based on qualification conversions (C++ 13.3.3.2p3,
4022 // bullet 3).
4023 if (ImplicitConversionSequence::CompareKind QualCK
4024 = CompareQualificationConversions(S, SCS1, SCS2))
4025 return QualCK;
4026
4027 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) {
4028 // C++ [over.ics.rank]p3b4:
4029 // -- S1 and S2 are reference bindings (8.5.3), and the types to
4030 // which the references refer are the same type except for
4031 // top-level cv-qualifiers, and the type to which the reference
4032 // initialized by S2 refers is more cv-qualified than the type
4033 // to which the reference initialized by S1 refers.
4034 QualType T1 = SCS1.getToType(2);
4035 QualType T2 = SCS2.getToType(2);
4036 T1 = S.Context.getCanonicalType(T1);
4037 T2 = S.Context.getCanonicalType(T2);
4038 Qualifiers T1Quals, T2Quals;
4039 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
4040 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
4041 if (UnqualT1 == UnqualT2) {
4042 // Objective-C++ ARC: If the references refer to objects with different
4043 // lifetimes, prefer bindings that don't change lifetime.
4044 if (SCS1.ObjCLifetimeConversionBinding !=
4045 SCS2.ObjCLifetimeConversionBinding) {
4046 return SCS1.ObjCLifetimeConversionBinding
4047 ? ImplicitConversionSequence::Worse
4048 : ImplicitConversionSequence::Better;
4049 }
4050
4051 // If the type is an array type, promote the element qualifiers to the
4052 // type for comparison.
4053 if (isa<ArrayType>(T1) && T1Quals)
4054 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals);
4055 if (isa<ArrayType>(T2) && T2Quals)
4056 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals);
4057 if (T2.isMoreQualifiedThan(T1))
4058 return ImplicitConversionSequence::Better;
4059 if (T1.isMoreQualifiedThan(T2))
4060 return ImplicitConversionSequence::Worse;
4061 }
4062 }
4063
4064 // In Microsoft mode, prefer an integral conversion to a
4065 // floating-to-integral conversion if the integral conversion
4066 // is between types of the same size.
4067 // For example:
4068 // void f(float);
4069 // void f(int);
4070 // int main {
4071 // long a;
4072 // f(a);
4073 // }
4074 // Here, MSVC will call f(int) instead of generating a compile error
4075 // as clang will do in standard mode.
4076 if (S.getLangOpts().MSVCCompat && SCS1.Second == ICK_Integral_Conversion &&
4077 SCS2.Second == ICK_Floating_Integral &&
4078 S.Context.getTypeSize(SCS1.getFromType()) ==
4079 S.Context.getTypeSize(SCS1.getToType(2)))
4080 return ImplicitConversionSequence::Better;
4081
4082 // Prefer a compatible vector conversion over a lax vector conversion
4083 // For example:
4084 //
4085 // typedef float __v4sf __attribute__((__vector_size__(16)));
4086 // void f(vector float);
4087 // void f(vector signed int);
4088 // int main() {
4089 // __v4sf a;
4090 // f(a);
4091 // }
4092 // Here, we'd like to choose f(vector float) and not
4093 // report an ambiguous call error
4094 if (SCS1.Second == ICK_Vector_Conversion &&
4095 SCS2.Second == ICK_Vector_Conversion) {
4096 bool SCS1IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
4097 SCS1.getFromType(), SCS1.getToType(2));
4098 bool SCS2IsCompatibleVectorConversion = S.Context.areCompatibleVectorTypes(
4099 SCS2.getFromType(), SCS2.getToType(2));
4100
4101 if (SCS1IsCompatibleVectorConversion != SCS2IsCompatibleVectorConversion)
4102 return SCS1IsCompatibleVectorConversion
4103 ? ImplicitConversionSequence::Better
4104 : ImplicitConversionSequence::Worse;
4105 }
4106
4107 if (SCS1.Second == ICK_SVE_Vector_Conversion &&
4108 SCS2.Second == ICK_SVE_Vector_Conversion) {
4109 bool SCS1IsCompatibleSVEVectorConversion =
4110 S.Context.areCompatibleSveTypes(SCS1.getFromType(), SCS1.getToType(2));
4111 bool SCS2IsCompatibleSVEVectorConversion =
4112 S.Context.areCompatibleSveTypes(SCS2.getFromType(), SCS2.getToType(2));
4113
4114 if (SCS1IsCompatibleSVEVectorConversion !=
4115 SCS2IsCompatibleSVEVectorConversion)
4116 return SCS1IsCompatibleSVEVectorConversion
4117 ? ImplicitConversionSequence::Better
4118 : ImplicitConversionSequence::Worse;
4119 }
4120
4121 return ImplicitConversionSequence::Indistinguishable;
4122}
4123
4124/// CompareQualificationConversions - Compares two standard conversion
4125/// sequences to determine whether they can be ranked based on their
4126/// qualification conversions (C++ 13.3.3.2p3 bullet 3).
4127static ImplicitConversionSequence::CompareKind
4128CompareQualificationConversions(Sema &S,
4129 const StandardConversionSequence& SCS1,
4130 const StandardConversionSequence& SCS2) {
4131 // C++ 13.3.3.2p3:
4132 // -- S1 and S2 differ only in their qualification conversion and
4133 // yield similar types T1 and T2 (C++ 4.4), respectively, and the
4134 // cv-qualification signature of type T1 is a proper subset of
4135 // the cv-qualification signature of type T2, and S1 is not the
4136 // deprecated string literal array-to-pointer conversion (4.2).
4137 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second ||
4138 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification)
4139 return ImplicitConversionSequence::Indistinguishable;
4140
4141 // FIXME: the example in the standard doesn't use a qualification
4142 // conversion (!)
4143 QualType T1 = SCS1.getToType(2);
4144 QualType T2 = SCS2.getToType(2);
4145 T1 = S.Context.getCanonicalType(T1);
4146 T2 = S.Context.getCanonicalType(T2);
4147 assert(!T1->isReferenceType() && !T2->isReferenceType())((!T1->isReferenceType() && !T2->isReferenceType
()) ? static_cast<void> (0) : __assert_fail ("!T1->isReferenceType() && !T2->isReferenceType()"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4147, __PRETTY_FUNCTION__))
;
4148 Qualifiers T1Quals, T2Quals;
4149 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals);
4150 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals);
4151
4152 // If the types are the same, we won't learn anything by unwrapping
4153 // them.
4154 if (UnqualT1 == UnqualT2)
4155 return ImplicitConversionSequence::Indistinguishable;
4156
4157 ImplicitConversionSequence::CompareKind Result
4158 = ImplicitConversionSequence::Indistinguishable;
4159
4160 // Objective-C++ ARC:
4161 // Prefer qualification conversions not involving a change in lifetime
4162 // to qualification conversions that do not change lifetime.
4163 if (SCS1.QualificationIncludesObjCLifetime !=
4164 SCS2.QualificationIncludesObjCLifetime) {
4165 Result = SCS1.QualificationIncludesObjCLifetime
4166 ? ImplicitConversionSequence::Worse
4167 : ImplicitConversionSequence::Better;
4168 }
4169
4170 while (S.Context.UnwrapSimilarTypes(T1, T2)) {
4171 // Within each iteration of the loop, we check the qualifiers to
4172 // determine if this still looks like a qualification
4173 // conversion. Then, if all is well, we unwrap one more level of
4174 // pointers or pointers-to-members and do it all again
4175 // until there are no more pointers or pointers-to-members left
4176 // to unwrap. This essentially mimics what
4177 // IsQualificationConversion does, but here we're checking for a
4178 // strict subset of qualifiers.
4179 if (T1.getQualifiers().withoutObjCLifetime() ==
4180 T2.getQualifiers().withoutObjCLifetime())
4181 // The qualifiers are the same, so this doesn't tell us anything
4182 // about how the sequences rank.
4183 // ObjC ownership quals are omitted above as they interfere with
4184 // the ARC overload rule.
4185 ;
4186 else if (T2.isMoreQualifiedThan(T1)) {
4187 // T1 has fewer qualifiers, so it could be the better sequence.
4188 if (Result == ImplicitConversionSequence::Worse)
4189 // Neither has qualifiers that are a subset of the other's
4190 // qualifiers.
4191 return ImplicitConversionSequence::Indistinguishable;
4192
4193 Result = ImplicitConversionSequence::Better;
4194 } else if (T1.isMoreQualifiedThan(T2)) {
4195 // T2 has fewer qualifiers, so it could be the better sequence.
4196 if (Result == ImplicitConversionSequence::Better)
4197 // Neither has qualifiers that are a subset of the other's
4198 // qualifiers.
4199 return ImplicitConversionSequence::Indistinguishable;
4200
4201 Result = ImplicitConversionSequence::Worse;
4202 } else {
4203 // Qualifiers are disjoint.
4204 return ImplicitConversionSequence::Indistinguishable;
4205 }
4206
4207 // If the types after this point are equivalent, we're done.
4208 if (S.Context.hasSameUnqualifiedType(T1, T2))
4209 break;
4210 }
4211
4212 // Check that the winning standard conversion sequence isn't using
4213 // the deprecated string literal array to pointer conversion.
4214 switch (Result) {
4215 case ImplicitConversionSequence::Better:
4216 if (SCS1.DeprecatedStringLiteralToCharPtr)
4217 Result = ImplicitConversionSequence::Indistinguishable;
4218 break;
4219
4220 case ImplicitConversionSequence::Indistinguishable:
4221 break;
4222
4223 case ImplicitConversionSequence::Worse:
4224 if (SCS2.DeprecatedStringLiteralToCharPtr)
4225 Result = ImplicitConversionSequence::Indistinguishable;
4226 break;
4227 }
4228
4229 return Result;
4230}
4231
4232/// CompareDerivedToBaseConversions - Compares two standard conversion
4233/// sequences to determine whether they can be ranked based on their
4234/// various kinds of derived-to-base conversions (C++
4235/// [over.ics.rank]p4b3). As part of these checks, we also look at
4236/// conversions between Objective-C interface types.
4237static ImplicitConversionSequence::CompareKind
4238CompareDerivedToBaseConversions(Sema &S, SourceLocation Loc,
4239 const StandardConversionSequence& SCS1,
4240 const StandardConversionSequence& SCS2) {
4241 QualType FromType1 = SCS1.getFromType();
4242 QualType ToType1 = SCS1.getToType(1);
4243 QualType FromType2 = SCS2.getFromType();
4244 QualType ToType2 = SCS2.getToType(1);
4245
4246 // Adjust the types we're converting from via the array-to-pointer
4247 // conversion, if we need to.
4248 if (SCS1.First == ICK_Array_To_Pointer)
4249 FromType1 = S.Context.getArrayDecayedType(FromType1);
4250 if (SCS2.First == ICK_Array_To_Pointer)
4251 FromType2 = S.Context.getArrayDecayedType(FromType2);
4252
4253 // Canonicalize all of the types.
4254 FromType1 = S.Context.getCanonicalType(FromType1);
4255 ToType1 = S.Context.getCanonicalType(ToType1);
4256 FromType2 = S.Context.getCanonicalType(FromType2);
4257 ToType2 = S.Context.getCanonicalType(ToType2);
4258
4259 // C++ [over.ics.rank]p4b3:
4260 //
4261 // If class B is derived directly or indirectly from class A and
4262 // class C is derived directly or indirectly from B,
4263 //
4264 // Compare based on pointer conversions.
4265 if (SCS1.Second == ICK_Pointer_Conversion &&
4266 SCS2.Second == ICK_Pointer_Conversion &&
4267 /*FIXME: Remove if Objective-C id conversions get their own rank*/
4268 FromType1->isPointerType() && FromType2->isPointerType() &&
4269 ToType1->isPointerType() && ToType2->isPointerType()) {
4270 QualType FromPointee1 =
4271 FromType1->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4272 QualType ToPointee1 =
4273 ToType1->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4274 QualType FromPointee2 =
4275 FromType2->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4276 QualType ToPointee2 =
4277 ToType2->castAs<PointerType>()->getPointeeType().getUnqualifiedType();
4278
4279 // -- conversion of C* to B* is better than conversion of C* to A*,
4280 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4281 if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4282 return ImplicitConversionSequence::Better;
4283 else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4284 return ImplicitConversionSequence::Worse;
4285 }
4286
4287 // -- conversion of B* to A* is better than conversion of C* to A*,
4288 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) {
4289 if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4290 return ImplicitConversionSequence::Better;
4291 else if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4292 return ImplicitConversionSequence::Worse;
4293 }
4294 } else if (SCS1.Second == ICK_Pointer_Conversion &&
4295 SCS2.Second == ICK_Pointer_Conversion) {
4296 const ObjCObjectPointerType *FromPtr1
4297 = FromType1->getAs<ObjCObjectPointerType>();
4298 const ObjCObjectPointerType *FromPtr2
4299 = FromType2->getAs<ObjCObjectPointerType>();
4300 const ObjCObjectPointerType *ToPtr1
4301 = ToType1->getAs<ObjCObjectPointerType>();
4302 const ObjCObjectPointerType *ToPtr2
4303 = ToType2->getAs<ObjCObjectPointerType>();
4304
4305 if (FromPtr1 && FromPtr2 && ToPtr1 && ToPtr2) {
4306 // Apply the same conversion ranking rules for Objective-C pointer types
4307 // that we do for C++ pointers to class types. However, we employ the
4308 // Objective-C pseudo-subtyping relationship used for assignment of
4309 // Objective-C pointer types.
4310 bool FromAssignLeft
4311 = S.Context.canAssignObjCInterfaces(FromPtr1, FromPtr2);
4312 bool FromAssignRight
4313 = S.Context.canAssignObjCInterfaces(FromPtr2, FromPtr1);
4314 bool ToAssignLeft
4315 = S.Context.canAssignObjCInterfaces(ToPtr1, ToPtr2);
4316 bool ToAssignRight
4317 = S.Context.canAssignObjCInterfaces(ToPtr2, ToPtr1);
4318
4319 // A conversion to an a non-id object pointer type or qualified 'id'
4320 // type is better than a conversion to 'id'.
4321 if (ToPtr1->isObjCIdType() &&
4322 (ToPtr2->isObjCQualifiedIdType() || ToPtr2->getInterfaceDecl()))
4323 return ImplicitConversionSequence::Worse;
4324 if (ToPtr2->isObjCIdType() &&
4325 (ToPtr1->isObjCQualifiedIdType() || ToPtr1->getInterfaceDecl()))
4326 return ImplicitConversionSequence::Better;
4327
4328 // A conversion to a non-id object pointer type is better than a
4329 // conversion to a qualified 'id' type
4330 if (ToPtr1->isObjCQualifiedIdType() && ToPtr2->getInterfaceDecl())
4331 return ImplicitConversionSequence::Worse;
4332 if (ToPtr2->isObjCQualifiedIdType() && ToPtr1->getInterfaceDecl())
4333 return ImplicitConversionSequence::Better;
4334
4335 // A conversion to an a non-Class object pointer type or qualified 'Class'
4336 // type is better than a conversion to 'Class'.
4337 if (ToPtr1->isObjCClassType() &&
4338 (ToPtr2->isObjCQualifiedClassType() || ToPtr2->getInterfaceDecl()))
4339 return ImplicitConversionSequence::Worse;
4340 if (ToPtr2->isObjCClassType() &&
4341 (ToPtr1->isObjCQualifiedClassType() || ToPtr1->getInterfaceDecl()))
4342 return ImplicitConversionSequence::Better;
4343
4344 // A conversion to a non-Class object pointer type is better than a
4345 // conversion to a qualified 'Class' type.
4346 if (ToPtr1->isObjCQualifiedClassType() && ToPtr2->getInterfaceDecl())
4347 return ImplicitConversionSequence::Worse;
4348 if (ToPtr2->isObjCQualifiedClassType() && ToPtr1->getInterfaceDecl())
4349 return ImplicitConversionSequence::Better;
4350
4351 // -- "conversion of C* to B* is better than conversion of C* to A*,"
4352 if (S.Context.hasSameType(FromType1, FromType2) &&
4353 !FromPtr1->isObjCIdType() && !FromPtr1->isObjCClassType() &&
4354 (ToAssignLeft != ToAssignRight)) {
4355 if (FromPtr1->isSpecialized()) {
4356 // "conversion of B<A> * to B * is better than conversion of B * to
4357 // C *.
4358 bool IsFirstSame =
4359 FromPtr1->getInterfaceDecl() == ToPtr1->getInterfaceDecl();
4360 bool IsSecondSame =
4361 FromPtr1->getInterfaceDecl() == ToPtr2->getInterfaceDecl();
4362 if (IsFirstSame) {
4363 if (!IsSecondSame)
4364 return ImplicitConversionSequence::Better;
4365 } else if (IsSecondSame)
4366 return ImplicitConversionSequence::Worse;
4367 }
4368 return ToAssignLeft? ImplicitConversionSequence::Worse
4369 : ImplicitConversionSequence::Better;
4370 }
4371
4372 // -- "conversion of B* to A* is better than conversion of C* to A*,"
4373 if (S.Context.hasSameUnqualifiedType(ToType1, ToType2) &&
4374 (FromAssignLeft != FromAssignRight))
4375 return FromAssignLeft? ImplicitConversionSequence::Better
4376 : ImplicitConversionSequence::Worse;
4377 }
4378 }
4379
4380 // Ranking of member-pointer types.
4381 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member &&
4382 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() &&
4383 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) {
4384 const auto *FromMemPointer1 = FromType1->castAs<MemberPointerType>();
4385 const auto *ToMemPointer1 = ToType1->castAs<MemberPointerType>();
4386 const auto *FromMemPointer2 = FromType2->castAs<MemberPointerType>();
4387 const auto *ToMemPointer2 = ToType2->castAs<MemberPointerType>();
4388 const Type *FromPointeeType1 = FromMemPointer1->getClass();
4389 const Type *ToPointeeType1 = ToMemPointer1->getClass();
4390 const Type *FromPointeeType2 = FromMemPointer2->getClass();
4391 const Type *ToPointeeType2 = ToMemPointer2->getClass();
4392 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType();
4393 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType();
4394 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType();
4395 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType();
4396 // conversion of A::* to B::* is better than conversion of A::* to C::*,
4397 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) {
4398 if (S.IsDerivedFrom(Loc, ToPointee1, ToPointee2))
4399 return ImplicitConversionSequence::Worse;
4400 else if (S.IsDerivedFrom(Loc, ToPointee2, ToPointee1))
4401 return ImplicitConversionSequence::Better;
4402 }
4403 // conversion of B::* to C::* is better than conversion of A::* to C::*
4404 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) {
4405 if (S.IsDerivedFrom(Loc, FromPointee1, FromPointee2))
4406 return ImplicitConversionSequence::Better;
4407 else if (S.IsDerivedFrom(Loc, FromPointee2, FromPointee1))
4408 return ImplicitConversionSequence::Worse;
4409 }
4410 }
4411
4412 if (SCS1.Second == ICK_Derived_To_Base) {
4413 // -- conversion of C to B is better than conversion of C to A,
4414 // -- binding of an expression of type C to a reference of type
4415 // B& is better than binding an expression of type C to a
4416 // reference of type A&,
4417 if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4418 !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4419 if (S.IsDerivedFrom(Loc, ToType1, ToType2))
4420 return ImplicitConversionSequence::Better;
4421 else if (S.IsDerivedFrom(Loc, ToType2, ToType1))
4422 return ImplicitConversionSequence::Worse;
4423 }
4424
4425 // -- conversion of B to A is better than conversion of C to A.
4426 // -- binding of an expression of type B to a reference of type
4427 // A& is better than binding an expression of type C to a
4428 // reference of type A&,
4429 if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) &&
4430 S.Context.hasSameUnqualifiedType(ToType1, ToType2)) {
4431 if (S.IsDerivedFrom(Loc, FromType2, FromType1))
4432 return ImplicitConversionSequence::Better;
4433 else if (S.IsDerivedFrom(Loc, FromType1, FromType2))
4434 return ImplicitConversionSequence::Worse;
4435 }
4436 }
4437
4438 return ImplicitConversionSequence::Indistinguishable;
4439}
4440
4441/// Determine whether the given type is valid, e.g., it is not an invalid
4442/// C++ class.
4443static bool isTypeValid(QualType T) {
4444 if (CXXRecordDecl *Record = T->getAsCXXRecordDecl())
4445 return !Record->isInvalidDecl();
4446
4447 return true;
4448}
4449
4450static QualType withoutUnaligned(ASTContext &Ctx, QualType T) {
4451 if (!T.getQualifiers().hasUnaligned())
4452 return T;
4453
4454 Qualifiers Q;
4455 T = Ctx.getUnqualifiedArrayType(T, Q);
4456 Q.removeUnaligned();
4457 return Ctx.getQualifiedType(T, Q);
4458}
4459
4460/// CompareReferenceRelationship - Compare the two types T1 and T2 to
4461/// determine whether they are reference-compatible,
4462/// reference-related, or incompatible, for use in C++ initialization by
4463/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference
4464/// type, and the first type (T1) is the pointee type of the reference
4465/// type being initialized.
4466Sema::ReferenceCompareResult
4467Sema::CompareReferenceRelationship(SourceLocation Loc,
4468 QualType OrigT1, QualType OrigT2,
4469 ReferenceConversions *ConvOut) {
4470 assert(!OrigT1->isReferenceType() &&((!OrigT1->isReferenceType() && "T1 must be the pointee type of the reference type"
) ? static_cast<void> (0) : __assert_fail ("!OrigT1->isReferenceType() && \"T1 must be the pointee type of the reference type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4471, __PRETTY_FUNCTION__))
4471 "T1 must be the pointee type of the reference type")((!OrigT1->isReferenceType() && "T1 must be the pointee type of the reference type"
) ? static_cast<void> (0) : __assert_fail ("!OrigT1->isReferenceType() && \"T1 must be the pointee type of the reference type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4471, __PRETTY_FUNCTION__))
;
4472 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type")((!OrigT2->isReferenceType() && "T2 cannot be a reference type"
) ? static_cast<void> (0) : __assert_fail ("!OrigT2->isReferenceType() && \"T2 cannot be a reference type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4472, __PRETTY_FUNCTION__))
;
4473
4474 QualType T1 = Context.getCanonicalType(OrigT1);
4475 QualType T2 = Context.getCanonicalType(OrigT2);
4476 Qualifiers T1Quals, T2Quals;
4477 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals);
4478 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals);
4479
4480 ReferenceConversions ConvTmp;
4481 ReferenceConversions &Conv = ConvOut ? *ConvOut : ConvTmp;
4482 Conv = ReferenceConversions();
4483
4484 // C++2a [dcl.init.ref]p4:
4485 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is
4486 // reference-related to "cv2 T2" if T1 is similar to T2, or
4487 // T1 is a base class of T2.
4488 // "cv1 T1" is reference-compatible with "cv2 T2" if
4489 // a prvalue of type "pointer to cv2 T2" can be converted to the type
4490 // "pointer to cv1 T1" via a standard conversion sequence.
4491
4492 // Check for standard conversions we can apply to pointers: derived-to-base
4493 // conversions, ObjC pointer conversions, and function pointer conversions.
4494 // (Qualification conversions are checked last.)
4495 QualType ConvertedT2;
4496 if (UnqualT1 == UnqualT2) {
4497 // Nothing to do.
4498 } else if (isCompleteType(Loc, OrigT2) &&
4499 isTypeValid(UnqualT1) && isTypeValid(UnqualT2) &&
4500 IsDerivedFrom(Loc, UnqualT2, UnqualT1))
4501 Conv |= ReferenceConversions::DerivedToBase;
4502 else if (UnqualT1->isObjCObjectOrInterfaceType() &&
4503 UnqualT2->isObjCObjectOrInterfaceType() &&
4504 Context.canBindObjCObjectType(UnqualT1, UnqualT2))
4505 Conv |= ReferenceConversions::ObjC;
4506 else if (UnqualT2->isFunctionType() &&
4507 IsFunctionConversion(UnqualT2, UnqualT1, ConvertedT2)) {
4508 Conv |= ReferenceConversions::Function;
4509 // No need to check qualifiers; function types don't have them.
4510 return Ref_Compatible;
4511 }
4512 bool ConvertedReferent = Conv != 0;
4513
4514 // We can have a qualification conversion. Compute whether the types are
4515 // similar at the same time.
4516 bool PreviousToQualsIncludeConst = true;
4517 bool TopLevel = true;
4518 do {
4519 if (T1 == T2)
4520 break;
4521
4522 // We will need a qualification conversion.
4523 Conv |= ReferenceConversions::Qualification;
4524
4525 // Track whether we performed a qualification conversion anywhere other
4526 // than the top level. This matters for ranking reference bindings in
4527 // overload resolution.
4528 if (!TopLevel)
4529 Conv |= ReferenceConversions::NestedQualification;
4530
4531 // MS compiler ignores __unaligned qualifier for references; do the same.
4532 T1 = withoutUnaligned(Context, T1);
4533 T2 = withoutUnaligned(Context, T2);
4534
4535 // If we find a qualifier mismatch, the types are not reference-compatible,
4536 // but are still be reference-related if they're similar.
4537 bool ObjCLifetimeConversion = false;
4538 if (!isQualificationConversionStep(T2, T1, /*CStyle=*/false, TopLevel,
4539 PreviousToQualsIncludeConst,
4540 ObjCLifetimeConversion))
4541 return (ConvertedReferent || Context.hasSimilarType(T1, T2))
4542 ? Ref_Related
4543 : Ref_Incompatible;
4544
4545 // FIXME: Should we track this for any level other than the first?
4546 if (ObjCLifetimeConversion)
4547 Conv |= ReferenceConversions::ObjCLifetime;
4548
4549 TopLevel = false;
4550 } while (Context.UnwrapSimilarTypes(T1, T2));
4551
4552 // At this point, if the types are reference-related, we must either have the
4553 // same inner type (ignoring qualifiers), or must have already worked out how
4554 // to convert the referent.
4555 return (ConvertedReferent || Context.hasSameUnqualifiedType(T1, T2))
4556 ? Ref_Compatible
4557 : Ref_Incompatible;
4558}
4559
4560/// Look for a user-defined conversion to a value reference-compatible
4561/// with DeclType. Return true if something definite is found.
4562static bool
4563FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS,
4564 QualType DeclType, SourceLocation DeclLoc,
4565 Expr *Init, QualType T2, bool AllowRvalues,
4566 bool AllowExplicit) {
4567 assert(T2->isRecordType() && "Can only find conversions of record types.")((T2->isRecordType() && "Can only find conversions of record types."
) ? static_cast<void> (0) : __assert_fail ("T2->isRecordType() && \"Can only find conversions of record types.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4567, __PRETTY_FUNCTION__))
;
4568 auto *T2RecordDecl = cast<CXXRecordDecl>(T2->castAs<RecordType>()->getDecl());
4569
4570 OverloadCandidateSet CandidateSet(
4571 DeclLoc, OverloadCandidateSet::CSK_InitByUserDefinedConversion);
4572 const auto &Conversions = T2RecordDecl->getVisibleConversionFunctions();
4573 for (auto I = Conversions.begin(), E = Conversions.end(); I != E; ++I) {
4574 NamedDecl *D = *I;
4575 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext());
4576 if (isa<UsingShadowDecl>(D))
4577 D = cast<UsingShadowDecl>(D)->getTargetDecl();
4578
4579 FunctionTemplateDecl *ConvTemplate
4580 = dyn_cast<FunctionTemplateDecl>(D);
4581 CXXConversionDecl *Conv;
4582 if (ConvTemplate)
4583 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
4584 else
4585 Conv = cast<CXXConversionDecl>(D);
4586
4587 if (AllowRvalues) {
4588 // If we are initializing an rvalue reference, don't permit conversion
4589 // functions that return lvalues.
4590 if (!ConvTemplate && DeclType->isRValueReferenceType()) {
4591 const ReferenceType *RefType
4592 = Conv->getConversionType()->getAs<LValueReferenceType>();
4593 if (RefType && !RefType->getPointeeType()->isFunctionType())
4594 continue;
4595 }
4596
4597 if (!ConvTemplate &&
4598 S.CompareReferenceRelationship(
4599 DeclLoc,
4600 Conv->getConversionType()
4601 .getNonReferenceType()
4602 .getUnqualifiedType(),
4603 DeclType.getNonReferenceType().getUnqualifiedType()) ==
4604 Sema::Ref_Incompatible)
4605 continue;
4606 } else {
4607 // If the conversion function doesn't return a reference type,
4608 // it can't be considered for this conversion. An rvalue reference
4609 // is only acceptable if its referencee is a function type.
4610
4611 const ReferenceType *RefType =
4612 Conv->getConversionType()->getAs<ReferenceType>();
4613 if (!RefType ||
4614 (!RefType->isLValueReferenceType() &&
4615 !RefType->getPointeeType()->isFunctionType()))
4616 continue;
4617 }
4618
4619 if (ConvTemplate)
4620 S.AddTemplateConversionCandidate(
4621 ConvTemplate, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4622 /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
4623 else
4624 S.AddConversionCandidate(
4625 Conv, I.getPair(), ActingDC, Init, DeclType, CandidateSet,
4626 /*AllowObjCConversionOnExplicit=*/false, AllowExplicit);
4627 }
4628
4629 bool HadMultipleCandidates = (CandidateSet.size() > 1);
4630
4631 OverloadCandidateSet::iterator Best;
4632 switch (CandidateSet.BestViableFunction(S, DeclLoc, Best)) {
4633 case OR_Success:
4634 // C++ [over.ics.ref]p1:
4635 //
4636 // [...] If the parameter binds directly to the result of
4637 // applying a conversion function to the argument
4638 // expression, the implicit conversion sequence is a
4639 // user-defined conversion sequence (13.3.3.1.2), with the
4640 // second standard conversion sequence either an identity
4641 // conversion or, if the conversion function returns an
4642 // entity of a type that is a derived class of the parameter
4643 // type, a derived-to-base Conversion.
4644 if (!Best->FinalConversion.DirectBinding)
4645 return false;
4646
4647 ICS.setUserDefined();
4648 ICS.UserDefined.Before = Best->Conversions[0].Standard;
4649 ICS.UserDefined.After = Best->FinalConversion;
4650 ICS.UserDefined.HadMultipleCandidates = HadMultipleCandidates;
4651 ICS.UserDefined.ConversionFunction = Best->Function;
4652 ICS.UserDefined.FoundConversionFunction = Best->FoundDecl;
4653 ICS.UserDefined.EllipsisConversion = false;
4654 assert(ICS.UserDefined.After.ReferenceBinding &&((ICS.UserDefined.After.ReferenceBinding && ICS.UserDefined
.After.DirectBinding && "Expected a direct reference binding!"
) ? static_cast<void> (0) : __assert_fail ("ICS.UserDefined.After.ReferenceBinding && ICS.UserDefined.After.DirectBinding && \"Expected a direct reference binding!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4656, __PRETTY_FUNCTION__))
4655 ICS.UserDefined.After.DirectBinding &&((ICS.UserDefined.After.ReferenceBinding && ICS.UserDefined
.After.DirectBinding && "Expected a direct reference binding!"
) ? static_cast<void> (0) : __assert_fail ("ICS.UserDefined.After.ReferenceBinding && ICS.UserDefined.After.DirectBinding && \"Expected a direct reference binding!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4656, __PRETTY_FUNCTION__))
4656 "Expected a direct reference binding!")((ICS.UserDefined.After.ReferenceBinding && ICS.UserDefined
.After.DirectBinding && "Expected a direct reference binding!"
) ? static_cast<void> (0) : __assert_fail ("ICS.UserDefined.After.ReferenceBinding && ICS.UserDefined.After.DirectBinding && \"Expected a direct reference binding!\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4656, __PRETTY_FUNCTION__))
;
4657 return true;
4658
4659 case OR_Ambiguous:
4660 ICS.setAmbiguous();
4661 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin();
4662 Cand != CandidateSet.end(); ++Cand)
4663 if (Cand->Best)
4664 ICS.Ambiguous.addConversion(Cand->FoundDecl, Cand->Function);
4665 return true;
4666
4667 case OR_No_Viable_Function:
4668 case OR_Deleted:
4669 // There was no suitable conversion, or we found a deleted
4670 // conversion; continue with other checks.
4671 return false;
4672 }
4673
4674 llvm_unreachable("Invalid OverloadResult!")::llvm::llvm_unreachable_internal("Invalid OverloadResult!", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4674)
;
4675}
4676
4677/// Compute an implicit conversion sequence for reference
4678/// initialization.
4679static ImplicitConversionSequence
4680TryReferenceInit(Sema &S, Expr *Init, QualType DeclType,
4681 SourceLocation DeclLoc,
4682 bool SuppressUserConversions,
4683 bool AllowExplicit) {
4684 assert(DeclType->isReferenceType() && "Reference init needs a reference")((DeclType->isReferenceType() && "Reference init needs a reference"
) ? static_cast<void> (0) : __assert_fail ("DeclType->isReferenceType() && \"Reference init needs a reference\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 4684, __PRETTY_FUNCTION__))
;
4685
4686 // Most paths end in a failed conversion.
4687 ImplicitConversionSequence ICS;
4688 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4689
4690 QualType T1 = DeclType->castAs<ReferenceType>()->getPointeeType();
4691 QualType T2 = Init->getType();
4692
4693 // If the initializer is the address of an overloaded function, try
4694 // to resolve the overloaded function. If all goes well, T2 is the
4695 // type of the resulting function.
4696 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
4697 DeclAccessPair Found;
4698 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType,
4699 false, Found))
4700 T2 = Fn->getType();
4701 }
4702
4703 // Compute some basic properties of the types and the initializer.
4704 bool isRValRef = DeclType->isRValueReferenceType();
4705 Expr::Classification InitCategory = Init->Classify(S.Context);
4706
4707 Sema::ReferenceConversions RefConv;
4708 Sema::ReferenceCompareResult RefRelationship =
4709 S.CompareReferenceRelationship(DeclLoc, T1, T2, &RefConv);
4710
4711 auto SetAsReferenceBinding = [&](bool BindsDirectly) {
4712 ICS.setStandard();
4713 ICS.Standard.First = ICK_Identity;
4714 // FIXME: A reference binding can be a function conversion too. We should
4715 // consider that when ordering reference-to-function bindings.
4716 ICS.Standard.Second = (RefConv & Sema::ReferenceConversions::DerivedToBase)
4717 ? ICK_Derived_To_Base
4718 : (RefConv & Sema::ReferenceConversions::ObjC)
4719 ? ICK_Compatible_Conversion
4720 : ICK_Identity;
4721 // FIXME: As a speculative fix to a defect introduced by CWG2352, we rank
4722 // a reference binding that performs a non-top-level qualification
4723 // conversion as a qualification conversion, not as an identity conversion.
4724 ICS.Standard.Third = (RefConv &
4725 Sema::ReferenceConversions::NestedQualification)
4726 ? ICK_Qualification
4727 : ICK_Identity;
4728 ICS.Standard.setFromType(T2);
4729 ICS.Standard.setToType(0, T2);
4730 ICS.Standard.setToType(1, T1);
4731 ICS.Standard.setToType(2, T1);
4732 ICS.Standard.ReferenceBinding = true;
4733 ICS.Standard.DirectBinding = BindsDirectly;
4734 ICS.Standard.IsLvalueReference = !isRValRef;
4735 ICS.Standard.BindsToFunctionLvalue = T2->isFunctionType();
4736 ICS.Standard.BindsToRvalue = InitCategory.isRValue();
4737 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4738 ICS.Standard.ObjCLifetimeConversionBinding =
4739 (RefConv & Sema::ReferenceConversions::ObjCLifetime) != 0;
4740 ICS.Standard.CopyConstructor = nullptr;
4741 ICS.Standard.DeprecatedStringLiteralToCharPtr = false;
4742 };
4743
4744 // C++0x [dcl.init.ref]p5:
4745 // A reference to type "cv1 T1" is initialized by an expression
4746 // of type "cv2 T2" as follows:
4747
4748 // -- If reference is an lvalue reference and the initializer expression
4749 if (!isRValRef) {
4750 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is
4751 // reference-compatible with "cv2 T2," or
4752 //
4753 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here.
4754 if (InitCategory.isLValue() && RefRelationship == Sema::Ref_Compatible) {
4755 // C++ [over.ics.ref]p1:
4756 // When a parameter of reference type binds directly (8.5.3)
4757 // to an argument expression, the implicit conversion sequence
4758 // is the identity conversion, unless the argument expression
4759 // has a type that is a derived class of the parameter type,
4760 // in which case the implicit conversion sequence is a
4761 // derived-to-base Conversion (13.3.3.1).
4762 SetAsReferenceBinding(/*BindsDirectly=*/true);
4763
4764 // Nothing more to do: the inaccessibility/ambiguity check for
4765 // derived-to-base conversions is suppressed when we're
4766 // computing the implicit conversion sequence (C++
4767 // [over.best.ics]p2).
4768 return ICS;
4769 }
4770
4771 // -- has a class type (i.e., T2 is a class type), where T1 is
4772 // not reference-related to T2, and can be implicitly
4773 // converted to an lvalue of type "cv3 T3," where "cv1 T1"
4774 // is reference-compatible with "cv3 T3" 92) (this
4775 // conversion is selected by enumerating the applicable
4776 // conversion functions (13.3.1.6) and choosing the best
4777 // one through overload resolution (13.3)),
4778 if (!SuppressUserConversions && T2->isRecordType() &&
4779 S.isCompleteType(DeclLoc, T2) &&
4780 RefRelationship == Sema::Ref_Incompatible) {
4781 if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4782 Init, T2, /*AllowRvalues=*/false,
4783 AllowExplicit))
4784 return ICS;
4785 }
4786 }
4787
4788 // -- Otherwise, the reference shall be an lvalue reference to a
4789 // non-volatile const type (i.e., cv1 shall be const), or the reference
4790 // shall be an rvalue reference.
4791 if (!isRValRef && (!T1.isConstQualified() || T1.isVolatileQualified()))
4792 return ICS;
4793
4794 // -- If the initializer expression
4795 //
4796 // -- is an xvalue, class prvalue, array prvalue or function
4797 // lvalue and "cv1 T1" is reference-compatible with "cv2 T2", or
4798 if (RefRelationship == Sema::Ref_Compatible &&
4799 (InitCategory.isXValue() ||
4800 (InitCategory.isPRValue() &&
4801 (T2->isRecordType() || T2->isArrayType())) ||
4802 (InitCategory.isLValue() && T2->isFunctionType()))) {
4803 // In C++11, this is always a direct binding. In C++98/03, it's a direct
4804 // binding unless we're binding to a class prvalue.
4805 // Note: Although xvalues wouldn't normally show up in C++98/03 code, we
4806 // allow the use of rvalue references in C++98/03 for the benefit of
4807 // standard library implementors; therefore, we need the xvalue check here.
4808 SetAsReferenceBinding(/*BindsDirectly=*/S.getLangOpts().CPlusPlus11 ||
4809 !(InitCategory.isPRValue() || T2->isRecordType()));
4810 return ICS;
4811 }
4812
4813 // -- has a class type (i.e., T2 is a class type), where T1 is not
4814 // reference-related to T2, and can be implicitly converted to
4815 // an xvalue, class prvalue, or function lvalue of type
4816 // "cv3 T3", where "cv1 T1" is reference-compatible with
4817 // "cv3 T3",
4818 //
4819 // then the reference is bound to the value of the initializer
4820 // expression in the first case and to the result of the conversion
4821 // in the second case (or, in either case, to an appropriate base
4822 // class subobject).
4823 if (!SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4824 T2->isRecordType() && S.isCompleteType(DeclLoc, T2) &&
4825 FindConversionForRefInit(S, ICS, DeclType, DeclLoc,
4826 Init, T2, /*AllowRvalues=*/true,
4827 AllowExplicit)) {
4828 // In the second case, if the reference is an rvalue reference
4829 // and the second standard conversion sequence of the
4830 // user-defined conversion sequence includes an lvalue-to-rvalue
4831 // conversion, the program is ill-formed.
4832 if (ICS.isUserDefined() && isRValRef &&
4833 ICS.UserDefined.After.First == ICK_Lvalue_To_Rvalue)
4834 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType);
4835
4836 return ICS;
4837 }
4838
4839 // A temporary of function type cannot be created; don't even try.
4840 if (T1->isFunctionType())
4841 return ICS;
4842
4843 // -- Otherwise, a temporary of type "cv1 T1" is created and
4844 // initialized from the initializer expression using the
4845 // rules for a non-reference copy initialization (8.5). The
4846 // reference is then bound to the temporary. If T1 is
4847 // reference-related to T2, cv1 must be the same
4848 // cv-qualification as, or greater cv-qualification than,
4849 // cv2; otherwise, the program is ill-formed.
4850 if (RefRelationship == Sema::Ref_Related) {
4851 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then
4852 // we would be reference-compatible or reference-compatible with
4853 // added qualification. But that wasn't the case, so the reference
4854 // initialization fails.
4855 //
4856 // Note that we only want to check address spaces and cvr-qualifiers here.
4857 // ObjC GC, lifetime and unaligned qualifiers aren't important.
4858 Qualifiers T1Quals = T1.getQualifiers();
4859 Qualifiers T2Quals = T2.getQualifiers();
4860 T1Quals.removeObjCGCAttr();
4861 T1Quals.removeObjCLifetime();
4862 T2Quals.removeObjCGCAttr();
4863 T2Quals.removeObjCLifetime();
4864 // MS compiler ignores __unaligned qualifier for references; do the same.
4865 T1Quals.removeUnaligned();
4866 T2Quals.removeUnaligned();
4867 if (!T1Quals.compatiblyIncludes(T2Quals))
4868 return ICS;
4869 }
4870
4871 // If at least one of the types is a class type, the types are not
4872 // related, and we aren't allowed any user conversions, the
4873 // reference binding fails. This case is important for breaking
4874 // recursion, since TryImplicitConversion below will attempt to
4875 // create a temporary through the use of a copy constructor.
4876 if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible &&
4877 (T1->isRecordType() || T2->isRecordType()))
4878 return ICS;
4879
4880 // If T1 is reference-related to T2 and the reference is an rvalue
4881 // reference, the initializer expression shall not be an lvalue.
4882 if (RefRelationship >= Sema::Ref_Related &&
4883 isRValRef && Init->Classify(S.Context).isLValue())
4884 return ICS;
4885
4886 // C++ [over.ics.ref]p2:
4887 // When a parameter of reference type is not bound directly to
4888 // an argument expression, the conversion sequence is the one
4889 // required to convert the argument expression to the
4890 // underlying type of the reference according to
4891 // 13.3.3.1. Conceptually, this conversion sequence corresponds
4892 // to copy-initializing a temporary of the underlying type with
4893 // the argument expression. Any difference in top-level
4894 // cv-qualification is subsumed by the initialization itself
4895 // and does not constitute a conversion.
4896 ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions,
4897 AllowedExplicit::None,
4898 /*InOverloadResolution=*/false,
4899 /*CStyle=*/false,
4900 /*AllowObjCWritebackConversion=*/false,
4901 /*AllowObjCConversionOnExplicit=*/false);
4902
4903 // Of course, that's still a reference binding.
4904 if (ICS.isStandard()) {
4905 ICS.Standard.ReferenceBinding = true;
4906 ICS.Standard.IsLvalueReference = !isRValRef;
4907 ICS.Standard.BindsToFunctionLvalue = false;
4908 ICS.Standard.BindsToRvalue = true;
4909 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4910 ICS.Standard.ObjCLifetimeConversionBinding = false;
4911 } else if (ICS.isUserDefined()) {
4912 const ReferenceType *LValRefType =
4913 ICS.UserDefined.ConversionFunction->getReturnType()
4914 ->getAs<LValueReferenceType>();
4915
4916 // C++ [over.ics.ref]p3:
4917 // Except for an implicit object parameter, for which see 13.3.1, a
4918 // standard conversion sequence cannot be formed if it requires [...]
4919 // binding an rvalue reference to an lvalue other than a function
4920 // lvalue.
4921 // Note that the function case is not possible here.
4922 if (DeclType->isRValueReferenceType() && LValRefType) {
4923 // FIXME: This is the wrong BadConversionSequence. The problem is binding
4924 // an rvalue reference to a (non-function) lvalue, not binding an lvalue
4925 // reference to an rvalue!
4926 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, Init, DeclType);
4927 return ICS;
4928 }
4929
4930 ICS.UserDefined.After.ReferenceBinding = true;
4931 ICS.UserDefined.After.IsLvalueReference = !isRValRef;
4932 ICS.UserDefined.After.BindsToFunctionLvalue = false;
4933 ICS.UserDefined.After.BindsToRvalue = !LValRefType;
4934 ICS.UserDefined.After.BindsImplicitObjectArgumentWithoutRefQualifier = false;
4935 ICS.UserDefined.After.ObjCLifetimeConversionBinding = false;
4936 }
4937
4938 return ICS;
4939}
4940
4941static ImplicitConversionSequence
4942TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
4943 bool SuppressUserConversions,
4944 bool InOverloadResolution,
4945 bool AllowObjCWritebackConversion,
4946 bool AllowExplicit = false);
4947
4948/// TryListConversion - Try to copy-initialize a value of type ToType from the
4949/// initializer list From.
4950static ImplicitConversionSequence
4951TryListConversion(Sema &S, InitListExpr *From, QualType ToType,
4952 bool SuppressUserConversions,
4953 bool InOverloadResolution,
4954 bool AllowObjCWritebackConversion) {
4955 // C++11 [over.ics.list]p1:
4956 // When an argument is an initializer list, it is not an expression and
4957 // special rules apply for converting it to a parameter type.
4958
4959 ImplicitConversionSequence Result;
4960 Result.setBad(BadConversionSequence::no_conversion, From, ToType);
4961
4962 // We need a complete type for what follows. Incomplete types can never be
4963 // initialized from init lists.
4964 if (!S.isCompleteType(From->getBeginLoc(), ToType))
4965 return Result;
4966
4967 // Per DR1467:
4968 // If the parameter type is a class X and the initializer list has a single
4969 // element of type cv U, where U is X or a class derived from X, the
4970 // implicit conversion sequence is the one required to convert the element
4971 // to the parameter type.
4972 //
4973 // Otherwise, if the parameter type is a character array [... ]
4974 // and the initializer list has a single element that is an
4975 // appropriately-typed string literal (8.5.2 [dcl.init.string]), the
4976 // implicit conversion sequence is the identity conversion.
4977 if (From->getNumInits() == 1) {
4978 if (ToType->isRecordType()) {
4979 QualType InitType = From->getInit(0)->getType();
4980 if (S.Context.hasSameUnqualifiedType(InitType, ToType) ||
4981 S.IsDerivedFrom(From->getBeginLoc(), InitType, ToType))
4982 return TryCopyInitialization(S, From->getInit(0), ToType,
4983 SuppressUserConversions,
4984 InOverloadResolution,
4985 AllowObjCWritebackConversion);
4986 }
4987 // FIXME: Check the other conditions here: array of character type,
4988 // initializer is a string literal.
4989 if (ToType->isArrayType()) {
4990 InitializedEntity Entity =
4991 InitializedEntity::InitializeParameter(S.Context, ToType,
4992 /*Consumed=*/false);
4993 if (S.CanPerformCopyInitialization(Entity, From)) {
4994 Result.setStandard();
4995 Result.Standard.setAsIdentityConversion();
4996 Result.Standard.setFromType(ToType);
4997 Result.Standard.setAllToTypes(ToType);
4998 return Result;
4999 }
5000 }
5001 }
5002
5003 // C++14 [over.ics.list]p2: Otherwise, if the parameter type [...] (below).
5004 // C++11 [over.ics.list]p2:
5005 // If the parameter type is std::initializer_list<X> or "array of X" and
5006 // all the elements can be implicitly converted to X, the implicit
5007 // conversion sequence is the worst conversion necessary to convert an
5008 // element of the list to X.
5009 //
5010 // C++14 [over.ics.list]p3:
5011 // Otherwise, if the parameter type is "array of N X", if the initializer
5012 // list has exactly N elements or if it has fewer than N elements and X is
5013 // default-constructible, and if all the elements of the initializer list
5014 // can be implicitly converted to X, the implicit conversion sequence is
5015 // the worst conversion necessary to convert an element of the list to X.
5016 //
5017 // FIXME: We're missing a lot of these checks.
5018 bool toStdInitializerList = false;
5019 QualType X;
5020 if (ToType->isArrayType())
5021 X = S.Context.getAsArrayType(ToType)->getElementType();
5022 else
5023 toStdInitializerList = S.isStdInitializerList(ToType, &X);
5024 if (!X.isNull()) {
5025 for (unsigned i = 0, e = From->getNumInits(); i < e; ++i) {
5026 Expr *Init = From->getInit(i);
5027 ImplicitConversionSequence ICS =
5028 TryCopyInitialization(S, Init, X, SuppressUserConversions,
5029 InOverloadResolution,
5030 AllowObjCWritebackConversion);
5031 // If a single element isn't convertible, fail.
5032 if (ICS.isBad()) {
5033 Result = ICS;
5034 break;
5035 }
5036 // Otherwise, look for the worst conversion.
5037 if (Result.isBad() || CompareImplicitConversionSequences(
5038 S, From->getBeginLoc(), ICS, Result) ==
5039 ImplicitConversionSequence::Worse)
5040 Result = ICS;
5041 }
5042
5043 // For an empty list, we won't have computed any conversion sequence.
5044 // Introduce the identity conversion sequence.
5045 if (From->getNumInits() == 0) {
5046 Result.setStandard();
5047 Result.Standard.setAsIdentityConversion();
5048 Result.Standard.setFromType(ToType);
5049 Result.Standard.setAllToTypes(ToType);
5050 }
5051
5052 Result.setStdInitializerListElement(toStdInitializerList);
5053 return Result;
5054 }
5055
5056 // C++14 [over.ics.list]p4:
5057 // C++11 [over.ics.list]p3:
5058 // Otherwise, if the parameter is a non-aggregate class X and overload
5059 // resolution chooses a single best constructor [...] the implicit
5060 // conversion sequence is a user-defined conversion sequence. If multiple
5061 // constructors are viable but none is better than the others, the
5062 // implicit conversion sequence is a user-defined conversion sequence.
5063 if (ToType->isRecordType() && !ToType->isAggregateType()) {
5064 // This function can deal with initializer lists.
5065 return TryUserDefinedConversion(S, From, ToType, SuppressUserConversions,
5066 AllowedExplicit::None,
5067 InOverloadResolution, /*CStyle=*/false,
5068 AllowObjCWritebackConversion,
5069 /*AllowObjCConversionOnExplicit=*/false);
5070 }
5071
5072 // C++14 [over.ics.list]p5:
5073 // C++11 [over.ics.list]p4:
5074 // Otherwise, if the parameter has an aggregate type which can be
5075 // initialized from the initializer list [...] the implicit conversion
5076 // sequence is a user-defined conversion sequence.
5077 if (ToType->isAggregateType()) {
5078 // Type is an aggregate, argument is an init list. At this point it comes
5079 // down to checking whether the initialization works.
5080 // FIXME: Find out whether this parameter is consumed or not.
5081 InitializedEntity Entity =
5082 InitializedEntity::InitializeParameter(S.Context, ToType,
5083 /*Consumed=*/false);
5084 if (S.CanPerformAggregateInitializationForOverloadResolution(Entity,
5085 From)) {
5086 Result.setUserDefined();
5087 Result.UserDefined.Before.setAsIdentityConversion();
5088 // Initializer lists don't have a type.
5089 Result.UserDefined.Before.setFromType(QualType());
5090 Result.UserDefined.Before.setAllToTypes(QualType());
5091
5092 Result.UserDefined.After.setAsIdentityConversion();
5093 Result.UserDefined.After.setFromType(ToType);
5094 Result.UserDefined.After.setAllToTypes(ToType);
5095 Result.UserDefined.ConversionFunction = nullptr;
5096 }
5097 return Result;
5098 }
5099
5100 // C++14 [over.ics.list]p6:
5101 // C++11 [over.ics.list]p5:
5102 // Otherwise, if the parameter is a reference, see 13.3.3.1.4.
5103 if (ToType->isReferenceType()) {
5104 // The standard is notoriously unclear here, since 13.3.3.1.4 doesn't
5105 // mention initializer lists in any way. So we go by what list-
5106 // initialization would do and try to extrapolate from that.
5107
5108 QualType T1 = ToType->castAs<ReferenceType>()->getPointeeType();
5109
5110 // If the initializer list has a single element that is reference-related
5111 // to the parameter type, we initialize the reference from that.
5112 if (From->getNumInits() == 1) {
5113 Expr *Init = From->getInit(0);
5114
5115 QualType T2 = Init->getType();
5116
5117 // If the initializer is the address of an overloaded function, try
5118 // to resolve the overloaded function. If all goes well, T2 is the
5119 // type of the resulting function.
5120 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) {
5121 DeclAccessPair Found;
5122 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(
5123 Init, ToType, false, Found))
5124 T2 = Fn->getType();
5125 }
5126
5127 // Compute some basic properties of the types and the initializer.
5128 Sema::ReferenceCompareResult RefRelationship =
5129 S.CompareReferenceRelationship(From->getBeginLoc(), T1, T2);
5130
5131 if (RefRelationship >= Sema::Ref_Related) {
5132 return TryReferenceInit(S, Init, ToType, /*FIXME*/ From->getBeginLoc(),
5133 SuppressUserConversions,
5134 /*AllowExplicit=*/false);
5135 }
5136 }
5137
5138 // Otherwise, we bind the reference to a temporary created from the
5139 // initializer list.
5140 Result = TryListConversion(S, From, T1, SuppressUserConversions,
5141 InOverloadResolution,
5142 AllowObjCWritebackConversion);
5143 if (Result.isFailure())
5144 return Result;
5145 assert(!Result.isEllipsis() &&((!Result.isEllipsis() && "Sub-initialization cannot result in ellipsis conversion."
) ? static_cast<void> (0) : __assert_fail ("!Result.isEllipsis() && \"Sub-initialization cannot result in ellipsis conversion.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5146, __PRETTY_FUNCTION__))
5146 "Sub-initialization cannot result in ellipsis conversion.")((!Result.isEllipsis() && "Sub-initialization cannot result in ellipsis conversion."
) ? static_cast<void> (0) : __assert_fail ("!Result.isEllipsis() && \"Sub-initialization cannot result in ellipsis conversion.\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5146, __PRETTY_FUNCTION__))
;
5147
5148 // Can we even bind to a temporary?
5149 if (ToType->isRValueReferenceType() ||
5150 (T1.isConstQualified() && !T1.isVolatileQualified())) {
5151 StandardConversionSequence &SCS = Result.isStandard() ? Result.Standard :
5152 Result.UserDefined.After;
5153 SCS.ReferenceBinding = true;
5154 SCS.IsLvalueReference = ToType->isLValueReferenceType();
5155 SCS.BindsToRvalue = true;
5156 SCS.BindsToFunctionLvalue = false;
5157 SCS.BindsImplicitObjectArgumentWithoutRefQualifier = false;
5158 SCS.ObjCLifetimeConversionBinding = false;
5159 } else
5160 Result.setBad(BadConversionSequence::lvalue_ref_to_rvalue,
5161 From, ToType);
5162 return Result;
5163 }
5164
5165 // C++14 [over.ics.list]p7:
5166 // C++11 [over.ics.list]p6:
5167 // Otherwise, if the parameter type is not a class:
5168 if (!ToType->isRecordType()) {
5169 // - if the initializer list has one element that is not itself an
5170 // initializer list, the implicit conversion sequence is the one
5171 // required to convert the element to the parameter type.
5172 unsigned NumInits = From->getNumInits();
5173 if (NumInits == 1 && !isa<InitListExpr>(From->getInit(0)))
5174 Result = TryCopyInitialization(S, From->getInit(0), ToType,
5175 SuppressUserConversions,
5176 InOverloadResolution,
5177 AllowObjCWritebackConversion);
5178 // - if the initializer list has no elements, the implicit conversion
5179 // sequence is the identity conversion.
5180 else if (NumInits == 0) {
5181 Result.setStandard();
5182 Result.Standard.setAsIdentityConversion();
5183 Result.Standard.setFromType(ToType);
5184 Result.Standard.setAllToTypes(ToType);
5185 }
5186 return Result;
5187 }
5188
5189 // C++14 [over.ics.list]p8:
5190 // C++11 [over.ics.list]p7:
5191 // In all cases other than those enumerated above, no conversion is possible
5192 return Result;
5193}
5194
5195/// TryCopyInitialization - Try to copy-initialize a value of type
5196/// ToType from the expression From. Return the implicit conversion
5197/// sequence required to pass this argument, which may be a bad
5198/// conversion sequence (meaning that the argument cannot be passed to
5199/// a parameter of this type). If @p SuppressUserConversions, then we
5200/// do not permit any user-defined conversion sequences.
5201static ImplicitConversionSequence
5202TryCopyInitialization(Sema &S, Expr *From, QualType ToType,
5203 bool SuppressUserConversions,
5204 bool InOverloadResolution,
5205 bool AllowObjCWritebackConversion,
5206 bool AllowExplicit) {
5207 if (InitListExpr *FromInitList = dyn_cast<InitListExpr>(From))
5208 return TryListConversion(S, FromInitList, ToType, SuppressUserConversions,
5209 InOverloadResolution,AllowObjCWritebackConversion);
5210
5211 if (ToType->isReferenceType())
5212 return TryReferenceInit(S, From, ToType,
5213 /*FIXME:*/ From->getBeginLoc(),
5214 SuppressUserConversions, AllowExplicit);
5215
5216 return TryImplicitConversion(S, From, ToType,
5217 SuppressUserConversions,
5218 AllowedExplicit::None,
5219 InOverloadResolution,
5220 /*CStyle=*/false,
5221 AllowObjCWritebackConversion,
5222 /*AllowObjCConversionOnExplicit=*/false);
5223}
5224
5225static bool TryCopyInitialization(const CanQualType FromQTy,
5226 const CanQualType ToQTy,
5227 Sema &S,
5228 SourceLocation Loc,
5229 ExprValueKind FromVK) {
5230 OpaqueValueExpr TmpExpr(Loc, FromQTy, FromVK);
5231 ImplicitConversionSequence ICS =
5232 TryCopyInitialization(S, &TmpExpr, ToQTy, true, true, false);
5233
5234 return !ICS.isBad();
5235}
5236
5237/// TryObjectArgumentInitialization - Try to initialize the object
5238/// parameter of the given member function (@c Method) from the
5239/// expression @p From.
5240static ImplicitConversionSequence
5241TryObjectArgumentInitialization(Sema &S, SourceLocation Loc, QualType FromType,
5242 Expr::Classification FromClassification,
5243 CXXMethodDecl *Method,
5244 CXXRecordDecl *ActingContext) {
5245 QualType ClassType = S.Context.getTypeDeclType(ActingContext);
5246 // [class.dtor]p2: A destructor can be invoked for a const, volatile or
5247 // const volatile object.
5248 Qualifiers Quals = Method->getMethodQualifiers();
5249 if (isa<CXXDestructorDecl>(Method)) {
5250 Quals.addConst();
5251 Quals.addVolatile();
5252 }
5253
5254 QualType ImplicitParamType = S.Context.getQualifiedType(ClassType, Quals);
5255
5256 // Set up the conversion sequence as a "bad" conversion, to allow us
5257 // to exit early.
5258 ImplicitConversionSequence ICS;
5259
5260 // We need to have an object of class type.
5261 if (const PointerType *PT = FromType->getAs<PointerType>()) {
5262 FromType = PT->getPointeeType();
5263
5264 // When we had a pointer, it's implicitly dereferenced, so we
5265 // better have an lvalue.
5266 assert(FromClassification.isLValue())((FromClassification.isLValue()) ? static_cast<void> (0
) : __assert_fail ("FromClassification.isLValue()", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5266, __PRETTY_FUNCTION__))
;
5267 }
5268
5269 assert(FromType->isRecordType())((FromType->isRecordType()) ? static_cast<void> (0) :
__assert_fail ("FromType->isRecordType()", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5269, __PRETTY_FUNCTION__))
;
5270
5271 // C++0x [over.match.funcs]p4:
5272 // For non-static member functions, the type of the implicit object
5273 // parameter is
5274 //
5275 // - "lvalue reference to cv X" for functions declared without a
5276 // ref-qualifier or with the & ref-qualifier
5277 // - "rvalue reference to cv X" for functions declared with the &&
5278 // ref-qualifier
5279 //
5280 // where X is the class of which the function is a member and cv is the
5281 // cv-qualification on the member function declaration.
5282 //
5283 // However, when finding an implicit conversion sequence for the argument, we
5284 // are not allowed to perform user-defined conversions
5285 // (C++ [over.match.funcs]p5). We perform a simplified version of
5286 // reference binding here, that allows class rvalues to bind to
5287 // non-constant references.
5288
5289 // First check the qualifiers.
5290 QualType FromTypeCanon = S.Context.getCanonicalType(FromType);
5291 if (ImplicitParamType.getCVRQualifiers()
5292 != FromTypeCanon.getLocalCVRQualifiers() &&
5293 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) {
5294 ICS.setBad(BadConversionSequence::bad_qualifiers,
5295 FromType, ImplicitParamType);
5296 return ICS;
5297 }
5298
5299 if (FromTypeCanon.hasAddressSpace()) {
5300 Qualifiers QualsImplicitParamType = ImplicitParamType.getQualifiers();
5301 Qualifiers QualsFromType = FromTypeCanon.getQualifiers();
5302 if (!QualsImplicitParamType.isAddressSpaceSupersetOf(QualsFromType)) {
5303 ICS.setBad(BadConversionSequence::bad_qualifiers,
5304 FromType, ImplicitParamType);
5305 return ICS;
5306 }
5307 }
5308
5309 // Check that we have either the same type or a derived type. It
5310 // affects the conversion rank.
5311 QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType);
5312 ImplicitConversionKind SecondKind;
5313 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) {
5314 SecondKind = ICK_Identity;
5315 } else if (S.IsDerivedFrom(Loc, FromType, ClassType))
5316 SecondKind = ICK_Derived_To_Base;
5317 else {
5318 ICS.setBad(BadConversionSequence::unrelated_class,
5319 FromType, ImplicitParamType);
5320 return ICS;
5321 }
5322
5323 // Check the ref-qualifier.
5324 switch (Method->getRefQualifier()) {
5325 case RQ_None:
5326 // Do nothing; we don't care about lvalueness or rvalueness.
5327 break;
5328
5329 case RQ_LValue:
5330 if (!FromClassification.isLValue() && !Quals.hasOnlyConst()) {
5331 // non-const lvalue reference cannot bind to an rvalue
5332 ICS.setBad(BadConversionSequence::lvalue_ref_to_rvalue, FromType,
5333 ImplicitParamType);
5334 return ICS;
5335 }
5336 break;
5337
5338 case RQ_RValue:
5339 if (!FromClassification.isRValue()) {
5340 // rvalue reference cannot bind to an lvalue
5341 ICS.setBad(BadConversionSequence::rvalue_ref_to_lvalue, FromType,
5342 ImplicitParamType);
5343 return ICS;
5344 }
5345 break;
5346 }
5347
5348 // Success. Mark this as a reference binding.
5349 ICS.setStandard();
5350 ICS.Standard.setAsIdentityConversion();
5351 ICS.Standard.Second = SecondKind;
5352 ICS.Standard.setFromType(FromType);
5353 ICS.Standard.setAllToTypes(ImplicitParamType);
5354 ICS.Standard.ReferenceBinding = true;
5355 ICS.Standard.DirectBinding = true;
5356 ICS.Standard.IsLvalueReference = Method->getRefQualifier() != RQ_RValue;
5357 ICS.Standard.BindsToFunctionLvalue = false;
5358 ICS.Standard.BindsToRvalue = FromClassification.isRValue();
5359 ICS.Standard.BindsImplicitObjectArgumentWithoutRefQualifier
5360 = (Method->getRefQualifier() == RQ_None);
5361 return ICS;
5362}
5363
5364/// PerformObjectArgumentInitialization - Perform initialization of
5365/// the implicit object parameter for the given Method with the given
5366/// expression.
5367ExprResult
5368Sema::PerformObjectArgumentInitialization(Expr *From,
5369 NestedNameSpecifier *Qualifier,
5370 NamedDecl *FoundDecl,
5371 CXXMethodDecl *Method) {
5372 QualType FromRecordType, DestType;
5373 QualType ImplicitParamRecordType =
5374 Method->getThisType()->castAs<PointerType>()->getPointeeType();
5375
5376 Expr::Classification FromClassification;
5377 if (const PointerType *PT = From->getType()->getAs<PointerType>()) {
5378 FromRecordType = PT->getPointeeType();
5379 DestType = Method->getThisType();
5380 FromClassification = Expr::Classification::makeSimpleLValue();
5381 } else {
5382 FromRecordType = From->getType();
5383 DestType = ImplicitParamRecordType;
5384 FromClassification = From->Classify(Context);
5385
5386 // When performing member access on an rvalue, materialize a temporary.
5387 if (From->isRValue()) {
5388 From = CreateMaterializeTemporaryExpr(FromRecordType, From,
5389 Method->getRefQualifier() !=
5390 RefQualifierKind::RQ_RValue);
5391 }
5392 }
5393
5394 // Note that we always use the true parent context when performing
5395 // the actual argument initialization.
5396 ImplicitConversionSequence ICS = TryObjectArgumentInitialization(
5397 *this, From->getBeginLoc(), From->getType(), FromClassification, Method,
5398 Method->getParent());
5399 if (ICS.isBad()) {
5400 switch (ICS.Bad.Kind) {
5401 case BadConversionSequence::bad_qualifiers: {
5402 Qualifiers FromQs = FromRecordType.getQualifiers();
5403 Qualifiers ToQs = DestType.getQualifiers();
5404 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers();
5405 if (CVR) {
5406 Diag(From->getBeginLoc(), diag::err_member_function_call_bad_cvr)
5407 << Method->getDeclName() << FromRecordType << (CVR - 1)
5408 << From->getSourceRange();
5409 Diag(Method->getLocation(), diag::note_previous_decl)
5410 << Method->getDeclName();
5411 return ExprError();
5412 }
5413 break;
5414 }
5415
5416 case BadConversionSequence::lvalue_ref_to_rvalue:
5417 case BadConversionSequence::rvalue_ref_to_lvalue: {
5418 bool IsRValueQualified =
5419 Method->getRefQualifier() == RefQualifierKind::RQ_RValue;
5420 Diag(From->getBeginLoc(), diag::err_member_function_call_bad_ref)
5421 << Method->getDeclName() << FromClassification.isRValue()
5422 << IsRValueQualified;
5423 Diag(Method->getLocation(), diag::note_previous_decl)
5424 << Method->getDeclName();
5425 return ExprError();
5426 }
5427
5428 case BadConversionSequence::no_conversion:
5429 case BadConversionSequence::unrelated_class:
5430 break;
5431 }
5432
5433 return Diag(From->getBeginLoc(), diag::err_member_function_call_bad_type)
5434 << ImplicitParamRecordType << FromRecordType
5435 << From->getSourceRange();
5436 }
5437
5438 if (ICS.Standard.Second == ICK_Derived_To_Base) {
5439 ExprResult FromRes =
5440 PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method);
5441 if (FromRes.isInvalid())
5442 return ExprError();
5443 From = FromRes.get();
5444 }
5445
5446 if (!Context.hasSameType(From->getType(), DestType)) {
5447 CastKind CK;
5448 QualType PteeTy = DestType->getPointeeType();
5449 LangAS DestAS =
5450 PteeTy.isNull() ? DestType.getAddressSpace() : PteeTy.getAddressSpace();
5451 if (FromRecordType.getAddressSpace() != DestAS)
5452 CK = CK_AddressSpaceConversion;
5453 else
5454 CK = CK_NoOp;
5455 From = ImpCastExprToType(From, DestType, CK, From->getValueKind()).get();
5456 }
5457 return From;
5458}
5459
5460/// TryContextuallyConvertToBool - Attempt to contextually convert the
5461/// expression From to bool (C++0x [conv]p3).
5462static ImplicitConversionSequence
5463TryContextuallyConvertToBool(Sema &S, Expr *From) {
5464 // C++ [dcl.init]/17.8:
5465 // - Otherwise, if the initialization is direct-initialization, the source
5466 // type is std::nullptr_t, and the destination type is bool, the initial
5467 // value of the object being initialized is false.
5468 if (From->getType()->isNullPtrType())
5469 return ImplicitConversionSequence::getNullptrToBool(From->getType(),
5470 S.Context.BoolTy,
5471 From->isGLValue());
5472
5473 // All other direct-initialization of bool is equivalent to an implicit
5474 // conversion to bool in which explicit conversions are permitted.
5475 return TryImplicitConversion(S, From, S.Context.BoolTy,
5476 /*SuppressUserConversions=*/false,
5477 AllowedExplicit::Conversions,
5478 /*InOverloadResolution=*/false,
5479 /*CStyle=*/false,
5480 /*AllowObjCWritebackConversion=*/false,
5481 /*AllowObjCConversionOnExplicit=*/false);
5482}
5483
5484/// PerformContextuallyConvertToBool - Perform a contextual conversion
5485/// of the expression From to bool (C++0x [conv]p3).
5486ExprResult Sema::PerformContextuallyConvertToBool(Expr *From) {
5487 if (checkPlaceholderForOverload(*this, From))
5488 return ExprError();
5489
5490 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From);
5491 if (!ICS.isBad())
5492 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting);
5493
5494 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy))
5495 return Diag(From->getBeginLoc(), diag::err_typecheck_bool_condition)
5496 << From->getType() << From->getSourceRange();
5497 return ExprError();
5498}
5499
5500/// Check that the specified conversion is permitted in a converted constant
5501/// expression, according to C++11 [expr.const]p3. Return true if the conversion
5502/// is acceptable.
5503static bool CheckConvertedConstantConversions(Sema &S,
5504 StandardConversionSequence &SCS) {
5505 // Since we know that the target type is an integral or unscoped enumeration
5506 // type, most conversion kinds are impossible. All possible First and Third
5507 // conversions are fine.
5508 switch (SCS.Second) {
5509 case ICK_Identity:
5510 case ICK_Integral_Promotion:
5511 case ICK_Integral_Conversion: // Narrowing conversions are checked elsewhere.
5512 case ICK_Zero_Queue_Conversion:
5513 return true;
5514
5515 case ICK_Boolean_Conversion:
5516 // Conversion from an integral or unscoped enumeration type to bool is
5517 // classified as ICK_Boolean_Conversion, but it's also arguably an integral
5518 // conversion, so we allow it in a converted constant expression.
5519 //
5520 // FIXME: Per core issue 1407, we should not allow this, but that breaks
5521 // a lot of popular code. We should at least add a warning for this
5522 // (non-conforming) extension.
5523 return SCS.getFromType()->isIntegralOrUnscopedEnumerationType() &&
5524 SCS.getToType(2)->isBooleanType();
5525
5526 case ICK_Pointer_Conversion:
5527 case ICK_Pointer_Member:
5528 // C++1z: null pointer conversions and null member pointer conversions are
5529 // only permitted if the source type is std::nullptr_t.
5530 return SCS.getFromType()->isNullPtrType();
5531
5532 case ICK_Floating_Promotion:
5533 case ICK_Complex_Promotion:
5534 case ICK_Floating_Conversion:
5535 case ICK_Complex_Conversion:
5536 case ICK_Floating_Integral:
5537 case ICK_Compatible_Conversion:
5538 case ICK_Derived_To_Base:
5539 case ICK_Vector_Conversion:
5540 case ICK_SVE_Vector_Conversion:
5541 case ICK_Vector_Splat:
5542 case ICK_Complex_Real:
5543 case ICK_Block_Pointer_Conversion:
5544 case ICK_TransparentUnionConversion:
5545 case ICK_Writeback_Conversion:
5546 case ICK_Zero_Event_Conversion:
5547 case ICK_C_Only_Conversion:
5548 case ICK_Incompatible_Pointer_Conversion:
5549 return false;
5550
5551 case ICK_Lvalue_To_Rvalue:
5552 case ICK_Array_To_Pointer:
5553 case ICK_Function_To_Pointer:
5554 llvm_unreachable("found a first conversion kind in Second")::llvm::llvm_unreachable_internal("found a first conversion kind in Second"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5554)
;
5555
5556 case ICK_Function_Conversion:
5557 case ICK_Qualification:
5558 llvm_unreachable("found a third conversion kind in Second")::llvm::llvm_unreachable_internal("found a third conversion kind in Second"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5558)
;
5559
5560 case ICK_Num_Conversion_Kinds:
5561 break;
5562 }
5563
5564 llvm_unreachable("unknown conversion kind")::llvm::llvm_unreachable_internal("unknown conversion kind", "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5564)
;
5565}
5566
5567/// CheckConvertedConstantExpression - Check that the expression From is a
5568/// converted constant expression of type T, perform the conversion and produce
5569/// the converted expression, per C++11 [expr.const]p3.
5570static ExprResult CheckConvertedConstantExpression(Sema &S, Expr *From,
5571 QualType T, APValue &Value,
5572 Sema::CCEKind CCE,
5573 bool RequireInt) {
5574 assert(S.getLangOpts().CPlusPlus11 &&((S.getLangOpts().CPlusPlus11 && "converted constant expression outside C++11"
) ? static_cast<void> (0) : __assert_fail ("S.getLangOpts().CPlusPlus11 && \"converted constant expression outside C++11\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5575, __PRETTY_FUNCTION__))
5575 "converted constant expression outside C++11")((S.getLangOpts().CPlusPlus11 && "converted constant expression outside C++11"
) ? static_cast<void> (0) : __assert_fail ("S.getLangOpts().CPlusPlus11 && \"converted constant expression outside C++11\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5575, __PRETTY_FUNCTION__))
;
5576
5577 if (checkPlaceholderForOverload(S, From))
5578 return ExprError();
5579
5580 // C++1z [expr.const]p3:
5581 // A converted constant expression of type T is an expression,
5582 // implicitly converted to type T, where the converted
5583 // expression is a constant expression and the implicit conversion
5584 // sequence contains only [... list of conversions ...].
5585 // C++1z [stmt.if]p2:
5586 // If the if statement is of the form if constexpr, the value of the
5587 // condition shall be a contextually converted constant expression of type
5588 // bool.
5589 ImplicitConversionSequence ICS =
5590 CCE == Sema::CCEK_ConstexprIf || CCE == Sema::CCEK_ExplicitBool
5591 ? TryContextuallyConvertToBool(S, From)
5592 : TryCopyInitialization(S, From, T,
5593 /*SuppressUserConversions=*/false,
5594 /*InOverloadResolution=*/false,
5595 /*AllowObjCWritebackConversion=*/false,
5596 /*AllowExplicit=*/false);
5597 StandardConversionSequence *SCS = nullptr;
5598 switch (ICS.getKind()) {
5599 case ImplicitConversionSequence::StandardConversion:
5600 SCS = &ICS.Standard;
5601 break;
5602 case ImplicitConversionSequence::UserDefinedConversion:
5603 // We are converting to a non-class type, so the Before sequence
5604 // must be trivial.
5605 SCS = &ICS.UserDefined.After;
5606 break;
5607 case ImplicitConversionSequence::AmbiguousConversion:
5608 case ImplicitConversionSequence::BadConversion:
5609 if (!S.DiagnoseMultipleUserDefinedConversion(From, T))
5610 return S.Diag(From->getBeginLoc(),
5611 diag::err_typecheck_converted_constant_expression)
5612 << From->getType() << From->getSourceRange() << T;
5613 return ExprError();
5614
5615 case ImplicitConversionSequence::EllipsisConversion:
5616 llvm_unreachable("ellipsis conversion in converted constant expression")::llvm::llvm_unreachable_internal("ellipsis conversion in converted constant expression"
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5616)
;
5617 }
5618
5619 // Check that we would only use permitted conversions.
5620 if (!CheckConvertedConstantConversions(S, *SCS)) {
5621 return S.Diag(From->getBeginLoc(),
5622 diag::err_typecheck_converted_constant_expression_disallowed)
5623 << From->getType() << From->getSourceRange() << T;
5624 }
5625 // [...] and where the reference binding (if any) binds directly.
5626 if (SCS->ReferenceBinding && !SCS->DirectBinding) {
5627 return S.Diag(From->getBeginLoc(),
5628 diag::err_typecheck_converted_constant_expression_indirect)
5629 << From->getType() << From->getSourceRange() << T;
5630 }
5631
5632 ExprResult Result =
5633 S.PerformImplicitConversion(From, T, ICS, Sema::AA_Converting);
5634 if (Result.isInvalid())
5635 return Result;
5636
5637 // C++2a [intro.execution]p5:
5638 // A full-expression is [...] a constant-expression [...]
5639 Result =
5640 S.ActOnFinishFullExpr(Result.get(), From->getExprLoc(),
5641 /*DiscardedValue=*/false, /*IsConstexpr=*/true);
5642 if (Result.isInvalid())
5643 return Result;
5644
5645 // Check for a narrowing implicit conversion.
5646 bool ReturnPreNarrowingValue = false;
5647 APValue PreNarrowingValue;
5648 QualType PreNarrowingType;
5649 switch (SCS->getNarrowingKind(S.Context, Result.get(), PreNarrowingValue,
5650 PreNarrowingType)) {
5651 case NK_Dependent_Narrowing:
5652 // Implicit conversion to a narrower type, but the expression is
5653 // value-dependent so we can't tell whether it's actually narrowing.
5654 case NK_Variable_Narrowing:
5655 // Implicit conversion to a narrower type, and the value is not a constant
5656 // expression. We'll diagnose this in a moment.
5657 case NK_Not_Narrowing:
5658 break;
5659
5660 case NK_Constant_Narrowing:
5661 if (CCE == Sema::CCEK_ArrayBound &&
5662 PreNarrowingType->isIntegralOrEnumerationType() &&
5663 PreNarrowingValue.isInt()) {
5664 // Don't diagnose array bound narrowing here; we produce more precise
5665 // errors by allowing the un-narrowed value through.
5666 ReturnPreNarrowingValue = true;
5667 break;
5668 }
5669 S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
5670 << CCE << /*Constant*/ 1
5671 << PreNarrowingValue.getAsString(S.Context, PreNarrowingType) << T;
5672 break;
5673
5674 case NK_Type_Narrowing:
5675 // FIXME: It would be better to diagnose that the expression is not a
5676 // constant expression.
5677 S.Diag(From->getBeginLoc(), diag::ext_cce_narrowing)
5678 << CCE << /*Constant*/ 0 << From->getType() << T;
5679 break;
5680 }
5681
5682 if (Result.get()->isValueDependent()) {
5683 Value = APValue();
5684 return Result;
5685 }
5686
5687 // Check the expression is a constant expression.
5688 SmallVector<PartialDiagnosticAt, 8> Notes;
5689 Expr::EvalResult Eval;
5690 Eval.Diag = &Notes;
5691 Expr::ConstExprUsage Usage = CCE == Sema::CCEK_TemplateArg
5692 ? Expr::EvaluateForMangling
5693 : Expr::EvaluateForCodeGen;
5694
5695 if (!Result.get()->EvaluateAsConstantExpr(Eval, Usage, S.Context) ||
5696 (RequireInt && !Eval.Val.isInt())) {
5697 // The expression can't be folded, so we can't keep it at this position in
5698 // the AST.
5699 Result = ExprError();
5700 } else {
5701 Value = Eval.Val;
5702
5703 if (Notes.empty()) {
5704 // It's a constant expression.
5705 Expr *E = ConstantExpr::Create(S.Context, Result.get(), Value);
5706 if (ReturnPreNarrowingValue)
5707 Value = std::move(PreNarrowingValue);
5708 return E;
5709 }
5710 }
5711
5712 // It's not a constant expression. Produce an appropriate diagnostic.
5713 if (Notes.size() == 1 &&
5714 Notes[0].second.getDiagID() == diag::note_invalid_subexpr_in_const_expr)
5715 S.Diag(Notes[0].first, diag::err_expr_not_cce) << CCE;
5716 else {
5717 S.Diag(From->getBeginLoc(), diag::err_expr_not_cce)
5718 << CCE << From->getSourceRange();
5719 for (unsigned I = 0; I < Notes.size(); ++I)
5720 S.Diag(Notes[I].first, Notes[I].second);
5721 }
5722 return ExprError();
5723}
5724
5725ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
5726 APValue &Value, CCEKind CCE) {
5727 return ::CheckConvertedConstantExpression(*this, From, T, Value, CCE, false);
5728}
5729
5730ExprResult Sema::CheckConvertedConstantExpression(Expr *From, QualType T,
5731 llvm::APSInt &Value,
5732 CCEKind CCE) {
5733 assert(T->isIntegralOrEnumerationType() && "unexpected converted const type")((T->isIntegralOrEnumerationType() && "unexpected converted const type"
) ? static_cast<void> (0) : __assert_fail ("T->isIntegralOrEnumerationType() && \"unexpected converted const type\""
, "/build/llvm-toolchain-snapshot-12~++20200917111122+b03c2b8395b/clang/lib/Sema/SemaOverload.cpp"
, 5733, __PRETTY_FUNCTION__))
;
5734
5735 APValue V;
5736 auto R = ::CheckConvertedConstantExpression(*this, From, T, V, CCE, true);
5737 if (!R.isInvalid() && !R.get()->isValueDependent())
5738 Value = V.getInt();
5739 return R;
5740}
5741
5742
5743/// dropPointerConversions - If the given standard conversion sequence
5744/// involves any pointer conversions, remove them. This may change
5745/// the result type of the conversion sequence.
5746static void dropPointerConversion(StandardConversionSequence &SCS) {
5747 if (SCS.Second == ICK_Pointer_Conversion) {
5748 SCS.Second = ICK_Identity;
5749 SCS.Third = ICK_Identity;
5750 SCS.ToTypePtrs[2] = SCS.ToTypePtrs[1] = SCS.ToTypePtrs[0];
5751 }
5752}
5753
5754/// TryContextuallyConvertToObjCPointer - Attempt to contextually
5755/// convert the expression From to an Objective-C pointer type.
5756static ImplicitConversionSequence
5757TryContextuallyConvertToObjCPointer(Sema &S, Expr *From) {
5758 // Do an implicit conversion to 'id'.
5759 QualType Ty = S.Context.getObjCIdType();
5760 ImplicitConversionSequence ICS
5761 = TryImplicitConversion(S, From, Ty,
5762 // FIXME: Are these flags correct?
5763 /*SuppressUserConversions=*/false,
5764 AllowedExplicit::Conversions,
5765 /*InOverloadResolution=*/false,
5766 /*CStyle=*/false,
5767 /*AllowObjCWritebackConversion=*/false,
5768 /*AllowObjCConversionOnExplicit=*/true);
5769
5770 // Strip off any final conversions to 'id'.
5771 switch (ICS.getKind()) {
5772 case ImplicitConversionSequence::BadConversion:
5773 case ImplicitConversionSequence::AmbiguousConversion:
5774 case ImplicitConversionSequence::EllipsisConversion:
5775 break;
5776
5777 case ImplicitConversionSequence::UserDefinedConversion:
5778 dropPointerConversion(ICS.UserDefined.After);
5779 break;
5780
5781 case ImplicitConversionSequence::StandardConversion:
5782 dropPointerConversion(ICS.Standard);
5783 break;
5784 }
5785
5786 return ICS;
5787}
5788
5789/// PerformContextuallyConvertToObjCPointer - Perform a contextual
5790/// conversion of the expression From to an Objective-C pointer type.
5791/// Returns a valid but null ExprResult if no conversion sequence exists.
5792ExprResult Sema::PerformContextuallyConvertToObjCPointer(Expr *From) {
5793 if (checkPlaceholderForOverload(*this, From))
5794 return ExprError();
5795
5796 QualType Ty = Context.getObjCIdType();
5797 ImplicitConversionSequence ICS =
5798 TryContextuallyConvertToObjCPointer(*this, From);
5799 if (!ICS.isBad())
5800 return PerformImplicitConversion(From, Ty, ICS, AA_Converting);
5801 return ExprResult();
5802}
5803
5804/// Determine whether the provided type is an integral type, or an enumeration
5805/// type of a permitted flavor.
5806bool Sema::ICEConvertDiagnoser::match(QualType T) {
5807 return AllowScopedEnumerations ? T->isIntegralOrEnumerationType()
5808 : T->isIntegralOrUnscopedEnumerationType();
5809}
5810
5811static ExprResult
5812diagnoseAmbiguousConversion(Sema &SemaRef, SourceLocation Loc, Expr *From,
5813 Sema::ContextualImplicitConverter &Converter,
5814 QualType T, UnresolvedSetImpl &ViableConversions) {
5815
5816 if (Converter.Suppress)
5817 return ExprError();
5818
5819 Converter.diagnoseAmbiguous(SemaRef, Loc, T) << From->getSourceRange();
5820 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5821 CXXConversionDecl *Conv =
5822 cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl());
5823 QualType ConvTy = Conv->getConversionType().getNonReferenceType();
5824 Converter.noteAmbiguous(SemaRef, Conv, ConvTy);
5825 }
5826 return From;
5827}
5828
5829static bool
5830diagnoseNoViableConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5831 Sema::ContextualImplicitConverter &Converter,
5832 QualType T, bool HadMultipleCandidates,
5833 UnresolvedSetImpl &ExplicitConversions) {
5834 if (ExplicitConversions.size() == 1 && !Converter.Suppress) {
5835 DeclAccessPair Found = ExplicitConversions[0];
5836 CXXConversionDecl *Conversion =
5837 cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5838
5839 // The user probably meant to invoke the given explicit
5840 // conversion; use it.
5841 QualType ConvTy = Conversion->getConversionType().getNonReferenceType();
5842 std::string TypeStr;
5843 ConvTy.getAsStringInternal(TypeStr, SemaRef.getPrintingPolicy());
5844
5845 Converter.diagnoseExplicitConv(SemaRef, Loc, T, ConvTy)
5846 << FixItHint::CreateInsertion(From->getBeginLoc(),
5847 "static_cast<" + TypeStr + ">(")
5848 << FixItHint::CreateInsertion(
5849 SemaRef.getLocForEndOfToken(From->getEndLoc()), ")");
5850 Converter.noteExplicitConv(SemaRef, Conversion, ConvTy);
5851
5852 // If we aren't in a SFINAE context, build a call to the
5853 // explicit conversion function.
5854 if (SemaRef.isSFINAEContext())
5855 return true;
5856
5857 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5858 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5859 HadMultipleCandidates);
5860 if (Result.isInvalid())
5861 return true;
5862 // Record usage of conversion in an implicit cast.
5863 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5864 CK_UserDefinedConversion, Result.get(),
5865 nullptr, Result.get()->getValueKind(),
5866 SemaRef.CurFPFeatureOverrides());
5867 }
5868 return false;
5869}
5870
5871static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
5872 Sema::ContextualImplicitConverter &Converter,
5873 QualType T, bool HadMultipleCandidates,
5874 DeclAccessPair &Found) {
5875 CXXConversionDecl *Conversion =
5876 cast<CXXConversionDecl>(Found->getUnderlyingDecl());
5877 SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
5878
5879 QualType ToType = Conversion->getConversionType().getNonReferenceType();
5880 if (!Converter.SuppressConversion) {
5881 if (SemaRef.isSFINAEContext())
5882 return true;
5883
5884 Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
5885 << From->getSourceRange();
5886 }
5887
5888 ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
5889 HadMultipleCandidates);
5890 if (Result.isInvalid())
5891 return true;
5892 // Record usage of conversion in an implicit cast.
5893 From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
5894 CK_UserDefinedConversion, Result.get(),
5895 nullptr, Result.get()->getValueKind(),
5896 SemaRef.CurFPFeatureOverrides());
5897 return false;
5898}
5899
5900static ExprResult finishContextualImplicitConversion(
5901 Sema &SemaRef, SourceLocation Loc, Expr *From,
5902 Sema::ContextualImplicitConverter &Converter) {
5903 if (!Converter.match(From->getType()) && !Converter.Suppress)
5904 Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
5905 << From->getSourceRange();
5906
5907 return SemaRef.DefaultLvalueConversion(From);
5908}
5909
5910static void
5911collectViableConversionCandidates(Sema &SemaRef, Expr *From, QualType ToType,
5912 UnresolvedSetImpl &ViableConversions,
5913 OverloadCandidateSet &CandidateSet) {
5914 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) {
5915 DeclAccessPair FoundDecl = ViableConversions[I];
5916 NamedDecl *D = FoundDecl.getDecl();
5917 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext());
5918 if (isa<UsingShadowDecl>(D))
5919 D = cast<UsingShadowDecl>(D)->getTargetDecl();
5920
5921 CXXConversionDecl *Conv;
5922 FunctionTemplateDecl *ConvTemplate;
5923 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D)))
5924 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl());
5925 else
5926 Conv = cast<CXXConversionDecl>(D);
5927
5928 if (ConvTemplate)
5929 SemaRef.AddTemplateConversionCandidate(
5930 ConvTemplate, FoundDecl, ActingContext, From, ToType, CandidateSet,
5931 /*AllowObjCConversionOnExplicit=*/false, /*AllowExplicit*/ true);
5932 else
5933 SemaRef.AddConversionCandidate(Conv, FoundDecl, ActingContext, From,
5934 ToType, CandidateSet,
5935 /*AllowObjCConversionOnExplicit=*/false,
5936 /*AllowExplicit*/ true);
5937 }
5938}
5939
5940/// Attempt to convert the given expression to a type which is accepted
5941/// by the given converter.
5942///
5943/// This routine will attempt to convert an expression of class type to a
5944/// type accepted by the specified converter. In C++11 and before, the class
5945/// must have a single non-explicit conversion function converting to a matching
5946/// type. In C++1y, there can be multiple such conversion functions, but only
5947/// one target type.
5948///
5949/// \param Loc The source location of the construct that requires the
5950/// conversion.
5951///
5952/// \param From The expression we're converting from.
5953///
5954/// \param Converter Used to control and diagnose the conversion process.
5955///
5956/// \returns The expression, converted to an integral or enumeration type if
5957/// successful.
5958ExprResult Sema::PerformContextualImplicitConversion(
5959 SourceLocation Loc, Expr *From, ContextualImplicitConverter &Converter) {