Coverage Report

Created: 2019-07-24 05:18

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/clang/include/clang/Sema/Overload.h
Line
Count
Source (jump to first uncovered line)
1
//===- Overload.h - C++ Overloading -----------------------------*- C++ -*-===//
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 defines the data structures and types used in C++
10
// overload resolution.
11
//
12
//===----------------------------------------------------------------------===//
13
14
#ifndef LLVM_CLANG_SEMA_OVERLOAD_H
15
#define LLVM_CLANG_SEMA_OVERLOAD_H
16
17
#include "clang/AST/Decl.h"
18
#include "clang/AST/DeclAccessPair.h"
19
#include "clang/AST/DeclBase.h"
20
#include "clang/AST/DeclCXX.h"
21
#include "clang/AST/DeclTemplate.h"
22
#include "clang/AST/Expr.h"
23
#include "clang/AST/Type.h"
24
#include "clang/Basic/LLVM.h"
25
#include "clang/Basic/SourceLocation.h"
26
#include "clang/Sema/SemaFixItUtils.h"
27
#include "clang/Sema/TemplateDeduction.h"
28
#include "llvm/ADT/ArrayRef.h"
29
#include "llvm/ADT/None.h"
30
#include "llvm/ADT/STLExtras.h"
31
#include "llvm/ADT/SmallPtrSet.h"
32
#include "llvm/ADT/SmallVector.h"
33
#include "llvm/ADT/StringRef.h"
34
#include "llvm/Support/AlignOf.h"
35
#include "llvm/Support/Allocator.h"
36
#include "llvm/Support/Casting.h"
37
#include "llvm/Support/ErrorHandling.h"
38
#include <cassert>
39
#include <cstddef>
40
#include <cstdint>
41
#include <utility>
42
43
namespace clang {
44
45
class APValue;
46
class ASTContext;
47
class Sema;
48
49
  /// OverloadingResult - Capture the result of performing overload
50
  /// resolution.
51
  enum OverloadingResult {
52
    /// Overload resolution succeeded.
53
    OR_Success,
54
55
    /// No viable function found.
56
    OR_No_Viable_Function,
57
58
    /// Ambiguous candidates found.
59
    OR_Ambiguous,
60
61
    /// Succeeded, but refers to a deleted function.
62
    OR_Deleted
63
  };
64
65
  enum OverloadCandidateDisplayKind {
66
    /// Requests that all candidates be shown.  Viable candidates will
67
    /// be printed first.
68
    OCD_AllCandidates,
69
70
    /// Requests that only viable candidates be shown.
71
    OCD_ViableCandidates
72
  };
73
74
  /// ImplicitConversionKind - The kind of implicit conversion used to
75
  /// convert an argument to a parameter's type. The enumerator values
76
  /// match with the table titled 'Conversions' in [over.ics.scs] and are listed
77
  /// such that better conversion kinds have smaller values.
78
  enum ImplicitConversionKind {
79
    /// Identity conversion (no conversion)
80
    ICK_Identity = 0,
81
82
    /// Lvalue-to-rvalue conversion (C++ [conv.lval])
83
    ICK_Lvalue_To_Rvalue,
84
85
    /// Array-to-pointer conversion (C++ [conv.array])
86
    ICK_Array_To_Pointer,
87
88
    /// Function-to-pointer (C++ [conv.array])
89
    ICK_Function_To_Pointer,
90
91
    /// Function pointer conversion (C++17 [conv.fctptr])
92
    ICK_Function_Conversion,
93
94
    /// Qualification conversions (C++ [conv.qual])
95
    ICK_Qualification,
96
97
    /// Integral promotions (C++ [conv.prom])
98
    ICK_Integral_Promotion,
99
100
    /// Floating point promotions (C++ [conv.fpprom])
101
    ICK_Floating_Promotion,
102
103
    /// Complex promotions (Clang extension)
104
    ICK_Complex_Promotion,
105
106
    /// Integral conversions (C++ [conv.integral])
107
    ICK_Integral_Conversion,
108
109
    /// Floating point conversions (C++ [conv.double]
110
    ICK_Floating_Conversion,
111
112
    /// Complex conversions (C99 6.3.1.6)
113
    ICK_Complex_Conversion,
114
115
    /// Floating-integral conversions (C++ [conv.fpint])
116
    ICK_Floating_Integral,
117
118
    /// Pointer conversions (C++ [conv.ptr])
119
    ICK_Pointer_Conversion,
120
121
    /// Pointer-to-member conversions (C++ [conv.mem])
122
    ICK_Pointer_Member,
123
124
    /// Boolean conversions (C++ [conv.bool])
125
    ICK_Boolean_Conversion,
126
127
    /// Conversions between compatible types in C99
128
    ICK_Compatible_Conversion,
129
130
    /// Derived-to-base (C++ [over.best.ics])
131
    ICK_Derived_To_Base,
132
133
    /// Vector conversions
134
    ICK_Vector_Conversion,
135
136
    /// A vector splat from an arithmetic type
137
    ICK_Vector_Splat,
138
139
    /// Complex-real conversions (C99 6.3.1.7)
140
    ICK_Complex_Real,
141
142
    /// Block Pointer conversions
143
    ICK_Block_Pointer_Conversion,
144
145
    /// Transparent Union Conversions
146
    ICK_TransparentUnionConversion,
147
148
    /// Objective-C ARC writeback conversion
149
    ICK_Writeback_Conversion,
150
151
    /// Zero constant to event (OpenCL1.2 6.12.10)
152
    ICK_Zero_Event_Conversion,
153
154
    /// Zero constant to queue
155
    ICK_Zero_Queue_Conversion,
156
157
    /// Conversions allowed in C, but not C++
158
    ICK_C_Only_Conversion,
159
160
    /// C-only conversion between pointers with incompatible types
161
    ICK_Incompatible_Pointer_Conversion,
162
163
    /// The number of conversion kinds
164
    ICK_Num_Conversion_Kinds,
165
  };
166
167
  /// ImplicitConversionRank - The rank of an implicit conversion
168
  /// kind. The enumerator values match with Table 9 of (C++
169
  /// 13.3.3.1.1) and are listed such that better conversion ranks
170
  /// have smaller values.
171
  enum ImplicitConversionRank {
172
    /// Exact Match
173
    ICR_Exact_Match = 0,
174
175
    /// Promotion
176
    ICR_Promotion,
177
178
    /// Conversion
179
    ICR_Conversion,
180
181
    /// OpenCL Scalar Widening
182
    ICR_OCL_Scalar_Widening,
183
184
    /// Complex <-> Real conversion
185
    ICR_Complex_Real_Conversion,
186
187
    /// ObjC ARC writeback conversion
188
    ICR_Writeback_Conversion,
189
190
    /// Conversion only allowed in the C standard (e.g. void* to char*).
191
    ICR_C_Conversion,
192
193
    /// Conversion not allowed by the C standard, but that we accept as an
194
    /// extension anyway.
195
    ICR_C_Conversion_Extension
196
  };
197
198
  ImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind);
199
200
  /// NarrowingKind - The kind of narrowing conversion being performed by a
201
  /// standard conversion sequence according to C++11 [dcl.init.list]p7.
202
  enum NarrowingKind {
203
    /// Not a narrowing conversion.
204
    NK_Not_Narrowing,
205
206
    /// A narrowing conversion by virtue of the source and destination types.
207
    NK_Type_Narrowing,
208
209
    /// A narrowing conversion, because a constant expression got narrowed.
210
    NK_Constant_Narrowing,
211
212
    /// A narrowing conversion, because a non-constant-expression variable might
213
    /// have got narrowed.
214
    NK_Variable_Narrowing,
215
216
    /// Cannot tell whether this is a narrowing conversion because the
217
    /// expression is value-dependent.
218
    NK_Dependent_Narrowing,
219
  };
220
221
  /// StandardConversionSequence - represents a standard conversion
222
  /// sequence (C++ 13.3.3.1.1). A standard conversion sequence
223
  /// contains between zero and three conversions. If a particular
224
  /// conversion is not needed, it will be set to the identity conversion
225
  /// (ICK_Identity). Note that the three conversions are
226
  /// specified as separate members (rather than in an array) so that
227
  /// we can keep the size of a standard conversion sequence to a
228
  /// single word.
229
  class StandardConversionSequence {
230
  public:
231
    /// First -- The first conversion can be an lvalue-to-rvalue
232
    /// conversion, array-to-pointer conversion, or
233
    /// function-to-pointer conversion.
234
    ImplicitConversionKind First : 8;
235
236
    /// Second - The second conversion can be an integral promotion,
237
    /// floating point promotion, integral conversion, floating point
238
    /// conversion, floating-integral conversion, pointer conversion,
239
    /// pointer-to-member conversion, or boolean conversion.
240
    ImplicitConversionKind Second : 8;
241
242
    /// Third - The third conversion can be a qualification conversion
243
    /// or a function conversion.
244
    ImplicitConversionKind Third : 8;
245
246
    /// Whether this is the deprecated conversion of a
247
    /// string literal to a pointer to non-const character data
248
    /// (C++ 4.2p2).
249
    unsigned DeprecatedStringLiteralToCharPtr : 1;
250
251
    /// Whether the qualification conversion involves a change in the
252
    /// Objective-C lifetime (for automatic reference counting).
253
    unsigned QualificationIncludesObjCLifetime : 1;
254
255
    /// IncompatibleObjC - Whether this is an Objective-C conversion
256
    /// that we should warn about (if we actually use it).
257
    unsigned IncompatibleObjC : 1;
258
259
    /// ReferenceBinding - True when this is a reference binding
260
    /// (C++ [over.ics.ref]).
261
    unsigned ReferenceBinding : 1;
262
263
    /// DirectBinding - True when this is a reference binding that is a
264
    /// direct binding (C++ [dcl.init.ref]).
265
    unsigned DirectBinding : 1;
266
267
    /// Whether this is an lvalue reference binding (otherwise, it's
268
    /// an rvalue reference binding).
269
    unsigned IsLvalueReference : 1;
270
271
    /// Whether we're binding to a function lvalue.
272
    unsigned BindsToFunctionLvalue : 1;
273
274
    /// Whether we're binding to an rvalue.
275
    unsigned BindsToRvalue : 1;
276
277
    /// Whether this binds an implicit object argument to a
278
    /// non-static member function without a ref-qualifier.
279
    unsigned BindsImplicitObjectArgumentWithoutRefQualifier : 1;
280
281
    /// Whether this binds a reference to an object with a different
282
    /// Objective-C lifetime qualifier.
283
    unsigned ObjCLifetimeConversionBinding : 1;
284
285
    /// FromType - The type that this conversion is converting
286
    /// from. This is an opaque pointer that can be translated into a
287
    /// QualType.
288
    void *FromTypePtr;
289
290
    /// ToType - The types that this conversion is converting to in
291
    /// each step. This is an opaque pointer that can be translated
292
    /// into a QualType.
293
    void *ToTypePtrs[3];
294
295
    /// CopyConstructor - The copy constructor that is used to perform
296
    /// this conversion, when the conversion is actually just the
297
    /// initialization of an object via copy constructor. Such
298
    /// conversions are either identity conversions or derived-to-base
299
    /// conversions.
300
    CXXConstructorDecl *CopyConstructor;
301
    DeclAccessPair FoundCopyConstructor;
302
303
40.8M
    void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
304
305
109M
    void setToType(unsigned Idx, QualType T) {
306
109M
      assert(Idx < 3 && "To type index is out of range");
307
109M
      ToTypePtrs[Idx] = T.getAsOpaquePtr();
308
109M
    }
309
310
3.84M
    void setAllToTypes(QualType T) {
311
3.84M
      ToTypePtrs[0] = T.getAsOpaquePtr();
312
3.84M
      ToTypePtrs[1] = ToTypePtrs[0];
313
3.84M
      ToTypePtrs[2] = ToTypePtrs[0];
314
3.84M
    }
315
316
16.2M
    QualType getFromType() const {
317
16.2M
      return QualType::getFromOpaquePtr(FromTypePtr);
318
16.2M
    }
319
320
41.9M
    QualType getToType(unsigned Idx) const {
321
41.9M
      assert(Idx < 3 && "To type index is out of range");
322
41.9M
      return QualType::getFromOpaquePtr(ToTypePtrs[Idx]);
323
41.9M
    }
324
325
    void setAsIdentityConversion();
326
327
76.3M
    bool isIdentityConversion() const {
328
76.3M
      return Second == ICK_Identity && 
Third == ICK_Identity28.0M
;
329
76.3M
    }
330
331
    ImplicitConversionRank getRank() const;
332
    NarrowingKind
333
    getNarrowingKind(ASTContext &Context, const Expr *Converted,
334
                     APValue &ConstantValue, QualType &ConstantType,
335
                     bool IgnoreFloatToIntegralConversion = false) const;
336
    bool isPointerConversionToBool() const;
337
    bool isPointerConversionToVoidPointer(ASTContext& Context) const;
338
    void dump() const;
339
  };
340
341
  /// UserDefinedConversionSequence - Represents a user-defined
342
  /// conversion sequence (C++ 13.3.3.1.2).
343
  struct UserDefinedConversionSequence {
344
    /// Represents the standard conversion that occurs before
345
    /// the actual user-defined conversion.
346
    ///
347
    /// C++11 13.3.3.1.2p1:
348
    ///   If the user-defined conversion is specified by a constructor
349
    ///   (12.3.1), the initial standard conversion sequence converts
350
    ///   the source type to the type required by the argument of the
351
    ///   constructor. If the user-defined conversion is specified by
352
    ///   a conversion function (12.3.2), the initial standard
353
    ///   conversion sequence converts the source type to the implicit
354
    ///   object parameter of the conversion function.
355
    StandardConversionSequence Before;
356
357
    /// EllipsisConversion - When this is true, it means user-defined
358
    /// conversion sequence starts with a ... (ellipsis) conversion, instead of
359
    /// a standard conversion. In this case, 'Before' field must be ignored.
360
    // FIXME. I much rather put this as the first field. But there seems to be
361
    // a gcc code gen. bug which causes a crash in a test. Putting it here seems
362
    // to work around the crash.
363
    bool EllipsisConversion : 1;
364
365
    /// HadMultipleCandidates - When this is true, it means that the
366
    /// conversion function was resolved from an overloaded set having
367
    /// size greater than 1.
368
    bool HadMultipleCandidates : 1;
369
370
    /// After - Represents the standard conversion that occurs after
371
    /// the actual user-defined conversion.
372
    StandardConversionSequence After;
373
374
    /// ConversionFunction - The function that will perform the
375
    /// user-defined conversion. Null if the conversion is an
376
    /// aggregate initialization from an initializer list.
377
    FunctionDecl* ConversionFunction;
378
379
    /// The declaration that we found via name lookup, which might be
380
    /// the same as \c ConversionFunction or it might be a using declaration
381
    /// that refers to \c ConversionFunction.
382
    DeclAccessPair FoundConversionFunction;
383
384
    void dump() const;
385
  };
386
387
  /// Represents an ambiguous user-defined conversion sequence.
388
  struct AmbiguousConversionSequence {
389
    using ConversionSet =
390
        SmallVector<std::pair<NamedDecl *, FunctionDecl *>, 4>;
391
392
    void *FromTypePtr;
393
    void *ToTypePtr;
394
    char Buffer[sizeof(ConversionSet)];
395
396
10
    QualType getFromType() const {
397
10
      return QualType::getFromOpaquePtr(FromTypePtr);
398
10
    }
399
400
10
    QualType getToType() const {
401
10
      return QualType::getFromOpaquePtr(ToTypePtr);
402
10
    }
403
404
251
    void setFromType(QualType T) { FromTypePtr = T.getAsOpaquePtr(); }
405
251
    void setToType(QualType T) { ToTypePtr = T.getAsOpaquePtr(); }
406
407
1.73k
    ConversionSet &conversions() {
408
1.73k
      return *reinterpret_cast<ConversionSet*>(Buffer);
409
1.73k
    }
410
411
325
    const ConversionSet &conversions() const {
412
325
      return *reinterpret_cast<const ConversionSet*>(Buffer);
413
325
    }
414
415
574
    void addConversion(NamedDecl *Found, FunctionDecl *D) {
416
574
      conversions().push_back(std::make_pair(Found, D));
417
574
    }
418
419
    using iterator = ConversionSet::iterator;
420
421
0
    iterator begin() { return conversions().begin(); }
422
0
    iterator end() { return conversions().end(); }
423
424
    using const_iterator = ConversionSet::const_iterator;
425
426
10
    const_iterator begin() const { return conversions().begin(); }
427
10
    const_iterator end() const { return conversions().end(); }
428
429
    void construct();
430
    void destruct();
431
    void copyFrom(const AmbiguousConversionSequence &);
432
  };
433
434
  /// BadConversionSequence - Records information about an invalid
435
  /// conversion sequence.
436
  struct BadConversionSequence {
437
    enum FailureKind {
438
      no_conversion,
439
      unrelated_class,
440
      bad_qualifiers,
441
      lvalue_ref_to_rvalue,
442
      rvalue_ref_to_lvalue
443
    };
444
445
    // This can be null, e.g. for implicit object arguments.
446
    Expr *FromExpr;
447
448
    FailureKind Kind;
449
450
  private:
451
    // The type we're converting from (an opaque QualType).
452
    void *FromTy;
453
454
    // The type we're converting to (an opaque QualType).
455
    void *ToTy;
456
457
  public:
458
9.64M
    void init(FailureKind K, Expr *From, QualType To) {
459
9.64M
      init(K, From->getType(), To);
460
9.64M
      FromExpr = From;
461
9.64M
    }
462
463
9.91M
    void init(FailureKind K, QualType From, QualType To) {
464
9.91M
      Kind = K;
465
9.91M
      FromExpr = nullptr;
466
9.91M
      setFromType(From);
467
9.91M
      setToType(To);
468
9.91M
    }
469
470
412k
    QualType getFromType() const { return QualType::getFromOpaquePtr(FromTy); }
471
412k
    QualType getToType() const { return QualType::getFromOpaquePtr(ToTy); }
472
473
0
    void setFromExpr(Expr *E) {
474
0
      FromExpr = E;
475
0
      setFromType(E->getType());
476
0
    }
477
478
9.91M
    void setFromType(QualType T) { FromTy = T.getAsOpaquePtr(); }
479
9.91M
    void setToType(QualType T) { ToTy = T.getAsOpaquePtr(); }
480
  };
481
482
  /// ImplicitConversionSequence - Represents an implicit conversion
483
  /// sequence, which may be a standard conversion sequence
484
  /// (C++ 13.3.3.1.1), user-defined conversion sequence (C++ 13.3.3.1.2),
485
  /// or an ellipsis conversion sequence (C++ 13.3.3.1.3).
486
  class ImplicitConversionSequence {
487
  public:
488
    /// Kind - The kind of implicit conversion sequence. BadConversion
489
    /// specifies that there is no conversion from the source type to
490
    /// the target type.  AmbiguousConversion represents the unique
491
    /// ambiguous conversion (C++0x [over.best.ics]p10).
492
    enum Kind {
493
      StandardConversion = 0,
494
      UserDefinedConversion,
495
      AmbiguousConversion,
496
      EllipsisConversion,
497
      BadConversion
498
    };
499
500
  private:
501
    enum {
502
      Uninitialized = BadConversion + 1
503
    };
504
505
    /// ConversionKind - The kind of implicit conversion sequence.
506
    unsigned ConversionKind : 30;
507
508
    /// Whether the target is really a std::initializer_list, and the
509
    /// sequence only represents the worst element conversion.
510
    unsigned StdInitializerListElement : 1;
511
512
48.0M
    void setKind(Kind K) {
513
48.0M
      destruct();
514
48.0M
      ConversionKind = K;
515
48.0M
    }
516
517
213M
    void destruct() {
518
213M
      if (ConversionKind == AmbiguousConversion) 
Ambiguous.destruct()578
;
519
213M
    }
520
521
  public:
522
    union {
523
      /// When ConversionKind == StandardConversion, provides the
524
      /// details of the standard conversion sequence.
525
      StandardConversionSequence Standard;
526
527
      /// When ConversionKind == UserDefinedConversion, provides the
528
      /// details of the user-defined conversion sequence.
529
      UserDefinedConversionSequence UserDefined;
530
531
      /// When ConversionKind == AmbiguousConversion, provides the
532
      /// details of the ambiguous conversion.
533
      AmbiguousConversionSequence Ambiguous;
534
535
      /// When ConversionKind == BadConversion, provides the details
536
      /// of the bad conversion.
537
      BadConversionSequence Bad;
538
    };
539
540
    ImplicitConversionSequence()
541
90.4M
        : ConversionKind(Uninitialized), StdInitializerListElement(false) {
542
90.4M
      Standard.setAsIdentityConversion();
543
90.4M
    }
544
545
    ImplicitConversionSequence(const ImplicitConversionSequence &Other)
546
        : ConversionKind(Other.ConversionKind),
547
75.0M
          StdInitializerListElement(Other.StdInitializerListElement) {
548
75.0M
      switch (ConversionKind) {
549
75.0M
      
case Uninitialized: break0
;
550
75.0M
      
case StandardConversion: Standard = Other.Standard; break66.6M
;
551
75.0M
      
case UserDefinedConversion: UserDefined = Other.UserDefined; break360k
;
552
75.0M
      
case AmbiguousConversion: Ambiguous.copyFrom(Other.Ambiguous); break305
;
553
75.0M
      
case EllipsisConversion: break0
;
554
75.0M
      
case BadConversion: Bad = Other.Bad; break8.02M
;
555
75.0M
      }
556
75.0M
    }
557
558
    ImplicitConversionSequence &
559
33.8M
    operator=(const ImplicitConversionSequence &Other) {
560
33.8M
      destruct();
561
33.8M
      new (this) ImplicitConversionSequence(Other);
562
33.8M
      return *this;
563
33.8M
    }
564
565
131M
    ~ImplicitConversionSequence() {
566
131M
      destruct();
567
131M
    }
568
569
571M
    Kind getKind() const {
570
571M
      assert(isInitialized() && "querying uninitialized conversion");
571
571M
      return Kind(ConversionKind);
572
571M
    }
573
574
    /// Return a ranking of the implicit conversion sequence
575
    /// kind, where smaller ranks represent better conversion
576
    /// sequences.
577
    ///
578
    /// In particular, this routine gives user-defined conversion
579
    /// sequences and ambiguous conversion sequences the same rank,
580
    /// per C++ [over.best.ics]p10.
581
123M
    unsigned getKindRank() const {
582
123M
      switch (getKind()) {
583
123M
      case StandardConversion:
584
121M
        return 0;
585
123M
586
123M
      case UserDefinedConversion:
587
1.65M
      case AmbiguousConversion:
588
1.65M
        return 1;
589
1.65M
590
1.65M
      case EllipsisConversion:
591
123k
        return 2;
592
1.65M
593
1.65M
      case BadConversion:
594
53.5k
        return 3;
595
0
      }
596
0
597
0
      llvm_unreachable("Invalid ImplicitConversionSequence::Kind!");
598
0
    }
599
600
72.1M
    bool isBad() const { return getKind() == BadConversion; }
601
171M
    bool isStandard() const { return getKind() == StandardConversion; }
602
35.9k
    bool isEllipsis() const { return getKind() == EllipsisConversion; }
603
605
    bool isAmbiguous() const { return getKind() == AmbiguousConversion; }
604
128M
    bool isUserDefined() const { return getKind() == UserDefinedConversion; }
605
688
    bool isFailure() const { return isBad() || 
isAmbiguous()524
; }
606
607
    /// Determines whether this conversion sequence has been
608
    /// initialized.  Most operations should never need to query
609
    /// uninitialized conversions and should assert as above.
610
6.57M
    bool isInitialized() const { return ConversionKind != Uninitialized; }
611
612
    /// Sets this sequence as a bad conversion for an explicit argument.
613
    void setBad(BadConversionSequence::FailureKind Failure,
614
9.64M
                Expr *FromExpr, QualType ToType) {
615
9.64M
      setKind(BadConversion);
616
9.64M
      Bad.init(Failure, FromExpr, ToType);
617
9.64M
    }
618
619
    /// Sets this sequence as a bad conversion for an implicit argument.
620
    void setBad(BadConversionSequence::FailureKind Failure,
621
267k
                QualType FromType, QualType ToType) {
622
267k
      setKind(BadConversion);
623
267k
      Bad.init(Failure, FromType, ToType);
624
267k
    }
625
626
37.6M
    void setStandard() { setKind(StandardConversion); }
627
98.9k
    void setEllipsis() { setKind(EllipsisConversion); }
628
330k
    void setUserDefined() { setKind(UserDefinedConversion); }
629
630
273
    void setAmbiguous() {
631
273
      if (ConversionKind == AmbiguousConversion) 
return0
;
632
273
      ConversionKind = AmbiguousConversion;
633
273
      Ambiguous.construct();
634
273
    }
635
636
361
    void setAsIdentityConversion(QualType T) {
637
361
      setStandard();
638
361
      Standard.setAsIdentityConversion();
639
361
      Standard.setFromType(T);
640
361
      Standard.setAllToTypes(T);
641
361
    }
642
643
    /// Whether the target is really a std::initializer_list, and the
644
    /// sequence only represents the worst element conversion.
645
91.7M
    bool isStdInitializerListElement() const {
646
91.7M
      return StdInitializerListElement;
647
91.7M
    }
648
649
875
    void setStdInitializerListElement(bool V = true) {
650
875
      StdInitializerListElement = V;
651
875
    }
652
653
    // The result of a comparison between implicit conversion
654
    // sequences. Use Sema::CompareImplicitConversionSequences to
655
    // actually perform the comparison.
656
    enum CompareKind {
657
      Better = -1,
658
      Indistinguishable = 0,
659
      Worse = 1
660
    };
661
662
    void DiagnoseAmbiguousConversion(Sema &S,
663
                                     SourceLocation CaretLoc,
664
                                     const PartialDiagnostic &PDiag) const;
665
666
    void dump() const;
667
  };
668
669
  enum OverloadFailureKind {
670
    ovl_fail_too_many_arguments,
671
    ovl_fail_too_few_arguments,
672
    ovl_fail_bad_conversion,
673
    ovl_fail_bad_deduction,
674
675
    /// This conversion candidate was not considered because it
676
    /// duplicates the work of a trivial or derived-to-base
677
    /// conversion.
678
    ovl_fail_trivial_conversion,
679
680
    /// This conversion candidate was not considered because it is
681
    /// an illegal instantiation of a constructor temploid: it is
682
    /// callable with one argument, we only have one argument, and
683
    /// its first parameter type is exactly the type of the class.
684
    ///
685
    /// Defining such a constructor directly is illegal, and
686
    /// template-argument deduction is supposed to ignore such
687
    /// instantiations, but we can still get one with the right
688
    /// kind of implicit instantiation.
689
    ovl_fail_illegal_constructor,
690
691
    /// This conversion candidate is not viable because its result
692
    /// type is not implicitly convertible to the desired type.
693
    ovl_fail_bad_final_conversion,
694
695
    /// This conversion function template specialization candidate is not
696
    /// viable because the final conversion was not an exact match.
697
    ovl_fail_final_conversion_not_exact,
698
699
    /// (CUDA) This candidate was not viable because the callee
700
    /// was not accessible from the caller's target (i.e. host->device,
701
    /// global->host, device->host).
702
    ovl_fail_bad_target,
703
704
    /// This candidate function was not viable because an enable_if
705
    /// attribute disabled it.
706
    ovl_fail_enable_if,
707
708
    /// This candidate constructor or conversion fonction
709
    /// is used implicitly but the explicit(bool) specifier
710
    /// was resolved to true
711
    ovl_fail_explicit_resolved,
712
713
    /// This candidate was not viable because its address could not be taken.
714
    ovl_fail_addr_not_available,
715
716
    /// This candidate was not viable because its OpenCL extension is disabled.
717
    ovl_fail_ext_disabled,
718
719
    /// This inherited constructor is not viable because it would slice the
720
    /// argument.
721
    ovl_fail_inhctor_slice,
722
723
    /// This candidate was not viable because it is a non-default multiversioned
724
    /// function.
725
    ovl_non_default_multiversion_function,
726
727
    /// This constructor/conversion candidate fail due to an address space
728
    /// mismatch between the object being constructed and the overload
729
    /// candidate.
730
    ovl_fail_object_addrspace_mismatch
731
  };
732
733
  /// A list of implicit conversion sequences for the arguments of an
734
  /// OverloadCandidate.
735
  using ConversionSequenceList =
736
      llvm::MutableArrayRef<ImplicitConversionSequence>;
737
738
  /// OverloadCandidate - A single candidate in an overload set (C++ 13.3).
739
  struct OverloadCandidate {
740
    /// Function - The actual function that this candidate
741
    /// represents. When NULL, this is a built-in candidate
742
    /// (C++ [over.oper]) or a surrogate for a conversion to a
743
    /// function pointer or reference (C++ [over.call.object]).
744
    FunctionDecl *Function;
745
746
    /// FoundDecl - The original declaration that was looked up /
747
    /// invented / otherwise found, together with its access.
748
    /// Might be a UsingShadowDecl or a FunctionTemplateDecl.
749
    DeclAccessPair FoundDecl;
750
751
    /// BuiltinParamTypes - Provides the parameter types of a built-in overload
752
    /// candidate. Only valid when Function is NULL.
753
    QualType BuiltinParamTypes[3];
754
755
    /// Surrogate - The conversion function for which this candidate
756
    /// is a surrogate, but only if IsSurrogate is true.
757
    CXXConversionDecl *Surrogate;
758
759
    /// The conversion sequences used to convert the function arguments
760
    /// to the function parameters.
761
    ConversionSequenceList Conversions;
762
763
    /// The FixIt hints which can be used to fix the Bad candidate.
764
    ConversionFixItGenerator Fix;
765
766
    /// Viable - True to indicate that this overload candidate is viable.
767
    bool Viable : 1;
768
769
    /// IsSurrogate - True to indicate that this candidate is a
770
    /// surrogate for a conversion to a function pointer or reference
771
    /// (C++ [over.call.object]).
772
    bool IsSurrogate : 1;
773
774
    /// IgnoreObjectArgument - True to indicate that the first
775
    /// argument's conversion, which for this function represents the
776
    /// implicit object argument, should be ignored. This will be true
777
    /// when the candidate is a static member function (where the
778
    /// implicit object argument is just a placeholder) or a
779
    /// non-static member function when the call doesn't have an
780
    /// object argument.
781
    bool IgnoreObjectArgument : 1;
782
783
    /// True if the candidate was found using ADL.
784
    CallExpr::ADLCallKind IsADLCandidate : 1;
785
786
    /// FailureKind - The reason why this candidate is not viable.
787
    /// Actually an OverloadFailureKind.
788
    unsigned char FailureKind;
789
790
    /// The number of call arguments that were explicitly provided,
791
    /// to be used while performing partial ordering of function templates.
792
    unsigned ExplicitCallArguments;
793
794
    union {
795
      DeductionFailureInfo DeductionFailure;
796
797
      /// FinalConversion - For a conversion function (where Function is
798
      /// a CXXConversionDecl), the standard conversion that occurs
799
      /// after the call to the overload candidate to convert the result
800
      /// of calling the conversion function to the required type.
801
      StandardConversionSequence FinalConversion;
802
    };
803
804
    /// hasAmbiguousConversion - Returns whether this overload
805
    /// candidate requires an ambiguous conversion or not.
806
0
    bool hasAmbiguousConversion() const {
807
0
      for (auto &C : Conversions) {
808
0
        if (!C.isInitialized()) return false;
809
0
        if (C.isAmbiguous()) return true;
810
0
      }
811
0
      return false;
812
0
    }
813
814
404k
    bool TryToFixBadConversion(unsigned Idx, Sema &S) {
815
404k
      bool CanFix = Fix.tryToFixConversion(
816
404k
                      Conversions[Idx].Bad.FromExpr,
817
404k
                      Conversions[Idx].Bad.getFromType(),
818
404k
                      Conversions[Idx].Bad.getToType(), S);
819
404k
820
404k
      // If at least one conversion fails, the candidate cannot be fixed.
821
404k
      if (!CanFix)
822
404k
        Fix.clear();
823
404k
824
404k
      return CanFix;
825
404k
    }
826
827
880
    unsigned getNumParams() const {
828
880
      if (IsSurrogate) {
829
9
        auto STy = Surrogate->getConversionType();
830
18
        while (STy->isPointerType() || 
STy->isReferenceType()9
)
831
9
          STy = STy->getPointeeType();
832
9
        return STy->getAs<FunctionProtoType>()->getNumParams();
833
9
      }
834
871
      if (Function)
835
871
        return Function->getNumParams();
836
0
      return ExplicitCallArguments;
837
0
    }
838
839
  private:
840
    friend class OverloadCandidateSet;
841
23.3M
    OverloadCandidate() : IsADLCandidate(CallExpr::NotADL) {}
842
  };
843
844
  /// OverloadCandidateSet - A set of overload candidates, used in C++
845
  /// overload resolution (C++ 13.3).
846
  class OverloadCandidateSet {
847
  public:
848
    enum CandidateSetKind {
849
      /// Normal lookup.
850
      CSK_Normal,
851
852
      /// C++ [over.match.oper]:
853
      /// Lookup of operator function candidates in a call using operator
854
      /// syntax. Candidates that have no parameters of class type will be
855
      /// skipped unless there is a parameter of (reference to) enum type and
856
      /// the corresponding argument is of the same enum type.
857
      CSK_Operator,
858
859
      /// C++ [over.match.copy]:
860
      /// Copy-initialization of an object of class type by user-defined
861
      /// conversion.
862
      CSK_InitByUserDefinedConversion,
863
864
      /// C++ [over.match.ctor], [over.match.list]
865
      /// Initialization of an object of class type by constructor,
866
      /// using either a parenthesized or braced list of arguments.
867
      CSK_InitByConstructor,
868
    };
869
870
  private:
871
    SmallVector<OverloadCandidate, 16> Candidates;
872
    llvm::SmallPtrSet<Decl *, 16> Functions;
873
874
    // Allocator for ConversionSequenceLists. We store the first few of these
875
    // inline to avoid allocation for small sets.
876
    llvm::BumpPtrAllocator SlabAllocator;
877
878
    SourceLocation Loc;
879
    CandidateSetKind Kind;
880
881
    constexpr static unsigned NumInlineBytes =
882
        24 * sizeof(ImplicitConversionSequence);
883
    unsigned NumInlineBytesUsed = 0;
884
    llvm::AlignedCharArray<alignof(void *), NumInlineBytes> InlineSpace;
885
886
    // Address space of the object being constructed.
887
    LangAS DestAS = LangAS::Default;
888
889
    /// If we have space, allocates from inline storage. Otherwise, allocates
890
    /// from the slab allocator.
891
    /// FIXME: It would probably be nice to have a SmallBumpPtrAllocator
892
    /// instead.
893
    /// FIXME: Now that this only allocates ImplicitConversionSequences, do we
894
    /// want to un-generalize this?
895
    template <typename T>
896
23.3M
    T *slabAllocate(unsigned N) {
897
23.3M
      // It's simpler if this doesn't need to consider alignment.
898
23.3M
      static_assert(alignof(T) == alignof(void *),
899
23.3M
                    "Only works for pointer-aligned types.");
900
23.3M
      static_assert(std::is_trivial<T>::value ||
901
23.3M
                        std::is_same<ImplicitConversionSequence, T>::value,
902
23.3M
                    "Add destruction logic to OverloadCandidateSet::clear().");
903
23.3M
904
23.3M
      unsigned NBytes = sizeof(T) * N;
905
23.3M
      if (NBytes > NumInlineBytes - NumInlineBytesUsed)
906
14.1M
        return SlabAllocator.Allocate<T>(N);
907
9.20M
      char *FreeSpaceStart = InlineSpace.buffer + NumInlineBytesUsed;
908
9.20M
      assert(uintptr_t(FreeSpaceStart) % alignof(void *) == 0 &&
909
9.20M
             "Misaligned storage!");
910
9.20M
911
9.20M
      NumInlineBytesUsed += NBytes;
912
9.20M
      return reinterpret_cast<T *>(FreeSpaceStart);
913
9.20M
    }
914
915
    void destroyCandidates();
916
917
  public:
918
    OverloadCandidateSet(SourceLocation Loc, CandidateSetKind CSK)
919
20.2M
        : Loc(Loc), Kind(CSK) {}
920
    OverloadCandidateSet(const OverloadCandidateSet &) = delete;
921
    OverloadCandidateSet &operator=(const OverloadCandidateSet &) = delete;
922
20.2M
    ~OverloadCandidateSet() { destroyCandidates(); }
923
924
5.26M
    SourceLocation getLocation() const { return Loc; }
925
4.48M
    CandidateSetKind getKind() const { return Kind; }
926
927
    /// Determine when this overload candidate will be new to the
928
    /// overload set.
929
9.48M
    bool isNewCandidate(Decl *F) {
930
9.48M
      return Functions.insert(F->getCanonicalDecl()).second;
931
9.48M
    }
932
933
    /// Clear out all of the candidates.
934
    void clear(CandidateSetKind CSK);
935
936
    using iterator = SmallVectorImpl<OverloadCandidate>::iterator;
937
938
28.7M
    iterator begin() { return Candidates.begin(); }
939
51.8M
    iterator end() { return Candidates.end(); }
940
941
4.03M
    size_t size() const { return Candidates.size(); }
942
1.80M
    bool empty() const { return Candidates.empty(); }
943
944
    /// Allocate storage for conversion sequences for NumConversions
945
    /// conversions.
946
    ConversionSequenceList
947
23.3M
    allocateConversionSequences(unsigned NumConversions) {
948
23.3M
      ImplicitConversionSequence *Conversions =
949
23.3M
          slabAllocate<ImplicitConversionSequence>(NumConversions);
950
23.3M
951
23.3M
      // Construct the new objects.
952
62.6M
      for (unsigned I = 0; I != NumConversions; 
++I39.2M
)
953
39.2M
        new (&Conversions[I]) ImplicitConversionSequence();
954
23.3M
955
23.3M
      return ConversionSequenceList(Conversions, NumConversions);
956
23.3M
    }
957
958
    /// Add a new candidate with NumConversions conversion sequence slots
959
    /// to the overload set.
960
    OverloadCandidate &addCandidate(unsigned NumConversions = 0,
961
23.3M
                                    ConversionSequenceList Conversions = None) {
962
23.3M
      assert((Conversions.empty() || Conversions.size() == NumConversions) &&
963
23.3M
             "preallocated conversion sequence has wrong length");
964
23.3M
965
23.3M
      Candidates.push_back(OverloadCandidate());
966
23.3M
      OverloadCandidate &C = Candidates.back();
967
23.3M
      C.Conversions = Conversions.empty()
968
23.3M
                          ? 
allocateConversionSequences(NumConversions)22.6M
969
23.3M
                          : 
Conversions706k
;
970
23.3M
      return C;
971
23.3M
    }
972
973
    /// Find the best viable function on this overload set, if it exists.
974
    OverloadingResult BestViableFunction(Sema &S, SourceLocation Loc,
975
                                         OverloadCandidateSet::iterator& Best);
976
977
    SmallVector<OverloadCandidate *, 32> CompleteCandidates(
978
        Sema &S, OverloadCandidateDisplayKind OCD, ArrayRef<Expr *> Args,
979
        SourceLocation OpLoc = SourceLocation(),
980
        llvm::function_ref<bool(OverloadCandidate &)> Filter =
981
402k
            [](OverloadCandidate &) { return true; });
982
983
    void NoteCandidates(
984
        PartialDiagnosticAt PA, Sema &S, OverloadCandidateDisplayKind OCD,
985
        ArrayRef<Expr *> Args, StringRef Opc = "",
986
        SourceLocation Loc = SourceLocation(),
987
        llvm::function_ref<bool(OverloadCandidate &)> Filter =
988
24.8k
            [](OverloadCandidate &) { return true; });
989
990
    void NoteCandidates(Sema &S, ArrayRef<Expr *> Args,
991
                        ArrayRef<OverloadCandidate *> Cands,
992
                        StringRef Opc = "",
993
                        SourceLocation OpLoc = SourceLocation());
994
995
2.55M
    LangAS getDestAS() { return DestAS; }
996
997
459k
    void setDestAS(LangAS AS) {
998
459k
      assert((Kind == CSK_InitByConstructor ||
999
459k
              Kind == CSK_InitByUserDefinedConversion) &&
1000
459k
             "can't set the destination address space when not constructing an "
1001
459k
             "object");
1002
459k
      DestAS = AS;
1003
459k
    }
1004
1005
  };
1006
1007
  bool isBetterOverloadCandidate(Sema &S,
1008
                                 const OverloadCandidate &Cand1,
1009
                                 const OverloadCandidate &Cand2,
1010
                                 SourceLocation Loc,
1011
                                 OverloadCandidateSet::CandidateSetKind Kind);
1012
1013
  struct ConstructorInfo {
1014
    DeclAccessPair FoundDecl;
1015
    CXXConstructorDecl *Constructor;
1016
    FunctionTemplateDecl *ConstructorTmpl;
1017
1018
1.78M
    explicit operator bool() const { return Constructor; }
1019
  };
1020
1021
  // FIXME: Add an AddOverloadCandidate / AddTemplateOverloadCandidate overload
1022
  // that takes one of these.
1023
4.05M
  inline ConstructorInfo getConstructorInfo(NamedDecl *ND) {
1024
4.05M
    if (isa<UsingDecl>(ND))
1025
1.06k
      return ConstructorInfo{};
1026
4.05M
1027
4.05M
    // For constructors, the access check is performed against the underlying
1028
4.05M
    // declaration, not the found declaration.
1029
4.05M
    auto *D = ND->getUnderlyingDecl();
1030
4.05M
    ConstructorInfo Info = {DeclAccessPair::make(ND, D->getAccess()), nullptr,
1031
4.05M
                            nullptr};
1032
4.05M
    Info.ConstructorTmpl = dyn_cast<FunctionTemplateDecl>(D);
1033
4.05M
    if (Info.ConstructorTmpl)
1034
751k
      D = Info.ConstructorTmpl->getTemplatedDecl();
1035
4.05M
    Info.Constructor = dyn_cast<CXXConstructorDecl>(D);
1036
4.05M
    return Info;
1037
4.05M
  }
1038
1039
} // namespace clang
1040
1041
#endif // LLVM_CLANG_SEMA_OVERLOAD_H