SemaOverload.cpp revision 0e800c9c20d1a658a91096c756c4a4a9e90264fc
105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger//===--- SemaOverload.cpp - C++ Overloading ---------------------*- C++ -*-===// 205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// 305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// The LLVM Compiler Infrastructure 405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// 505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// This file is distributed under the University of Illinois Open Source 605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// License. See LICENSE.TXT for details. 705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// 805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger//===----------------------------------------------------------------------===// 905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// 1005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// This file provides Sema routines for C++ overloading. 1105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger// 1205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger//===----------------------------------------------------------------------===// 1305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 1405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/Sema/SemaInternal.h" 1505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/Sema/Lookup.h" 1605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/Sema/Initialization.h" 1705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/Sema/Template.h" 1805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/Sema/TemplateDeduction.h" 190b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/Basic/Diagnostic.h" 200b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/Lex/Preprocessor.h" 210b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/AST/ASTContext.h" 220b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/AST/CXXInheritance.h" 230b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/AST/DeclObjC.h" 240b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/AST/Expr.h" 250b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/AST/ExprCXX.h" 260b15698a8c76bb8abc1b555c1d91892669b4118fDerek Sollenberger#include "clang/AST/ExprObjC.h" 2705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/AST/TypeOrdering.h" 2805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "clang/Basic/PartialDiagnostic.h" 2905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "llvm/ADT/DenseSet.h" 3005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "llvm/ADT/SmallPtrSet.h" 3105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include "llvm/ADT/STLExtras.h" 3205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger#include <algorithm> 3305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 3405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergernamespace clang { 3505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerusing namespace sema; 3605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 3705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// A convenience routine for creating a decayed reference to a 3805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// function. 3905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic Expr * 4005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerCreateFunctionRefExpr(Sema &S, FunctionDecl *Fn, 4105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger SourceLocation Loc = SourceLocation()) { 4205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Expr *E = new (S.Context) DeclRefExpr(Fn, Fn->getType(), VK_LValue, Loc); 4305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger S.DefaultFunctionArrayConversion(E); 4405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return E; 4505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 4605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 4705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic bool IsStandardConversion(Sema &S, Expr* From, QualType ToType, 4805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger bool InOverloadResolution, 4905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger StandardConversionSequence &SCS); 5005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic OverloadingResult 5105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerIsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 5205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger UserDefinedConversionSequence& User, 5305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OverloadCandidateSet& Conversions, 5405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger bool AllowExplicit); 5505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 5605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 5705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic ImplicitConversionSequence::CompareKind 5805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerCompareStandardConversionSequences(Sema &S, 5905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger const StandardConversionSequence& SCS1, 6005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger const StandardConversionSequence& SCS2); 6105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 6205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic ImplicitConversionSequence::CompareKind 6305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerCompareQualificationConversions(Sema &S, 6405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger const StandardConversionSequence& SCS1, 6505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger const StandardConversionSequence& SCS2); 6605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 6705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic ImplicitConversionSequence::CompareKind 6805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerCompareDerivedToBaseConversions(Sema &S, 6905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger const StandardConversionSequence& SCS1, 7005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger const StandardConversionSequence& SCS2); 7105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 7205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 7305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 7405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// GetConversionCategory - Retrieve the implicit conversion 7505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// category corresponding to the given implicit conversion kind. 7605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerImplicitConversionCategory 7705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerGetConversionCategory(ImplicitConversionKind Kind) { 7805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger static const ImplicitConversionCategory 7905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Category[(int)ICK_Num_Conversion_Kinds] = { 8005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Identity, 8105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Lvalue_Transformation, 8205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Lvalue_Transformation, 8305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Lvalue_Transformation, 8405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Identity, 8505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Qualification_Adjustment, 8605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Promotion, 8705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Promotion, 8805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Promotion, 8905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 9905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion, 10005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICC_Conversion 10105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger }; 10205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return Category[(int)Kind]; 10305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 10405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 10505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// GetConversionRank - Retrieve the implicit conversion rank 10605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// corresponding to the given implicit conversion kind. 10705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerImplicitConversionRank GetConversionRank(ImplicitConversionKind Kind) { 10805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger static const ImplicitConversionRank 10905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Rank[(int)ICK_Num_Conversion_Kinds] = { 11005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Exact_Match, 11105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Exact_Match, 11205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Exact_Match, 11305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Exact_Match, 11405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Exact_Match, 11505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Exact_Match, 11605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Promotion, 11705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Promotion, 11805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Promotion, 11905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 12905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Conversion, 13005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ICR_Complex_Real_Conversion 13105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger }; 13205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return Rank[(int)Kind]; 13305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 13405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 13505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// GetImplicitConversionName - Return the name of this kind of 13605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// implicit conversion. 13705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerconst char* GetImplicitConversionName(ImplicitConversionKind Kind) { 13805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger static const char* const Name[(int)ICK_Num_Conversion_Kinds] = { 13905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "No conversion", 14005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Lvalue-to-rvalue", 14105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Array-to-pointer", 14205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Function-to-pointer", 14305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Noreturn adjustment", 14405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Qualification", 14505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Integral promotion", 14605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Floating point promotion", 14705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Complex promotion", 14805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Integral conversion", 14905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Floating conversion", 15005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Complex conversion", 15105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Floating-integral conversion", 15205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Pointer conversion", 15305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Pointer-to-member conversion", 15405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Boolean conversion", 15505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Compatible-types conversion", 15605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Derived-to-base conversion", 15705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Vector conversion", 15805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Vector splat", 15905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger "Complex-real conversion" 16005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger }; 16105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return Name[Kind]; 16205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 16305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 16405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// StandardConversionSequence - Set the standard conversion 16505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// sequence to the identity conversion. 16605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid StandardConversionSequence::setAsIdentityConversion() { 16705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger First = ICK_Identity; 16805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Second = ICK_Identity; 16905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Third = ICK_Identity; 17005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger DeprecatedStringLiteralToCharPtr = false; 17105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ReferenceBinding = false; 17205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger DirectBinding = false; 17305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger RRefBinding = false; 17405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger CopyConstructor = 0; 17505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 17605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 17705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// getRank - Retrieve the rank of this standard conversion sequence 17805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// (C++ 13.3.3.1.1p3). The rank is the largest rank of each of the 17905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// implicit conversions. 18005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerImplicitConversionRank StandardConversionSequence::getRank() const { 18105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ImplicitConversionRank Rank = ICR_Exact_Match; 18205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (GetConversionRank(First) > Rank) 18305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Rank = GetConversionRank(First); 18405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (GetConversionRank(Second) > Rank) 18505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Rank = GetConversionRank(Second); 18605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (GetConversionRank(Third) > Rank) 18705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Rank = GetConversionRank(Third); 18805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return Rank; 18905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 19005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 19105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// isPointerConversionToBool - Determines whether this conversion is 19205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// a conversion of a pointer or pointer-to-member to bool. This is 19305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// used as part of the ranking of standard conversion sequences 19405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// (C++ 13.3.3.2p4). 19505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerbool StandardConversionSequence::isPointerConversionToBool() const { 19605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // Note that FromType has not necessarily been transformed by the 19705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // array-to-pointer or function-to-pointer implicit conversions, so 19805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // check for their presence as well as checking whether FromType is 19905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // a pointer. 20005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (getToType(1)->isBooleanType() && 20105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger (getFromType()->isPointerType() || 20205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger getFromType()->isObjCObjectPointerType() || 20305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger getFromType()->isBlockPointerType() || 20405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger getFromType()->isNullPtrType() || 20505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger First == ICK_Array_To_Pointer || First == ICK_Function_To_Pointer)) 20605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return true; 20705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 20805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return false; 20905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 21005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 21105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// isPointerConversionToVoidPointer - Determines whether this 21205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// conversion is a conversion of a pointer to a void pointer. This is 21305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// used as part of the ranking of standard conversion sequences (C++ 21405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// 13.3.3.2p4). 21505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerbool 21605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerStandardConversionSequence:: 21705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerisPointerConversionToVoidPointer(ASTContext& Context) const { 21805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger QualType FromType = getFromType(); 21905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger QualType ToType = getToType(1); 22005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 22105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // Note that FromType has not necessarily been transformed by the 22205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // array-to-pointer implicit conversion, so check for its presence 22305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // and redo the conversion to get a pointer. 22405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (First == ICK_Array_To_Pointer) 22505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger FromType = Context.getArrayDecayedType(FromType); 22605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 22705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (Second == ICK_Pointer_Conversion && FromType->isPointerType()) 22805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (const PointerType* ToPtrType = ToType->getAs<PointerType>()) 22905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return ToPtrType->getPointeeType()->isVoidType(); 23005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 23105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return false; 23205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 23305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 23405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// DebugPrint - Print this standard conversion sequence to standard 23505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// error. Useful for debugging overloading issues. 23605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid StandardConversionSequence::DebugPrint() const { 23705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger llvm::raw_ostream &OS = llvm::errs(); 23805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger bool PrintedSomething = false; 23905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (First != ICK_Identity) { 24005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << GetImplicitConversionName(First); 24105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger PrintedSomething = true; 24205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 24305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 24405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (Second != ICK_Identity) { 24505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (PrintedSomething) { 24605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " -> "; 24705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 24805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << GetImplicitConversionName(Second); 24905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 25005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (CopyConstructor) { 25105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " (by copy constructor)"; 25205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } else if (DirectBinding) { 25305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " (direct reference binding)"; 25405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } else if (ReferenceBinding) { 25505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " (reference binding)"; 25605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 25705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger PrintedSomething = true; 25805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 25987b8e645865f9633f410c02252a0fd3feb18f09bDerek Sollenberger 26005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (Third != ICK_Identity) { 26105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (PrintedSomething) { 26205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " -> "; 26305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 26405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << GetImplicitConversionName(Third); 26505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger PrintedSomething = true; 26605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 26705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 26805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (!PrintedSomething) { 26905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "No conversions required"; 27005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 27105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 27205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 27305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// DebugPrint - Print this user-defined conversion sequence to standard 27405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// error. Useful for debugging overloading issues. 27505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid UserDefinedConversionSequence::DebugPrint() const { 27605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger llvm::raw_ostream &OS = llvm::errs(); 27705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (Before.First || Before.Second || Before.Third) { 27805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Before.DebugPrint(); 27905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " -> "; 28005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 28105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << '\'' << ConversionFunction << '\''; 28205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger if (After.First || After.Second || After.Third) { 28305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << " -> "; 28405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger After.DebugPrint(); 28505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 28605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 28705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 28805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// DebugPrint - Print this implicit conversion sequence to standard 28905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// error. Useful for debugging overloading issues. 29005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid ImplicitConversionSequence::DebugPrint() const { 29105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger llvm::raw_ostream &OS = llvm::errs(); 29205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger switch (ConversionKind) { 29305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case StandardConversion: 29405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "Standard conversion: "; 29505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Standard.DebugPrint(); 29605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 29705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case UserDefinedConversion: 29805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "User-defined conversion: "; 29905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger UserDefined.DebugPrint(); 30005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 30105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case EllipsisConversion: 30205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "Ellipsis conversion"; 30305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 30405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case AmbiguousConversion: 30505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "Ambiguous conversion"; 30605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 30705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case BadConversion: 30805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "Bad conversion"; 30905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 31005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 31105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 31205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OS << "\n"; 31305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 31405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 31505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid AmbiguousConversionSequence::construct() { 31605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger new (&conversions()) ConversionSet(); 31705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 31805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 31905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid AmbiguousConversionSequence::destruct() { 32005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger conversions().~ConversionSet(); 32105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 32205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 32305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergervoid 32405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerAmbiguousConversionSequence::copyFrom(const AmbiguousConversionSequence &O) { 32505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger FromTypePtr = O.FromTypePtr; 32605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger ToTypePtr = O.ToTypePtr; 32705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger new (&conversions()) ConversionSet(O.conversions()); 32805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 32905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 33005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergernamespace { 33105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // Structure used by OverloadCandidate::DeductionFailureInfo to store 33205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // template parameter and template argument information. 33305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger struct DFIParamWithArguments { 33405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger TemplateParameter Param; 33505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger TemplateArgument FirstArg; 33605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger TemplateArgument SecondArg; 33705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger }; 33805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 33905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 34005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// \brief Convert from Sema's representation of template deduction information 34105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger/// to the form used in overload-candidate information. 34205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek SollenbergerOverloadCandidate::DeductionFailureInfo 34305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenbergerstatic MakeDeductionFailureInfo(ASTContext &Context, 34405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Sema::TemplateDeductionResult TDK, 34505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger TemplateDeductionInfo &Info) { 34605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger OverloadCandidate::DeductionFailureInfo Result; 34705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Result.Result = static_cast<unsigned>(TDK); 34805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Result.Data = 0; 34905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger switch (TDK) { 35005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_Success: 35105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_InstantiationDepth: 35205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_TooManyArguments: 35305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_TooFewArguments: 35405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 35505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 35605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_Incomplete: 35705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_InvalidExplicitArguments: 35805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Result.Data = Info.Param.getOpaqueValue(); 35905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 36005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 36105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_Inconsistent: 36205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_Underqualified: { 36305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger // FIXME: Should allocate from normal heap so that we can free this later. 36405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger DFIParamWithArguments *Saved = new (Context) DFIParamWithArguments; 36505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Saved->Param = Info.Param; 36605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Saved->FirstArg = Info.FirstArg; 36705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Saved->SecondArg = Info.SecondArg; 36805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Result.Data = Saved; 36905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 37005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 37105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 37205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_SubstitutionFailure: 37305b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger Result.Data = Info.take(); 37405b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 37505b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 37605b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_NonDeducedMismatch: 37705b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger case Sema::TDK_FailedOverloadResolution: 37805b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger break; 37905b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger } 38005b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger 38105b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger return Result; 38205b6b4d746867a9fb02e14edfe1bf3685abeb813Derek Sollenberger} 38335e2e62b55598210f6999fc2ea26ff8f41446ffeDerek Sollenberger 384void OverloadCandidate::DeductionFailureInfo::Destroy() { 385 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 386 case Sema::TDK_Success: 387 case Sema::TDK_InstantiationDepth: 388 case Sema::TDK_Incomplete: 389 case Sema::TDK_TooManyArguments: 390 case Sema::TDK_TooFewArguments: 391 case Sema::TDK_InvalidExplicitArguments: 392 break; 393 394 case Sema::TDK_Inconsistent: 395 case Sema::TDK_Underqualified: 396 // FIXME: Destroy the data? 397 Data = 0; 398 break; 399 400 case Sema::TDK_SubstitutionFailure: 401 // FIXME: Destroy the template arugment list? 402 Data = 0; 403 break; 404 405 // Unhandled 406 case Sema::TDK_NonDeducedMismatch: 407 case Sema::TDK_FailedOverloadResolution: 408 break; 409 } 410} 411 412TemplateParameter 413OverloadCandidate::DeductionFailureInfo::getTemplateParameter() { 414 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 415 case Sema::TDK_Success: 416 case Sema::TDK_InstantiationDepth: 417 case Sema::TDK_TooManyArguments: 418 case Sema::TDK_TooFewArguments: 419 case Sema::TDK_SubstitutionFailure: 420 return TemplateParameter(); 421 422 case Sema::TDK_Incomplete: 423 case Sema::TDK_InvalidExplicitArguments: 424 return TemplateParameter::getFromOpaqueValue(Data); 425 426 case Sema::TDK_Inconsistent: 427 case Sema::TDK_Underqualified: 428 return static_cast<DFIParamWithArguments*>(Data)->Param; 429 430 // Unhandled 431 case Sema::TDK_NonDeducedMismatch: 432 case Sema::TDK_FailedOverloadResolution: 433 break; 434 } 435 436 return TemplateParameter(); 437} 438 439TemplateArgumentList * 440OverloadCandidate::DeductionFailureInfo::getTemplateArgumentList() { 441 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 442 case Sema::TDK_Success: 443 case Sema::TDK_InstantiationDepth: 444 case Sema::TDK_TooManyArguments: 445 case Sema::TDK_TooFewArguments: 446 case Sema::TDK_Incomplete: 447 case Sema::TDK_InvalidExplicitArguments: 448 case Sema::TDK_Inconsistent: 449 case Sema::TDK_Underqualified: 450 return 0; 451 452 case Sema::TDK_SubstitutionFailure: 453 return static_cast<TemplateArgumentList*>(Data); 454 455 // Unhandled 456 case Sema::TDK_NonDeducedMismatch: 457 case Sema::TDK_FailedOverloadResolution: 458 break; 459 } 460 461 return 0; 462} 463 464const TemplateArgument *OverloadCandidate::DeductionFailureInfo::getFirstArg() { 465 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 466 case Sema::TDK_Success: 467 case Sema::TDK_InstantiationDepth: 468 case Sema::TDK_Incomplete: 469 case Sema::TDK_TooManyArguments: 470 case Sema::TDK_TooFewArguments: 471 case Sema::TDK_InvalidExplicitArguments: 472 case Sema::TDK_SubstitutionFailure: 473 return 0; 474 475 case Sema::TDK_Inconsistent: 476 case Sema::TDK_Underqualified: 477 return &static_cast<DFIParamWithArguments*>(Data)->FirstArg; 478 479 // Unhandled 480 case Sema::TDK_NonDeducedMismatch: 481 case Sema::TDK_FailedOverloadResolution: 482 break; 483 } 484 485 return 0; 486} 487 488const TemplateArgument * 489OverloadCandidate::DeductionFailureInfo::getSecondArg() { 490 switch (static_cast<Sema::TemplateDeductionResult>(Result)) { 491 case Sema::TDK_Success: 492 case Sema::TDK_InstantiationDepth: 493 case Sema::TDK_Incomplete: 494 case Sema::TDK_TooManyArguments: 495 case Sema::TDK_TooFewArguments: 496 case Sema::TDK_InvalidExplicitArguments: 497 case Sema::TDK_SubstitutionFailure: 498 return 0; 499 500 case Sema::TDK_Inconsistent: 501 case Sema::TDK_Underqualified: 502 return &static_cast<DFIParamWithArguments*>(Data)->SecondArg; 503 504 // Unhandled 505 case Sema::TDK_NonDeducedMismatch: 506 case Sema::TDK_FailedOverloadResolution: 507 break; 508 } 509 510 return 0; 511} 512 513void OverloadCandidateSet::clear() { 514 inherited::clear(); 515 Functions.clear(); 516} 517 518// IsOverload - Determine whether the given New declaration is an 519// overload of the declarations in Old. This routine returns false if 520// New and Old cannot be overloaded, e.g., if New has the same 521// signature as some function in Old (C++ 1.3.10) or if the Old 522// declarations aren't functions (or function templates) at all. When 523// it does return false, MatchedDecl will point to the decl that New 524// cannot be overloaded with. This decl may be a UsingShadowDecl on 525// top of the underlying declaration. 526// 527// Example: Given the following input: 528// 529// void f(int, float); // #1 530// void f(int, int); // #2 531// int f(int, int); // #3 532// 533// When we process #1, there is no previous declaration of "f", 534// so IsOverload will not be used. 535// 536// When we process #2, Old contains only the FunctionDecl for #1. By 537// comparing the parameter types, we see that #1 and #2 are overloaded 538// (since they have different signatures), so this routine returns 539// false; MatchedDecl is unchanged. 540// 541// When we process #3, Old is an overload set containing #1 and #2. We 542// compare the signatures of #3 to #1 (they're overloaded, so we do 543// nothing) and then #3 to #2. Since the signatures of #3 and #2 are 544// identical (return types of functions are not part of the 545// signature), IsOverload returns false and MatchedDecl will be set to 546// point to the FunctionDecl for #2. 547// 548// 'NewIsUsingShadowDecl' indicates that 'New' is being introduced 549// into a class by a using declaration. The rules for whether to hide 550// shadow declarations ignore some properties which otherwise figure 551// into a function template's signature. 552Sema::OverloadKind 553Sema::CheckOverload(Scope *S, FunctionDecl *New, const LookupResult &Old, 554 NamedDecl *&Match, bool NewIsUsingDecl) { 555 for (LookupResult::iterator I = Old.begin(), E = Old.end(); 556 I != E; ++I) { 557 NamedDecl *OldD = *I; 558 559 bool OldIsUsingDecl = false; 560 if (isa<UsingShadowDecl>(OldD)) { 561 OldIsUsingDecl = true; 562 563 // We can always introduce two using declarations into the same 564 // context, even if they have identical signatures. 565 if (NewIsUsingDecl) continue; 566 567 OldD = cast<UsingShadowDecl>(OldD)->getTargetDecl(); 568 } 569 570 // If either declaration was introduced by a using declaration, 571 // we'll need to use slightly different rules for matching. 572 // Essentially, these rules are the normal rules, except that 573 // function templates hide function templates with different 574 // return types or template parameter lists. 575 bool UseMemberUsingDeclRules = 576 (OldIsUsingDecl || NewIsUsingDecl) && CurContext->isRecord(); 577 578 if (FunctionTemplateDecl *OldT = dyn_cast<FunctionTemplateDecl>(OldD)) { 579 if (!IsOverload(New, OldT->getTemplatedDecl(), UseMemberUsingDeclRules)) { 580 if (UseMemberUsingDeclRules && OldIsUsingDecl) { 581 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I)); 582 continue; 583 } 584 585 Match = *I; 586 return Ovl_Match; 587 } 588 } else if (FunctionDecl *OldF = dyn_cast<FunctionDecl>(OldD)) { 589 if (!IsOverload(New, OldF, UseMemberUsingDeclRules)) { 590 if (UseMemberUsingDeclRules && OldIsUsingDecl) { 591 HideUsingShadowDecl(S, cast<UsingShadowDecl>(*I)); 592 continue; 593 } 594 595 Match = *I; 596 return Ovl_Match; 597 } 598 } else if (isa<UsingDecl>(OldD)) { 599 // We can overload with these, which can show up when doing 600 // redeclaration checks for UsingDecls. 601 assert(Old.getLookupKind() == LookupUsingDeclName); 602 } else if (isa<TagDecl>(OldD)) { 603 // We can always overload with tags by hiding them. 604 } else if (isa<UnresolvedUsingValueDecl>(OldD)) { 605 // Optimistically assume that an unresolved using decl will 606 // overload; if it doesn't, we'll have to diagnose during 607 // template instantiation. 608 } else { 609 // (C++ 13p1): 610 // Only function declarations can be overloaded; object and type 611 // declarations cannot be overloaded. 612 Match = *I; 613 return Ovl_NonFunction; 614 } 615 } 616 617 return Ovl_Overload; 618} 619 620bool Sema::IsOverload(FunctionDecl *New, FunctionDecl *Old, 621 bool UseUsingDeclRules) { 622 // If both of the functions are extern "C", then they are not 623 // overloads. 624 if (Old->isExternC() && New->isExternC()) 625 return false; 626 627 FunctionTemplateDecl *OldTemplate = Old->getDescribedFunctionTemplate(); 628 FunctionTemplateDecl *NewTemplate = New->getDescribedFunctionTemplate(); 629 630 // C++ [temp.fct]p2: 631 // A function template can be overloaded with other function templates 632 // and with normal (non-template) functions. 633 if ((OldTemplate == 0) != (NewTemplate == 0)) 634 return true; 635 636 // Is the function New an overload of the function Old? 637 QualType OldQType = Context.getCanonicalType(Old->getType()); 638 QualType NewQType = Context.getCanonicalType(New->getType()); 639 640 // Compare the signatures (C++ 1.3.10) of the two functions to 641 // determine whether they are overloads. If we find any mismatch 642 // in the signature, they are overloads. 643 644 // If either of these functions is a K&R-style function (no 645 // prototype), then we consider them to have matching signatures. 646 if (isa<FunctionNoProtoType>(OldQType.getTypePtr()) || 647 isa<FunctionNoProtoType>(NewQType.getTypePtr())) 648 return false; 649 650 FunctionProtoType* OldType = cast<FunctionProtoType>(OldQType); 651 FunctionProtoType* NewType = cast<FunctionProtoType>(NewQType); 652 653 // The signature of a function includes the types of its 654 // parameters (C++ 1.3.10), which includes the presence or absence 655 // of the ellipsis; see C++ DR 357). 656 if (OldQType != NewQType && 657 (OldType->getNumArgs() != NewType->getNumArgs() || 658 OldType->isVariadic() != NewType->isVariadic() || 659 !FunctionArgTypesAreEqual(OldType, NewType))) 660 return true; 661 662 // C++ [temp.over.link]p4: 663 // The signature of a function template consists of its function 664 // signature, its return type and its template parameter list. The names 665 // of the template parameters are significant only for establishing the 666 // relationship between the template parameters and the rest of the 667 // signature. 668 // 669 // We check the return type and template parameter lists for function 670 // templates first; the remaining checks follow. 671 // 672 // However, we don't consider either of these when deciding whether 673 // a member introduced by a shadow declaration is hidden. 674 if (!UseUsingDeclRules && NewTemplate && 675 (!TemplateParameterListsAreEqual(NewTemplate->getTemplateParameters(), 676 OldTemplate->getTemplateParameters(), 677 false, TPL_TemplateMatch) || 678 OldType->getResultType() != NewType->getResultType())) 679 return true; 680 681 // If the function is a class member, its signature includes the 682 // cv-qualifiers (if any) on the function itself. 683 // 684 // As part of this, also check whether one of the member functions 685 // is static, in which case they are not overloads (C++ 686 // 13.1p2). While not part of the definition of the signature, 687 // this check is important to determine whether these functions 688 // can be overloaded. 689 CXXMethodDecl* OldMethod = dyn_cast<CXXMethodDecl>(Old); 690 CXXMethodDecl* NewMethod = dyn_cast<CXXMethodDecl>(New); 691 if (OldMethod && NewMethod && 692 !OldMethod->isStatic() && !NewMethod->isStatic() && 693 OldMethod->getTypeQualifiers() != NewMethod->getTypeQualifiers()) 694 return true; 695 696 // The signatures match; this is not an overload. 697 return false; 698} 699 700/// TryImplicitConversion - Attempt to perform an implicit conversion 701/// from the given expression (Expr) to the given type (ToType). This 702/// function returns an implicit conversion sequence that can be used 703/// to perform the initialization. Given 704/// 705/// void f(float f); 706/// void g(int i) { f(i); } 707/// 708/// this routine would produce an implicit conversion sequence to 709/// describe the initialization of f from i, which will be a standard 710/// conversion sequence containing an lvalue-to-rvalue conversion (C++ 711/// 4.1) followed by a floating-integral conversion (C++ 4.9). 712// 713/// Note that this routine only determines how the conversion can be 714/// performed; it does not actually perform the conversion. As such, 715/// it will not produce any diagnostics if no conversion is available, 716/// but will instead return an implicit conversion sequence of kind 717/// "BadConversion". 718/// 719/// If @p SuppressUserConversions, then user-defined conversions are 720/// not permitted. 721/// If @p AllowExplicit, then explicit user-defined conversions are 722/// permitted. 723static ImplicitConversionSequence 724TryImplicitConversion(Sema &S, Expr *From, QualType ToType, 725 bool SuppressUserConversions, 726 bool AllowExplicit, 727 bool InOverloadResolution) { 728 ImplicitConversionSequence ICS; 729 if (IsStandardConversion(S, From, ToType, InOverloadResolution, 730 ICS.Standard)) { 731 ICS.setStandard(); 732 return ICS; 733 } 734 735 if (!S.getLangOptions().CPlusPlus) { 736 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 737 return ICS; 738 } 739 740 // C++ [over.ics.user]p4: 741 // A conversion of an expression of class type to the same class 742 // type is given Exact Match rank, and a conversion of an 743 // expression of class type to a base class of that type is 744 // given Conversion rank, in spite of the fact that a copy/move 745 // constructor (i.e., a user-defined conversion function) is 746 // called for those cases. 747 QualType FromType = From->getType(); 748 if (ToType->getAs<RecordType>() && FromType->getAs<RecordType>() && 749 (S.Context.hasSameUnqualifiedType(FromType, ToType) || 750 S.IsDerivedFrom(FromType, ToType))) { 751 ICS.setStandard(); 752 ICS.Standard.setAsIdentityConversion(); 753 ICS.Standard.setFromType(FromType); 754 ICS.Standard.setAllToTypes(ToType); 755 756 // We don't actually check at this point whether there is a valid 757 // copy/move constructor, since overloading just assumes that it 758 // exists. When we actually perform initialization, we'll find the 759 // appropriate constructor to copy the returned object, if needed. 760 ICS.Standard.CopyConstructor = 0; 761 762 // Determine whether this is considered a derived-to-base conversion. 763 if (!S.Context.hasSameUnqualifiedType(FromType, ToType)) 764 ICS.Standard.Second = ICK_Derived_To_Base; 765 766 return ICS; 767 } 768 769 if (SuppressUserConversions) { 770 // We're not in the case above, so there is no conversion that 771 // we can perform. 772 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 773 return ICS; 774 } 775 776 // Attempt user-defined conversion. 777 OverloadCandidateSet Conversions(From->getExprLoc()); 778 OverloadingResult UserDefResult 779 = IsUserDefinedConversion(S, From, ToType, ICS.UserDefined, Conversions, 780 AllowExplicit); 781 782 if (UserDefResult == OR_Success) { 783 ICS.setUserDefined(); 784 // C++ [over.ics.user]p4: 785 // A conversion of an expression of class type to the same class 786 // type is given Exact Match rank, and a conversion of an 787 // expression of class type to a base class of that type is 788 // given Conversion rank, in spite of the fact that a copy 789 // constructor (i.e., a user-defined conversion function) is 790 // called for those cases. 791 if (CXXConstructorDecl *Constructor 792 = dyn_cast<CXXConstructorDecl>(ICS.UserDefined.ConversionFunction)) { 793 QualType FromCanon 794 = S.Context.getCanonicalType(From->getType().getUnqualifiedType()); 795 QualType ToCanon 796 = S.Context.getCanonicalType(ToType).getUnqualifiedType(); 797 if (Constructor->isCopyConstructor() && 798 (FromCanon == ToCanon || S.IsDerivedFrom(FromCanon, ToCanon))) { 799 // Turn this into a "standard" conversion sequence, so that it 800 // gets ranked with standard conversion sequences. 801 ICS.setStandard(); 802 ICS.Standard.setAsIdentityConversion(); 803 ICS.Standard.setFromType(From->getType()); 804 ICS.Standard.setAllToTypes(ToType); 805 ICS.Standard.CopyConstructor = Constructor; 806 if (ToCanon != FromCanon) 807 ICS.Standard.Second = ICK_Derived_To_Base; 808 } 809 } 810 811 // C++ [over.best.ics]p4: 812 // However, when considering the argument of a user-defined 813 // conversion function that is a candidate by 13.3.1.3 when 814 // invoked for the copying of the temporary in the second step 815 // of a class copy-initialization, or by 13.3.1.4, 13.3.1.5, or 816 // 13.3.1.6 in all cases, only standard conversion sequences and 817 // ellipsis conversion sequences are allowed. 818 if (SuppressUserConversions && ICS.isUserDefined()) { 819 ICS.setBad(BadConversionSequence::suppressed_user, From, ToType); 820 } 821 } else if (UserDefResult == OR_Ambiguous && !SuppressUserConversions) { 822 ICS.setAmbiguous(); 823 ICS.Ambiguous.setFromType(From->getType()); 824 ICS.Ambiguous.setToType(ToType); 825 for (OverloadCandidateSet::iterator Cand = Conversions.begin(); 826 Cand != Conversions.end(); ++Cand) 827 if (Cand->Viable) 828 ICS.Ambiguous.addConversion(Cand->Function); 829 } else { 830 ICS.setBad(BadConversionSequence::no_conversion, From, ToType); 831 } 832 833 return ICS; 834} 835 836bool Sema::TryImplicitConversion(InitializationSequence &Sequence, 837 const InitializedEntity &Entity, 838 Expr *Initializer, 839 bool SuppressUserConversions, 840 bool AllowExplicitConversions, 841 bool InOverloadResolution) { 842 ImplicitConversionSequence ICS 843 = clang::TryImplicitConversion(*this, Initializer, Entity.getType(), 844 SuppressUserConversions, 845 AllowExplicitConversions, 846 InOverloadResolution); 847 if (ICS.isBad()) return true; 848 849 // Perform the actual conversion. 850 Sequence.AddConversionSequenceStep(ICS, Entity.getType()); 851 return false; 852} 853 854/// PerformImplicitConversion - Perform an implicit conversion of the 855/// expression From to the type ToType. Returns true if there was an 856/// error, false otherwise. The expression From is replaced with the 857/// converted expression. Flavor is the kind of conversion we're 858/// performing, used in the error message. If @p AllowExplicit, 859/// explicit user-defined conversions are permitted. 860bool 861Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 862 AssignmentAction Action, bool AllowExplicit) { 863 ImplicitConversionSequence ICS; 864 return PerformImplicitConversion(From, ToType, Action, AllowExplicit, ICS); 865} 866 867bool 868Sema::PerformImplicitConversion(Expr *&From, QualType ToType, 869 AssignmentAction Action, bool AllowExplicit, 870 ImplicitConversionSequence& ICS) { 871 ICS = clang::TryImplicitConversion(*this, From, ToType, 872 /*SuppressUserConversions=*/false, 873 AllowExplicit, 874 /*InOverloadResolution=*/false); 875 return PerformImplicitConversion(From, ToType, ICS, Action); 876} 877 878/// \brief Determine whether the conversion from FromType to ToType is a valid 879/// conversion that strips "noreturn" off the nested function type. 880static bool IsNoReturnConversion(ASTContext &Context, QualType FromType, 881 QualType ToType, QualType &ResultTy) { 882 if (Context.hasSameUnqualifiedType(FromType, ToType)) 883 return false; 884 885 // Strip the noreturn off the type we're converting from; noreturn can 886 // safely be removed. 887 FromType = Context.getNoReturnType(FromType, false); 888 if (!Context.hasSameUnqualifiedType(FromType, ToType)) 889 return false; 890 891 ResultTy = FromType; 892 return true; 893} 894 895/// \brief Determine whether the conversion from FromType to ToType is a valid 896/// vector conversion. 897/// 898/// \param ICK Will be set to the vector conversion kind, if this is a vector 899/// conversion. 900static bool IsVectorConversion(ASTContext &Context, QualType FromType, 901 QualType ToType, ImplicitConversionKind &ICK) { 902 // We need at least one of these types to be a vector type to have a vector 903 // conversion. 904 if (!ToType->isVectorType() && !FromType->isVectorType()) 905 return false; 906 907 // Identical types require no conversions. 908 if (Context.hasSameUnqualifiedType(FromType, ToType)) 909 return false; 910 911 // There are no conversions between extended vector types, only identity. 912 if (ToType->isExtVectorType()) { 913 // There are no conversions between extended vector types other than the 914 // identity conversion. 915 if (FromType->isExtVectorType()) 916 return false; 917 918 // Vector splat from any arithmetic type to a vector. 919 if (FromType->isArithmeticType()) { 920 ICK = ICK_Vector_Splat; 921 return true; 922 } 923 } 924 925 // We can perform the conversion between vector types in the following cases: 926 // 1)vector types are equivalent AltiVec and GCC vector types 927 // 2)lax vector conversions are permitted and the vector types are of the 928 // same size 929 if (ToType->isVectorType() && FromType->isVectorType()) { 930 if (Context.areCompatibleVectorTypes(FromType, ToType) || 931 (Context.getLangOptions().LaxVectorConversions && 932 (Context.getTypeSize(FromType) == Context.getTypeSize(ToType)))) { 933 ICK = ICK_Vector_Conversion; 934 return true; 935 } 936 } 937 938 return false; 939} 940 941/// IsStandardConversion - Determines whether there is a standard 942/// conversion sequence (C++ [conv], C++ [over.ics.scs]) from the 943/// expression From to the type ToType. Standard conversion sequences 944/// only consider non-class types; for conversions that involve class 945/// types, use TryImplicitConversion. If a conversion exists, SCS will 946/// contain the standard conversion sequence required to perform this 947/// conversion and this routine will return true. Otherwise, this 948/// routine will return false and the value of SCS is unspecified. 949static bool IsStandardConversion(Sema &S, Expr* From, QualType ToType, 950 bool InOverloadResolution, 951 StandardConversionSequence &SCS) { 952 QualType FromType = From->getType(); 953 954 // Standard conversions (C++ [conv]) 955 SCS.setAsIdentityConversion(); 956 SCS.DeprecatedStringLiteralToCharPtr = false; 957 SCS.IncompatibleObjC = false; 958 SCS.setFromType(FromType); 959 SCS.CopyConstructor = 0; 960 961 // There are no standard conversions for class types in C++, so 962 // abort early. When overloading in C, however, we do permit 963 if (FromType->isRecordType() || ToType->isRecordType()) { 964 if (S.getLangOptions().CPlusPlus) 965 return false; 966 967 // When we're overloading in C, we allow, as standard conversions, 968 } 969 970 // The first conversion can be an lvalue-to-rvalue conversion, 971 // array-to-pointer conversion, or function-to-pointer conversion 972 // (C++ 4p1). 973 974 if (FromType == S.Context.OverloadTy) { 975 DeclAccessPair AccessPair; 976 if (FunctionDecl *Fn 977 = S.ResolveAddressOfOverloadedFunction(From, ToType, false, 978 AccessPair)) { 979 // We were able to resolve the address of the overloaded function, 980 // so we can convert to the type of that function. 981 FromType = Fn->getType(); 982 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) { 983 if (!Method->isStatic()) { 984 Type *ClassType 985 = S.Context.getTypeDeclType(Method->getParent()).getTypePtr(); 986 FromType = S.Context.getMemberPointerType(FromType, ClassType); 987 } 988 } 989 990 // If the "from" expression takes the address of the overloaded 991 // function, update the type of the resulting expression accordingly. 992 if (FromType->getAs<FunctionType>()) 993 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(From->IgnoreParens())) 994 if (UnOp->getOpcode() == UO_AddrOf) 995 FromType = S.Context.getPointerType(FromType); 996 997 // Check that we've computed the proper type after overload resolution. 998 assert(S.Context.hasSameType(FromType, 999 S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType())); 1000 } else { 1001 return false; 1002 } 1003 } 1004 // Lvalue-to-rvalue conversion (C++ 4.1): 1005 // An lvalue (3.10) of a non-function, non-array type T can be 1006 // converted to an rvalue. 1007 bool argIsLValue = From->isLValue(); 1008 if (argIsLValue && 1009 !FromType->isFunctionType() && !FromType->isArrayType() && 1010 S.Context.getCanonicalType(FromType) != S.Context.OverloadTy) { 1011 SCS.First = ICK_Lvalue_To_Rvalue; 1012 1013 // If T is a non-class type, the type of the rvalue is the 1014 // cv-unqualified version of T. Otherwise, the type of the rvalue 1015 // is T (C++ 4.1p1). C++ can't get here with class types; in C, we 1016 // just strip the qualifiers because they don't matter. 1017 FromType = FromType.getUnqualifiedType(); 1018 } else if (FromType->isArrayType()) { 1019 // Array-to-pointer conversion (C++ 4.2) 1020 SCS.First = ICK_Array_To_Pointer; 1021 1022 // An lvalue or rvalue of type "array of N T" or "array of unknown 1023 // bound of T" can be converted to an rvalue of type "pointer to 1024 // T" (C++ 4.2p1). 1025 FromType = S.Context.getArrayDecayedType(FromType); 1026 1027 if (S.IsStringLiteralToNonConstPointerConversion(From, ToType)) { 1028 // This conversion is deprecated. (C++ D.4). 1029 SCS.DeprecatedStringLiteralToCharPtr = true; 1030 1031 // For the purpose of ranking in overload resolution 1032 // (13.3.3.1.1), this conversion is considered an 1033 // array-to-pointer conversion followed by a qualification 1034 // conversion (4.4). (C++ 4.2p2) 1035 SCS.Second = ICK_Identity; 1036 SCS.Third = ICK_Qualification; 1037 SCS.setAllToTypes(FromType); 1038 return true; 1039 } 1040 } else if (FromType->isFunctionType() && argIsLValue) { 1041 // Function-to-pointer conversion (C++ 4.3). 1042 SCS.First = ICK_Function_To_Pointer; 1043 1044 // An lvalue of function type T can be converted to an rvalue of 1045 // type "pointer to T." The result is a pointer to the 1046 // function. (C++ 4.3p1). 1047 FromType = S.Context.getPointerType(FromType); 1048 } else { 1049 // We don't require any conversions for the first step. 1050 SCS.First = ICK_Identity; 1051 } 1052 SCS.setToType(0, FromType); 1053 1054 // The second conversion can be an integral promotion, floating 1055 // point promotion, integral conversion, floating point conversion, 1056 // floating-integral conversion, pointer conversion, 1057 // pointer-to-member conversion, or boolean conversion (C++ 4p1). 1058 // For overloading in C, this can also be a "compatible-type" 1059 // conversion. 1060 bool IncompatibleObjC = false; 1061 ImplicitConversionKind SecondICK = ICK_Identity; 1062 if (S.Context.hasSameUnqualifiedType(FromType, ToType)) { 1063 // The unqualified versions of the types are the same: there's no 1064 // conversion to do. 1065 SCS.Second = ICK_Identity; 1066 } else if (S.IsIntegralPromotion(From, FromType, ToType)) { 1067 // Integral promotion (C++ 4.5). 1068 SCS.Second = ICK_Integral_Promotion; 1069 FromType = ToType.getUnqualifiedType(); 1070 } else if (S.IsFloatingPointPromotion(FromType, ToType)) { 1071 // Floating point promotion (C++ 4.6). 1072 SCS.Second = ICK_Floating_Promotion; 1073 FromType = ToType.getUnqualifiedType(); 1074 } else if (S.IsComplexPromotion(FromType, ToType)) { 1075 // Complex promotion (Clang extension) 1076 SCS.Second = ICK_Complex_Promotion; 1077 FromType = ToType.getUnqualifiedType(); 1078 } else if (ToType->isBooleanType() && 1079 (FromType->isArithmeticType() || 1080 FromType->isAnyPointerType() || 1081 FromType->isBlockPointerType() || 1082 FromType->isMemberPointerType() || 1083 FromType->isNullPtrType())) { 1084 // Boolean conversions (C++ 4.12). 1085 SCS.Second = ICK_Boolean_Conversion; 1086 FromType = S.Context.BoolTy; 1087 } else if (FromType->isIntegralOrUnscopedEnumerationType() && 1088 ToType->isIntegralType(S.Context)) { 1089 // Integral conversions (C++ 4.7). 1090 SCS.Second = ICK_Integral_Conversion; 1091 FromType = ToType.getUnqualifiedType(); 1092 } else if (FromType->isAnyComplexType() && ToType->isComplexType()) { 1093 // Complex conversions (C99 6.3.1.6) 1094 SCS.Second = ICK_Complex_Conversion; 1095 FromType = ToType.getUnqualifiedType(); 1096 } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) || 1097 (ToType->isAnyComplexType() && FromType->isArithmeticType())) { 1098 // Complex-real conversions (C99 6.3.1.7) 1099 SCS.Second = ICK_Complex_Real; 1100 FromType = ToType.getUnqualifiedType(); 1101 } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) { 1102 // Floating point conversions (C++ 4.8). 1103 SCS.Second = ICK_Floating_Conversion; 1104 FromType = ToType.getUnqualifiedType(); 1105 } else if ((FromType->isRealFloatingType() && 1106 ToType->isIntegralType(S.Context)) || 1107 (FromType->isIntegralOrUnscopedEnumerationType() && 1108 ToType->isRealFloatingType())) { 1109 // Floating-integral conversions (C++ 4.9). 1110 SCS.Second = ICK_Floating_Integral; 1111 FromType = ToType.getUnqualifiedType(); 1112 } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution, 1113 FromType, IncompatibleObjC)) { 1114 // Pointer conversions (C++ 4.10). 1115 SCS.Second = ICK_Pointer_Conversion; 1116 SCS.IncompatibleObjC = IncompatibleObjC; 1117 } else if (S.IsMemberPointerConversion(From, FromType, ToType, 1118 InOverloadResolution, FromType)) { 1119 // Pointer to member conversions (4.11). 1120 SCS.Second = ICK_Pointer_Member; 1121 } else if (IsVectorConversion(S.Context, FromType, ToType, SecondICK)) { 1122 SCS.Second = SecondICK; 1123 FromType = ToType.getUnqualifiedType(); 1124 } else if (!S.getLangOptions().CPlusPlus && 1125 S.Context.typesAreCompatible(ToType, FromType)) { 1126 // Compatible conversions (Clang extension for C function overloading) 1127 SCS.Second = ICK_Compatible_Conversion; 1128 FromType = ToType.getUnqualifiedType(); 1129 } else if (IsNoReturnConversion(S.Context, FromType, ToType, FromType)) { 1130 // Treat a conversion that strips "noreturn" as an identity conversion. 1131 SCS.Second = ICK_NoReturn_Adjustment; 1132 } else { 1133 // No second conversion required. 1134 SCS.Second = ICK_Identity; 1135 } 1136 SCS.setToType(1, FromType); 1137 1138 QualType CanonFrom; 1139 QualType CanonTo; 1140 // The third conversion can be a qualification conversion (C++ 4p1). 1141 if (S.IsQualificationConversion(FromType, ToType)) { 1142 SCS.Third = ICK_Qualification; 1143 FromType = ToType; 1144 CanonFrom = S.Context.getCanonicalType(FromType); 1145 CanonTo = S.Context.getCanonicalType(ToType); 1146 } else { 1147 // No conversion required 1148 SCS.Third = ICK_Identity; 1149 1150 // C++ [over.best.ics]p6: 1151 // [...] Any difference in top-level cv-qualification is 1152 // subsumed by the initialization itself and does not constitute 1153 // a conversion. [...] 1154 CanonFrom = S.Context.getCanonicalType(FromType); 1155 CanonTo = S.Context.getCanonicalType(ToType); 1156 if (CanonFrom.getLocalUnqualifiedType() 1157 == CanonTo.getLocalUnqualifiedType() && 1158 (CanonFrom.getLocalCVRQualifiers() != CanonTo.getLocalCVRQualifiers() 1159 || CanonFrom.getObjCGCAttr() != CanonTo.getObjCGCAttr())) { 1160 FromType = ToType; 1161 CanonFrom = CanonTo; 1162 } 1163 } 1164 SCS.setToType(2, FromType); 1165 1166 // If we have not converted the argument type to the parameter type, 1167 // this is a bad conversion sequence. 1168 if (CanonFrom != CanonTo) 1169 return false; 1170 1171 return true; 1172} 1173 1174/// IsIntegralPromotion - Determines whether the conversion from the 1175/// expression From (whose potentially-adjusted type is FromType) to 1176/// ToType is an integral promotion (C++ 4.5). If so, returns true and 1177/// sets PromotedType to the promoted type. 1178bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) { 1179 const BuiltinType *To = ToType->getAs<BuiltinType>(); 1180 // All integers are built-in. 1181 if (!To) { 1182 return false; 1183 } 1184 1185 // An rvalue of type char, signed char, unsigned char, short int, or 1186 // unsigned short int can be converted to an rvalue of type int if 1187 // int can represent all the values of the source type; otherwise, 1188 // the source rvalue can be converted to an rvalue of type unsigned 1189 // int (C++ 4.5p1). 1190 if (FromType->isPromotableIntegerType() && !FromType->isBooleanType() && 1191 !FromType->isEnumeralType()) { 1192 if (// We can promote any signed, promotable integer type to an int 1193 (FromType->isSignedIntegerType() || 1194 // We can promote any unsigned integer type whose size is 1195 // less than int to an int. 1196 (!FromType->isSignedIntegerType() && 1197 Context.getTypeSize(FromType) < Context.getTypeSize(ToType)))) { 1198 return To->getKind() == BuiltinType::Int; 1199 } 1200 1201 return To->getKind() == BuiltinType::UInt; 1202 } 1203 1204 // C++0x [conv.prom]p3: 1205 // A prvalue of an unscoped enumeration type whose underlying type is not 1206 // fixed (7.2) can be converted to an rvalue a prvalue of the first of the 1207 // following types that can represent all the values of the enumeration 1208 // (i.e., the values in the range bmin to bmax as described in 7.2): int, 1209 // unsigned int, long int, unsigned long int, long long int, or unsigned 1210 // long long int. If none of the types in that list can represent all the 1211 // values of the enumeration, an rvalue a prvalue of an unscoped enumeration 1212 // type can be converted to an rvalue a prvalue of the extended integer type 1213 // with lowest integer conversion rank (4.13) greater than the rank of long 1214 // long in which all the values of the enumeration can be represented. If 1215 // there are two such extended types, the signed one is chosen. 1216 if (const EnumType *FromEnumType = FromType->getAs<EnumType>()) { 1217 // C++0x 7.2p9: Note that this implicit enum to int conversion is not 1218 // provided for a scoped enumeration. 1219 if (FromEnumType->getDecl()->isScoped()) 1220 return false; 1221 1222 // We have already pre-calculated the promotion type, so this is trivial. 1223 if (ToType->isIntegerType() && 1224 !RequireCompleteType(From->getLocStart(), FromType, PDiag())) 1225 return Context.hasSameUnqualifiedType(ToType, 1226 FromEnumType->getDecl()->getPromotionType()); 1227 } 1228 1229 // C++0x [conv.prom]p2: 1230 // A prvalue of type char16_t, char32_t, or wchar_t (3.9.1) can be converted 1231 // to an rvalue a prvalue of the first of the following types that can 1232 // represent all the values of its underlying type: int, unsigned int, 1233 // long int, unsigned long int, long long int, or unsigned long long int. 1234 // If none of the types in that list can represent all the values of its 1235 // underlying type, an rvalue a prvalue of type char16_t, char32_t, 1236 // or wchar_t can be converted to an rvalue a prvalue of its underlying 1237 // type. 1238 if (FromType->isAnyCharacterType() && !FromType->isCharType() && 1239 ToType->isIntegerType()) { 1240 // Determine whether the type we're converting from is signed or 1241 // unsigned. 1242 bool FromIsSigned; 1243 uint64_t FromSize = Context.getTypeSize(FromType); 1244 1245 // FIXME: Is wchar_t signed or unsigned? We assume it's signed for now. 1246 FromIsSigned = true; 1247 1248 // The types we'll try to promote to, in the appropriate 1249 // order. Try each of these types. 1250 QualType PromoteTypes[6] = { 1251 Context.IntTy, Context.UnsignedIntTy, 1252 Context.LongTy, Context.UnsignedLongTy , 1253 Context.LongLongTy, Context.UnsignedLongLongTy 1254 }; 1255 for (int Idx = 0; Idx < 6; ++Idx) { 1256 uint64_t ToSize = Context.getTypeSize(PromoteTypes[Idx]); 1257 if (FromSize < ToSize || 1258 (FromSize == ToSize && 1259 FromIsSigned == PromoteTypes[Idx]->isSignedIntegerType())) { 1260 // We found the type that we can promote to. If this is the 1261 // type we wanted, we have a promotion. Otherwise, no 1262 // promotion. 1263 return Context.hasSameUnqualifiedType(ToType, PromoteTypes[Idx]); 1264 } 1265 } 1266 } 1267 1268 // An rvalue for an integral bit-field (9.6) can be converted to an 1269 // rvalue of type int if int can represent all the values of the 1270 // bit-field; otherwise, it can be converted to unsigned int if 1271 // unsigned int can represent all the values of the bit-field. If 1272 // the bit-field is larger yet, no integral promotion applies to 1273 // it. If the bit-field has an enumerated type, it is treated as any 1274 // other value of that type for promotion purposes (C++ 4.5p3). 1275 // FIXME: We should delay checking of bit-fields until we actually perform the 1276 // conversion. 1277 using llvm::APSInt; 1278 if (From) 1279 if (FieldDecl *MemberDecl = From->getBitField()) { 1280 APSInt BitWidth; 1281 if (FromType->isIntegralType(Context) && 1282 MemberDecl->getBitWidth()->isIntegerConstantExpr(BitWidth, Context)) { 1283 APSInt ToSize(BitWidth.getBitWidth(), BitWidth.isUnsigned()); 1284 ToSize = Context.getTypeSize(ToType); 1285 1286 // Are we promoting to an int from a bitfield that fits in an int? 1287 if (BitWidth < ToSize || 1288 (FromType->isSignedIntegerType() && BitWidth <= ToSize)) { 1289 return To->getKind() == BuiltinType::Int; 1290 } 1291 1292 // Are we promoting to an unsigned int from an unsigned bitfield 1293 // that fits into an unsigned int? 1294 if (FromType->isUnsignedIntegerType() && BitWidth <= ToSize) { 1295 return To->getKind() == BuiltinType::UInt; 1296 } 1297 1298 return false; 1299 } 1300 } 1301 1302 // An rvalue of type bool can be converted to an rvalue of type int, 1303 // with false becoming zero and true becoming one (C++ 4.5p4). 1304 if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) { 1305 return true; 1306 } 1307 1308 return false; 1309} 1310 1311/// IsFloatingPointPromotion - Determines whether the conversion from 1312/// FromType to ToType is a floating point promotion (C++ 4.6). If so, 1313/// returns true and sets PromotedType to the promoted type. 1314bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) { 1315 /// An rvalue of type float can be converted to an rvalue of type 1316 /// double. (C++ 4.6p1). 1317 if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>()) 1318 if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) { 1319 if (FromBuiltin->getKind() == BuiltinType::Float && 1320 ToBuiltin->getKind() == BuiltinType::Double) 1321 return true; 1322 1323 // C99 6.3.1.5p1: 1324 // When a float is promoted to double or long double, or a 1325 // double is promoted to long double [...]. 1326 if (!getLangOptions().CPlusPlus && 1327 (FromBuiltin->getKind() == BuiltinType::Float || 1328 FromBuiltin->getKind() == BuiltinType::Double) && 1329 (ToBuiltin->getKind() == BuiltinType::LongDouble)) 1330 return true; 1331 } 1332 1333 return false; 1334} 1335 1336/// \brief Determine if a conversion is a complex promotion. 1337/// 1338/// A complex promotion is defined as a complex -> complex conversion 1339/// where the conversion between the underlying real types is a 1340/// floating-point or integral promotion. 1341bool Sema::IsComplexPromotion(QualType FromType, QualType ToType) { 1342 const ComplexType *FromComplex = FromType->getAs<ComplexType>(); 1343 if (!FromComplex) 1344 return false; 1345 1346 const ComplexType *ToComplex = ToType->getAs<ComplexType>(); 1347 if (!ToComplex) 1348 return false; 1349 1350 return IsFloatingPointPromotion(FromComplex->getElementType(), 1351 ToComplex->getElementType()) || 1352 IsIntegralPromotion(0, FromComplex->getElementType(), 1353 ToComplex->getElementType()); 1354} 1355 1356/// BuildSimilarlyQualifiedPointerType - In a pointer conversion from 1357/// the pointer type FromPtr to a pointer to type ToPointee, with the 1358/// same type qualifiers as FromPtr has on its pointee type. ToType, 1359/// if non-empty, will be a pointer to ToType that may or may not have 1360/// the right set of qualifiers on its pointee. 1361static QualType 1362BuildSimilarlyQualifiedPointerType(const Type *FromPtr, 1363 QualType ToPointee, QualType ToType, 1364 ASTContext &Context) { 1365 assert((FromPtr->getTypeClass() == Type::Pointer || 1366 FromPtr->getTypeClass() == Type::ObjCObjectPointer) && 1367 "Invalid similarly-qualified pointer type"); 1368 QualType CanonFromPointee 1369 = Context.getCanonicalType(FromPtr->getPointeeType()); 1370 QualType CanonToPointee = Context.getCanonicalType(ToPointee); 1371 Qualifiers Quals = CanonFromPointee.getQualifiers(); 1372 1373 // Exact qualifier match -> return the pointer type we're converting to. 1374 if (CanonToPointee.getLocalQualifiers() == Quals) { 1375 // ToType is exactly what we need. Return it. 1376 if (!ToType.isNull()) 1377 return ToType.getUnqualifiedType(); 1378 1379 // Build a pointer to ToPointee. It has the right qualifiers 1380 // already. 1381 if (isa<ObjCObjectPointerType>(ToType)) 1382 return Context.getObjCObjectPointerType(ToPointee); 1383 return Context.getPointerType(ToPointee); 1384 } 1385 1386 // Just build a canonical type that has the right qualifiers. 1387 QualType QualifiedCanonToPointee 1388 = Context.getQualifiedType(CanonToPointee.getLocalUnqualifiedType(), Quals); 1389 1390 if (isa<ObjCObjectPointerType>(ToType)) 1391 return Context.getObjCObjectPointerType(QualifiedCanonToPointee); 1392 return Context.getPointerType(QualifiedCanonToPointee); 1393} 1394 1395static bool isNullPointerConstantForConversion(Expr *Expr, 1396 bool InOverloadResolution, 1397 ASTContext &Context) { 1398 // Handle value-dependent integral null pointer constants correctly. 1399 // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#903 1400 if (Expr->isValueDependent() && !Expr->isTypeDependent() && 1401 Expr->getType()->isIntegerType() && !Expr->getType()->isEnumeralType()) 1402 return !InOverloadResolution; 1403 1404 return Expr->isNullPointerConstant(Context, 1405 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull 1406 : Expr::NPC_ValueDependentIsNull); 1407} 1408 1409/// IsPointerConversion - Determines whether the conversion of the 1410/// expression From, which has the (possibly adjusted) type FromType, 1411/// can be converted to the type ToType via a pointer conversion (C++ 1412/// 4.10). If so, returns true and places the converted type (that 1413/// might differ from ToType in its cv-qualifiers at some level) into 1414/// ConvertedType. 1415/// 1416/// This routine also supports conversions to and from block pointers 1417/// and conversions with Objective-C's 'id', 'id<protocols...>', and 1418/// pointers to interfaces. FIXME: Once we've determined the 1419/// appropriate overloading rules for Objective-C, we may want to 1420/// split the Objective-C checks into a different routine; however, 1421/// GCC seems to consider all of these conversions to be pointer 1422/// conversions, so for now they live here. IncompatibleObjC will be 1423/// set if the conversion is an allowed Objective-C conversion that 1424/// should result in a warning. 1425bool Sema::IsPointerConversion(Expr *From, QualType FromType, QualType ToType, 1426 bool InOverloadResolution, 1427 QualType& ConvertedType, 1428 bool &IncompatibleObjC) { 1429 IncompatibleObjC = false; 1430 if (isObjCPointerConversion(FromType, ToType, ConvertedType, IncompatibleObjC)) 1431 return true; 1432 1433 // Conversion from a null pointer constant to any Objective-C pointer type. 1434 if (ToType->isObjCObjectPointerType() && 1435 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 1436 ConvertedType = ToType; 1437 return true; 1438 } 1439 1440 // Blocks: Block pointers can be converted to void*. 1441 if (FromType->isBlockPointerType() && ToType->isPointerType() && 1442 ToType->getAs<PointerType>()->getPointeeType()->isVoidType()) { 1443 ConvertedType = ToType; 1444 return true; 1445 } 1446 // Blocks: A null pointer constant can be converted to a block 1447 // pointer type. 1448 if (ToType->isBlockPointerType() && 1449 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 1450 ConvertedType = ToType; 1451 return true; 1452 } 1453 1454 // If the left-hand-side is nullptr_t, the right side can be a null 1455 // pointer constant. 1456 if (ToType->isNullPtrType() && 1457 isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 1458 ConvertedType = ToType; 1459 return true; 1460 } 1461 1462 const PointerType* ToTypePtr = ToType->getAs<PointerType>(); 1463 if (!ToTypePtr) 1464 return false; 1465 1466 // A null pointer constant can be converted to a pointer type (C++ 4.10p1). 1467 if (isNullPointerConstantForConversion(From, InOverloadResolution, Context)) { 1468 ConvertedType = ToType; 1469 return true; 1470 } 1471 1472 // Beyond this point, both types need to be pointers 1473 // , including objective-c pointers. 1474 QualType ToPointeeType = ToTypePtr->getPointeeType(); 1475 if (FromType->isObjCObjectPointerType() && ToPointeeType->isVoidType()) { 1476 ConvertedType = BuildSimilarlyQualifiedPointerType( 1477 FromType->getAs<ObjCObjectPointerType>(), 1478 ToPointeeType, 1479 ToType, Context); 1480 return true; 1481 } 1482 const PointerType *FromTypePtr = FromType->getAs<PointerType>(); 1483 if (!FromTypePtr) 1484 return false; 1485 1486 QualType FromPointeeType = FromTypePtr->getPointeeType(); 1487 1488 // If the unqualified pointee types are the same, this can't be a 1489 // pointer conversion, so don't do all of the work below. 1490 if (Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) 1491 return false; 1492 1493 // An rvalue of type "pointer to cv T," where T is an object type, 1494 // can be converted to an rvalue of type "pointer to cv void" (C++ 1495 // 4.10p2). 1496 if (FromPointeeType->isIncompleteOrObjectType() && 1497 ToPointeeType->isVoidType()) { 1498 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 1499 ToPointeeType, 1500 ToType, Context); 1501 return true; 1502 } 1503 1504 // When we're overloading in C, we allow a special kind of pointer 1505 // conversion for compatible-but-not-identical pointee types. 1506 if (!getLangOptions().CPlusPlus && 1507 Context.typesAreCompatible(FromPointeeType, ToPointeeType)) { 1508 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 1509 ToPointeeType, 1510 ToType, Context); 1511 return true; 1512 } 1513 1514 // C++ [conv.ptr]p3: 1515 // 1516 // An rvalue of type "pointer to cv D," where D is a class type, 1517 // can be converted to an rvalue of type "pointer to cv B," where 1518 // B is a base class (clause 10) of D. If B is an inaccessible 1519 // (clause 11) or ambiguous (10.2) base class of D, a program that 1520 // necessitates this conversion is ill-formed. The result of the 1521 // conversion is a pointer to the base class sub-object of the 1522 // derived class object. The null pointer value is converted to 1523 // the null pointer value of the destination type. 1524 // 1525 // Note that we do not check for ambiguity or inaccessibility 1526 // here. That is handled by CheckPointerConversion. 1527 if (getLangOptions().CPlusPlus && 1528 FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && 1529 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType) && 1530 !RequireCompleteType(From->getLocStart(), FromPointeeType, PDiag()) && 1531 IsDerivedFrom(FromPointeeType, ToPointeeType)) { 1532 ConvertedType = BuildSimilarlyQualifiedPointerType(FromTypePtr, 1533 ToPointeeType, 1534 ToType, Context); 1535 return true; 1536 } 1537 1538 return false; 1539} 1540 1541/// isObjCPointerConversion - Determines whether this is an 1542/// Objective-C pointer conversion. Subroutine of IsPointerConversion, 1543/// with the same arguments and return values. 1544bool Sema::isObjCPointerConversion(QualType FromType, QualType ToType, 1545 QualType& ConvertedType, 1546 bool &IncompatibleObjC) { 1547 if (!getLangOptions().ObjC1) 1548 return false; 1549 1550 // First, we handle all conversions on ObjC object pointer types. 1551 const ObjCObjectPointerType* ToObjCPtr = ToType->getAs<ObjCObjectPointerType>(); 1552 const ObjCObjectPointerType *FromObjCPtr = 1553 FromType->getAs<ObjCObjectPointerType>(); 1554 1555 if (ToObjCPtr && FromObjCPtr) { 1556 // If the pointee types are the same (ignoring qualifications), 1557 // then this is not a pointer conversion. 1558 if (Context.hasSameUnqualifiedType(ToObjCPtr->getPointeeType(), 1559 FromObjCPtr->getPointeeType())) 1560 return false; 1561 1562 // Objective C++: We're able to convert between "id" or "Class" and a 1563 // pointer to any interface (in both directions). 1564 if (ToObjCPtr->isObjCBuiltinType() && FromObjCPtr->isObjCBuiltinType()) { 1565 ConvertedType = ToType; 1566 return true; 1567 } 1568 // Conversions with Objective-C's id<...>. 1569 if ((FromObjCPtr->isObjCQualifiedIdType() || 1570 ToObjCPtr->isObjCQualifiedIdType()) && 1571 Context.ObjCQualifiedIdTypesAreCompatible(ToType, FromType, 1572 /*compare=*/false)) { 1573 ConvertedType = ToType; 1574 return true; 1575 } 1576 // Objective C++: We're able to convert from a pointer to an 1577 // interface to a pointer to a different interface. 1578 if (Context.canAssignObjCInterfaces(ToObjCPtr, FromObjCPtr)) { 1579 const ObjCInterfaceType* LHS = ToObjCPtr->getInterfaceType(); 1580 const ObjCInterfaceType* RHS = FromObjCPtr->getInterfaceType(); 1581 if (getLangOptions().CPlusPlus && LHS && RHS && 1582 !ToObjCPtr->getPointeeType().isAtLeastAsQualifiedAs( 1583 FromObjCPtr->getPointeeType())) 1584 return false; 1585 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr, 1586 ToObjCPtr->getPointeeType(), 1587 ToType, Context); 1588 return true; 1589 } 1590 1591 if (Context.canAssignObjCInterfaces(FromObjCPtr, ToObjCPtr)) { 1592 // Okay: this is some kind of implicit downcast of Objective-C 1593 // interfaces, which is permitted. However, we're going to 1594 // complain about it. 1595 IncompatibleObjC = true; 1596 ConvertedType = BuildSimilarlyQualifiedPointerType(FromObjCPtr, 1597 ToObjCPtr->getPointeeType(), 1598 ToType, Context); 1599 return true; 1600 } 1601 } 1602 // Beyond this point, both types need to be C pointers or block pointers. 1603 QualType ToPointeeType; 1604 if (const PointerType *ToCPtr = ToType->getAs<PointerType>()) 1605 ToPointeeType = ToCPtr->getPointeeType(); 1606 else if (const BlockPointerType *ToBlockPtr = 1607 ToType->getAs<BlockPointerType>()) { 1608 // Objective C++: We're able to convert from a pointer to any object 1609 // to a block pointer type. 1610 if (FromObjCPtr && FromObjCPtr->isObjCBuiltinType()) { 1611 ConvertedType = ToType; 1612 return true; 1613 } 1614 ToPointeeType = ToBlockPtr->getPointeeType(); 1615 } 1616 else if (FromType->getAs<BlockPointerType>() && 1617 ToObjCPtr && ToObjCPtr->isObjCBuiltinType()) { 1618 // Objective C++: We're able to convert from a block pointer type to a 1619 // pointer to any object. 1620 ConvertedType = ToType; 1621 return true; 1622 } 1623 else 1624 return false; 1625 1626 QualType FromPointeeType; 1627 if (const PointerType *FromCPtr = FromType->getAs<PointerType>()) 1628 FromPointeeType = FromCPtr->getPointeeType(); 1629 else if (const BlockPointerType *FromBlockPtr = FromType->getAs<BlockPointerType>()) 1630 FromPointeeType = FromBlockPtr->getPointeeType(); 1631 else 1632 return false; 1633 1634 // If we have pointers to pointers, recursively check whether this 1635 // is an Objective-C conversion. 1636 if (FromPointeeType->isPointerType() && ToPointeeType->isPointerType() && 1637 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType, 1638 IncompatibleObjC)) { 1639 // We always complain about this conversion. 1640 IncompatibleObjC = true; 1641 ConvertedType = Context.getPointerType(ConvertedType); 1642 return true; 1643 } 1644 // Allow conversion of pointee being objective-c pointer to another one; 1645 // as in I* to id. 1646 if (FromPointeeType->getAs<ObjCObjectPointerType>() && 1647 ToPointeeType->getAs<ObjCObjectPointerType>() && 1648 isObjCPointerConversion(FromPointeeType, ToPointeeType, ConvertedType, 1649 IncompatibleObjC)) { 1650 ConvertedType = Context.getPointerType(ConvertedType); 1651 return true; 1652 } 1653 1654 // If we have pointers to functions or blocks, check whether the only 1655 // differences in the argument and result types are in Objective-C 1656 // pointer conversions. If so, we permit the conversion (but 1657 // complain about it). 1658 const FunctionProtoType *FromFunctionType 1659 = FromPointeeType->getAs<FunctionProtoType>(); 1660 const FunctionProtoType *ToFunctionType 1661 = ToPointeeType->getAs<FunctionProtoType>(); 1662 if (FromFunctionType && ToFunctionType) { 1663 // If the function types are exactly the same, this isn't an 1664 // Objective-C pointer conversion. 1665 if (Context.getCanonicalType(FromPointeeType) 1666 == Context.getCanonicalType(ToPointeeType)) 1667 return false; 1668 1669 // Perform the quick checks that will tell us whether these 1670 // function types are obviously different. 1671 if (FromFunctionType->getNumArgs() != ToFunctionType->getNumArgs() || 1672 FromFunctionType->isVariadic() != ToFunctionType->isVariadic() || 1673 FromFunctionType->getTypeQuals() != ToFunctionType->getTypeQuals()) 1674 return false; 1675 1676 bool HasObjCConversion = false; 1677 if (Context.getCanonicalType(FromFunctionType->getResultType()) 1678 == Context.getCanonicalType(ToFunctionType->getResultType())) { 1679 // Okay, the types match exactly. Nothing to do. 1680 } else if (isObjCPointerConversion(FromFunctionType->getResultType(), 1681 ToFunctionType->getResultType(), 1682 ConvertedType, IncompatibleObjC)) { 1683 // Okay, we have an Objective-C pointer conversion. 1684 HasObjCConversion = true; 1685 } else { 1686 // Function types are too different. Abort. 1687 return false; 1688 } 1689 1690 // Check argument types. 1691 for (unsigned ArgIdx = 0, NumArgs = FromFunctionType->getNumArgs(); 1692 ArgIdx != NumArgs; ++ArgIdx) { 1693 QualType FromArgType = FromFunctionType->getArgType(ArgIdx); 1694 QualType ToArgType = ToFunctionType->getArgType(ArgIdx); 1695 if (Context.getCanonicalType(FromArgType) 1696 == Context.getCanonicalType(ToArgType)) { 1697 // Okay, the types match exactly. Nothing to do. 1698 } else if (isObjCPointerConversion(FromArgType, ToArgType, 1699 ConvertedType, IncompatibleObjC)) { 1700 // Okay, we have an Objective-C pointer conversion. 1701 HasObjCConversion = true; 1702 } else { 1703 // Argument types are too different. Abort. 1704 return false; 1705 } 1706 } 1707 1708 if (HasObjCConversion) { 1709 // We had an Objective-C conversion. Allow this pointer 1710 // conversion, but complain about it. 1711 ConvertedType = ToType; 1712 IncompatibleObjC = true; 1713 return true; 1714 } 1715 } 1716 1717 return false; 1718} 1719 1720/// FunctionArgTypesAreEqual - This routine checks two function proto types 1721/// for equlity of their argument types. Caller has already checked that 1722/// they have same number of arguments. This routine assumes that Objective-C 1723/// pointer types which only differ in their protocol qualifiers are equal. 1724bool Sema::FunctionArgTypesAreEqual(FunctionProtoType* OldType, 1725 FunctionProtoType* NewType){ 1726 if (!getLangOptions().ObjC1) 1727 return std::equal(OldType->arg_type_begin(), OldType->arg_type_end(), 1728 NewType->arg_type_begin()); 1729 1730 for (FunctionProtoType::arg_type_iterator O = OldType->arg_type_begin(), 1731 N = NewType->arg_type_begin(), 1732 E = OldType->arg_type_end(); O && (O != E); ++O, ++N) { 1733 QualType ToType = (*O); 1734 QualType FromType = (*N); 1735 if (ToType != FromType) { 1736 if (const PointerType *PTTo = ToType->getAs<PointerType>()) { 1737 if (const PointerType *PTFr = FromType->getAs<PointerType>()) 1738 if ((PTTo->getPointeeType()->isObjCQualifiedIdType() && 1739 PTFr->getPointeeType()->isObjCQualifiedIdType()) || 1740 (PTTo->getPointeeType()->isObjCQualifiedClassType() && 1741 PTFr->getPointeeType()->isObjCQualifiedClassType())) 1742 continue; 1743 } 1744 else if (const ObjCObjectPointerType *PTTo = 1745 ToType->getAs<ObjCObjectPointerType>()) { 1746 if (const ObjCObjectPointerType *PTFr = 1747 FromType->getAs<ObjCObjectPointerType>()) 1748 if (PTTo->getInterfaceDecl() == PTFr->getInterfaceDecl()) 1749 continue; 1750 } 1751 return false; 1752 } 1753 } 1754 return true; 1755} 1756 1757/// CheckPointerConversion - Check the pointer conversion from the 1758/// expression From to the type ToType. This routine checks for 1759/// ambiguous or inaccessible derived-to-base pointer 1760/// conversions for which IsPointerConversion has already returned 1761/// true. It returns true and produces a diagnostic if there was an 1762/// error, or returns false otherwise. 1763bool Sema::CheckPointerConversion(Expr *From, QualType ToType, 1764 CastKind &Kind, 1765 CXXCastPath& BasePath, 1766 bool IgnoreBaseAccess) { 1767 QualType FromType = From->getType(); 1768 bool IsCStyleOrFunctionalCast = IgnoreBaseAccess; 1769 1770 Kind = CK_BitCast; 1771 1772 if (CXXBoolLiteralExpr* LitBool 1773 = dyn_cast<CXXBoolLiteralExpr>(From->IgnoreParens())) 1774 if (!IsCStyleOrFunctionalCast && LitBool->getValue() == false) 1775 Diag(LitBool->getExprLoc(), diag::warn_init_pointer_from_false) 1776 << ToType; 1777 1778 if (const PointerType *FromPtrType = FromType->getAs<PointerType>()) 1779 if (const PointerType *ToPtrType = ToType->getAs<PointerType>()) { 1780 QualType FromPointeeType = FromPtrType->getPointeeType(), 1781 ToPointeeType = ToPtrType->getPointeeType(); 1782 1783 if (FromPointeeType->isRecordType() && ToPointeeType->isRecordType() && 1784 !Context.hasSameUnqualifiedType(FromPointeeType, ToPointeeType)) { 1785 // We must have a derived-to-base conversion. Check an 1786 // ambiguous or inaccessible conversion. 1787 if (CheckDerivedToBaseConversion(FromPointeeType, ToPointeeType, 1788 From->getExprLoc(), 1789 From->getSourceRange(), &BasePath, 1790 IgnoreBaseAccess)) 1791 return true; 1792 1793 // The conversion was successful. 1794 Kind = CK_DerivedToBase; 1795 } 1796 } 1797 if (const ObjCObjectPointerType *FromPtrType = 1798 FromType->getAs<ObjCObjectPointerType>()) { 1799 if (const ObjCObjectPointerType *ToPtrType = 1800 ToType->getAs<ObjCObjectPointerType>()) { 1801 // Objective-C++ conversions are always okay. 1802 // FIXME: We should have a different class of conversions for the 1803 // Objective-C++ implicit conversions. 1804 if (FromPtrType->isObjCBuiltinType() || ToPtrType->isObjCBuiltinType()) 1805 return false; 1806 } 1807 } 1808 1809 // We shouldn't fall into this case unless it's valid for other 1810 // reasons. 1811 if (From->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull)) 1812 Kind = CK_NullToPointer; 1813 1814 return false; 1815} 1816 1817/// IsMemberPointerConversion - Determines whether the conversion of the 1818/// expression From, which has the (possibly adjusted) type FromType, can be 1819/// converted to the type ToType via a member pointer conversion (C++ 4.11). 1820/// If so, returns true and places the converted type (that might differ from 1821/// ToType in its cv-qualifiers at some level) into ConvertedType. 1822bool Sema::IsMemberPointerConversion(Expr *From, QualType FromType, 1823 QualType ToType, 1824 bool InOverloadResolution, 1825 QualType &ConvertedType) { 1826 const MemberPointerType *ToTypePtr = ToType->getAs<MemberPointerType>(); 1827 if (!ToTypePtr) 1828 return false; 1829 1830 // A null pointer constant can be converted to a member pointer (C++ 4.11p1) 1831 if (From->isNullPointerConstant(Context, 1832 InOverloadResolution? Expr::NPC_ValueDependentIsNotNull 1833 : Expr::NPC_ValueDependentIsNull)) { 1834 ConvertedType = ToType; 1835 return true; 1836 } 1837 1838 // Otherwise, both types have to be member pointers. 1839 const MemberPointerType *FromTypePtr = FromType->getAs<MemberPointerType>(); 1840 if (!FromTypePtr) 1841 return false; 1842 1843 // A pointer to member of B can be converted to a pointer to member of D, 1844 // where D is derived from B (C++ 4.11p2). 1845 QualType FromClass(FromTypePtr->getClass(), 0); 1846 QualType ToClass(ToTypePtr->getClass(), 0); 1847 // FIXME: What happens when these are dependent? Is this function even called? 1848 1849 if (IsDerivedFrom(ToClass, FromClass)) { 1850 ConvertedType = Context.getMemberPointerType(FromTypePtr->getPointeeType(), 1851 ToClass.getTypePtr()); 1852 return true; 1853 } 1854 1855 return false; 1856} 1857 1858/// CheckMemberPointerConversion - Check the member pointer conversion from the 1859/// expression From to the type ToType. This routine checks for ambiguous or 1860/// virtual or inaccessible base-to-derived member pointer conversions 1861/// for which IsMemberPointerConversion has already returned true. It returns 1862/// true and produces a diagnostic if there was an error, or returns false 1863/// otherwise. 1864bool Sema::CheckMemberPointerConversion(Expr *From, QualType ToType, 1865 CastKind &Kind, 1866 CXXCastPath &BasePath, 1867 bool IgnoreBaseAccess) { 1868 QualType FromType = From->getType(); 1869 const MemberPointerType *FromPtrType = FromType->getAs<MemberPointerType>(); 1870 if (!FromPtrType) { 1871 // This must be a null pointer to member pointer conversion 1872 assert(From->isNullPointerConstant(Context, 1873 Expr::NPC_ValueDependentIsNull) && 1874 "Expr must be null pointer constant!"); 1875 Kind = CK_NullToMemberPointer; 1876 return false; 1877 } 1878 1879 const MemberPointerType *ToPtrType = ToType->getAs<MemberPointerType>(); 1880 assert(ToPtrType && "No member pointer cast has a target type " 1881 "that is not a member pointer."); 1882 1883 QualType FromClass = QualType(FromPtrType->getClass(), 0); 1884 QualType ToClass = QualType(ToPtrType->getClass(), 0); 1885 1886 // FIXME: What about dependent types? 1887 assert(FromClass->isRecordType() && "Pointer into non-class."); 1888 assert(ToClass->isRecordType() && "Pointer into non-class."); 1889 1890 CXXBasePaths Paths(/*FindAmbiguities=*/true, /*RecordPaths=*/true, 1891 /*DetectVirtual=*/true); 1892 bool DerivationOkay = IsDerivedFrom(ToClass, FromClass, Paths); 1893 assert(DerivationOkay && 1894 "Should not have been called if derivation isn't OK."); 1895 (void)DerivationOkay; 1896 1897 if (Paths.isAmbiguous(Context.getCanonicalType(FromClass). 1898 getUnqualifiedType())) { 1899 std::string PathDisplayStr = getAmbiguousPathsDisplayString(Paths); 1900 Diag(From->getExprLoc(), diag::err_ambiguous_memptr_conv) 1901 << 0 << FromClass << ToClass << PathDisplayStr << From->getSourceRange(); 1902 return true; 1903 } 1904 1905 if (const RecordType *VBase = Paths.getDetectedVirtual()) { 1906 Diag(From->getExprLoc(), diag::err_memptr_conv_via_virtual) 1907 << FromClass << ToClass << QualType(VBase, 0) 1908 << From->getSourceRange(); 1909 return true; 1910 } 1911 1912 if (!IgnoreBaseAccess) 1913 CheckBaseClassAccess(From->getExprLoc(), FromClass, ToClass, 1914 Paths.front(), 1915 diag::err_downcast_from_inaccessible_base); 1916 1917 // Must be a base to derived member conversion. 1918 BuildBasePathArray(Paths, BasePath); 1919 Kind = CK_BaseToDerivedMemberPointer; 1920 return false; 1921} 1922 1923/// IsQualificationConversion - Determines whether the conversion from 1924/// an rvalue of type FromType to ToType is a qualification conversion 1925/// (C++ 4.4). 1926bool 1927Sema::IsQualificationConversion(QualType FromType, QualType ToType) { 1928 FromType = Context.getCanonicalType(FromType); 1929 ToType = Context.getCanonicalType(ToType); 1930 1931 // If FromType and ToType are the same type, this is not a 1932 // qualification conversion. 1933 if (FromType.getUnqualifiedType() == ToType.getUnqualifiedType()) 1934 return false; 1935 1936 // (C++ 4.4p4): 1937 // A conversion can add cv-qualifiers at levels other than the first 1938 // in multi-level pointers, subject to the following rules: [...] 1939 bool PreviousToQualsIncludeConst = true; 1940 bool UnwrappedAnyPointer = false; 1941 while (Context.UnwrapSimilarPointerTypes(FromType, ToType)) { 1942 // Within each iteration of the loop, we check the qualifiers to 1943 // determine if this still looks like a qualification 1944 // conversion. Then, if all is well, we unwrap one more level of 1945 // pointers or pointers-to-members and do it all again 1946 // until there are no more pointers or pointers-to-members left to 1947 // unwrap. 1948 UnwrappedAnyPointer = true; 1949 1950 // -- for every j > 0, if const is in cv 1,j then const is in cv 1951 // 2,j, and similarly for volatile. 1952 if (!ToType.isAtLeastAsQualifiedAs(FromType)) 1953 return false; 1954 1955 // -- if the cv 1,j and cv 2,j are different, then const is in 1956 // every cv for 0 < k < j. 1957 if (FromType.getCVRQualifiers() != ToType.getCVRQualifiers() 1958 && !PreviousToQualsIncludeConst) 1959 return false; 1960 1961 // Keep track of whether all prior cv-qualifiers in the "to" type 1962 // include const. 1963 PreviousToQualsIncludeConst 1964 = PreviousToQualsIncludeConst && ToType.isConstQualified(); 1965 } 1966 1967 // We are left with FromType and ToType being the pointee types 1968 // after unwrapping the original FromType and ToType the same number 1969 // of types. If we unwrapped any pointers, and if FromType and 1970 // ToType have the same unqualified type (since we checked 1971 // qualifiers above), then this is a qualification conversion. 1972 return UnwrappedAnyPointer && Context.hasSameUnqualifiedType(FromType,ToType); 1973} 1974 1975/// Determines whether there is a user-defined conversion sequence 1976/// (C++ [over.ics.user]) that converts expression From to the type 1977/// ToType. If such a conversion exists, User will contain the 1978/// user-defined conversion sequence that performs such a conversion 1979/// and this routine will return true. Otherwise, this routine returns 1980/// false and User is unspecified. 1981/// 1982/// \param AllowExplicit true if the conversion should consider C++0x 1983/// "explicit" conversion functions as well as non-explicit conversion 1984/// functions (C++0x [class.conv.fct]p2). 1985static OverloadingResult 1986IsUserDefinedConversion(Sema &S, Expr *From, QualType ToType, 1987 UserDefinedConversionSequence& User, 1988 OverloadCandidateSet& CandidateSet, 1989 bool AllowExplicit) { 1990 // Whether we will only visit constructors. 1991 bool ConstructorsOnly = false; 1992 1993 // If the type we are conversion to is a class type, enumerate its 1994 // constructors. 1995 if (const RecordType *ToRecordType = ToType->getAs<RecordType>()) { 1996 // C++ [over.match.ctor]p1: 1997 // When objects of class type are direct-initialized (8.5), or 1998 // copy-initialized from an expression of the same or a 1999 // derived class type (8.5), overload resolution selects the 2000 // constructor. [...] For copy-initialization, the candidate 2001 // functions are all the converting constructors (12.3.1) of 2002 // that class. The argument list is the expression-list within 2003 // the parentheses of the initializer. 2004 if (S.Context.hasSameUnqualifiedType(ToType, From->getType()) || 2005 (From->getType()->getAs<RecordType>() && 2006 S.IsDerivedFrom(From->getType(), ToType))) 2007 ConstructorsOnly = true; 2008 2009 if (S.RequireCompleteType(From->getLocStart(), ToType, S.PDiag())) { 2010 // We're not going to find any constructors. 2011 } else if (CXXRecordDecl *ToRecordDecl 2012 = dyn_cast<CXXRecordDecl>(ToRecordType->getDecl())) { 2013 DeclContext::lookup_iterator Con, ConEnd; 2014 for (llvm::tie(Con, ConEnd) = S.LookupConstructors(ToRecordDecl); 2015 Con != ConEnd; ++Con) { 2016 NamedDecl *D = *Con; 2017 DeclAccessPair FoundDecl = DeclAccessPair::make(D, D->getAccess()); 2018 2019 // Find the constructor (which may be a template). 2020 CXXConstructorDecl *Constructor = 0; 2021 FunctionTemplateDecl *ConstructorTmpl 2022 = dyn_cast<FunctionTemplateDecl>(D); 2023 if (ConstructorTmpl) 2024 Constructor 2025 = cast<CXXConstructorDecl>(ConstructorTmpl->getTemplatedDecl()); 2026 else 2027 Constructor = cast<CXXConstructorDecl>(D); 2028 2029 if (!Constructor->isInvalidDecl() && 2030 Constructor->isConvertingConstructor(AllowExplicit)) { 2031 if (ConstructorTmpl) 2032 S.AddTemplateOverloadCandidate(ConstructorTmpl, FoundDecl, 2033 /*ExplicitArgs*/ 0, 2034 &From, 1, CandidateSet, 2035 /*SuppressUserConversions=*/ 2036 !ConstructorsOnly); 2037 else 2038 // Allow one user-defined conversion when user specifies a 2039 // From->ToType conversion via an static cast (c-style, etc). 2040 S.AddOverloadCandidate(Constructor, FoundDecl, 2041 &From, 1, CandidateSet, 2042 /*SuppressUserConversions=*/ 2043 !ConstructorsOnly); 2044 } 2045 } 2046 } 2047 } 2048 2049 // Enumerate conversion functions, if we're allowed to. 2050 if (ConstructorsOnly) { 2051 } else if (S.RequireCompleteType(From->getLocStart(), From->getType(), 2052 S.PDiag(0) << From->getSourceRange())) { 2053 // No conversion functions from incomplete types. 2054 } else if (const RecordType *FromRecordType 2055 = From->getType()->getAs<RecordType>()) { 2056 if (CXXRecordDecl *FromRecordDecl 2057 = dyn_cast<CXXRecordDecl>(FromRecordType->getDecl())) { 2058 // Add all of the conversion functions as candidates. 2059 const UnresolvedSetImpl *Conversions 2060 = FromRecordDecl->getVisibleConversionFunctions(); 2061 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 2062 E = Conversions->end(); I != E; ++I) { 2063 DeclAccessPair FoundDecl = I.getPair(); 2064 NamedDecl *D = FoundDecl.getDecl(); 2065 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 2066 if (isa<UsingShadowDecl>(D)) 2067 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2068 2069 CXXConversionDecl *Conv; 2070 FunctionTemplateDecl *ConvTemplate; 2071 if ((ConvTemplate = dyn_cast<FunctionTemplateDecl>(D))) 2072 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 2073 else 2074 Conv = cast<CXXConversionDecl>(D); 2075 2076 if (AllowExplicit || !Conv->isExplicit()) { 2077 if (ConvTemplate) 2078 S.AddTemplateConversionCandidate(ConvTemplate, FoundDecl, 2079 ActingContext, From, ToType, 2080 CandidateSet); 2081 else 2082 S.AddConversionCandidate(Conv, FoundDecl, ActingContext, 2083 From, ToType, CandidateSet); 2084 } 2085 } 2086 } 2087 } 2088 2089 OverloadCandidateSet::iterator Best; 2090 switch (CandidateSet.BestViableFunction(S, From->getLocStart(), Best, true)) { 2091 case OR_Success: 2092 // Record the standard conversion we used and the conversion function. 2093 if (CXXConstructorDecl *Constructor 2094 = dyn_cast<CXXConstructorDecl>(Best->Function)) { 2095 // C++ [over.ics.user]p1: 2096 // If the user-defined conversion is specified by a 2097 // constructor (12.3.1), the initial standard conversion 2098 // sequence converts the source type to the type required by 2099 // the argument of the constructor. 2100 // 2101 QualType ThisType = Constructor->getThisType(S.Context); 2102 if (Best->Conversions[0].isEllipsis()) 2103 User.EllipsisConversion = true; 2104 else { 2105 User.Before = Best->Conversions[0].Standard; 2106 User.EllipsisConversion = false; 2107 } 2108 User.ConversionFunction = Constructor; 2109 User.After.setAsIdentityConversion(); 2110 User.After.setFromType(ThisType->getAs<PointerType>()->getPointeeType()); 2111 User.After.setAllToTypes(ToType); 2112 return OR_Success; 2113 } else if (CXXConversionDecl *Conversion 2114 = dyn_cast<CXXConversionDecl>(Best->Function)) { 2115 // C++ [over.ics.user]p1: 2116 // 2117 // [...] If the user-defined conversion is specified by a 2118 // conversion function (12.3.2), the initial standard 2119 // conversion sequence converts the source type to the 2120 // implicit object parameter of the conversion function. 2121 User.Before = Best->Conversions[0].Standard; 2122 User.ConversionFunction = Conversion; 2123 User.EllipsisConversion = false; 2124 2125 // C++ [over.ics.user]p2: 2126 // The second standard conversion sequence converts the 2127 // result of the user-defined conversion to the target type 2128 // for the sequence. Since an implicit conversion sequence 2129 // is an initialization, the special rules for 2130 // initialization by user-defined conversion apply when 2131 // selecting the best user-defined conversion for a 2132 // user-defined conversion sequence (see 13.3.3 and 2133 // 13.3.3.1). 2134 User.After = Best->FinalConversion; 2135 return OR_Success; 2136 } else { 2137 llvm_unreachable("Not a constructor or conversion function?"); 2138 return OR_No_Viable_Function; 2139 } 2140 2141 case OR_No_Viable_Function: 2142 return OR_No_Viable_Function; 2143 case OR_Deleted: 2144 // No conversion here! We're done. 2145 return OR_Deleted; 2146 2147 case OR_Ambiguous: 2148 return OR_Ambiguous; 2149 } 2150 2151 return OR_No_Viable_Function; 2152} 2153 2154bool 2155Sema::DiagnoseMultipleUserDefinedConversion(Expr *From, QualType ToType) { 2156 ImplicitConversionSequence ICS; 2157 OverloadCandidateSet CandidateSet(From->getExprLoc()); 2158 OverloadingResult OvResult = 2159 IsUserDefinedConversion(*this, From, ToType, ICS.UserDefined, 2160 CandidateSet, false); 2161 if (OvResult == OR_Ambiguous) 2162 Diag(From->getSourceRange().getBegin(), 2163 diag::err_typecheck_ambiguous_condition) 2164 << From->getType() << ToType << From->getSourceRange(); 2165 else if (OvResult == OR_No_Viable_Function && !CandidateSet.empty()) 2166 Diag(From->getSourceRange().getBegin(), 2167 diag::err_typecheck_nonviable_condition) 2168 << From->getType() << ToType << From->getSourceRange(); 2169 else 2170 return false; 2171 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, &From, 1); 2172 return true; 2173} 2174 2175/// CompareImplicitConversionSequences - Compare two implicit 2176/// conversion sequences to determine whether one is better than the 2177/// other or if they are indistinguishable (C++ 13.3.3.2). 2178static ImplicitConversionSequence::CompareKind 2179CompareImplicitConversionSequences(Sema &S, 2180 const ImplicitConversionSequence& ICS1, 2181 const ImplicitConversionSequence& ICS2) 2182{ 2183 // (C++ 13.3.3.2p2): When comparing the basic forms of implicit 2184 // conversion sequences (as defined in 13.3.3.1) 2185 // -- a standard conversion sequence (13.3.3.1.1) is a better 2186 // conversion sequence than a user-defined conversion sequence or 2187 // an ellipsis conversion sequence, and 2188 // -- a user-defined conversion sequence (13.3.3.1.2) is a better 2189 // conversion sequence than an ellipsis conversion sequence 2190 // (13.3.3.1.3). 2191 // 2192 // C++0x [over.best.ics]p10: 2193 // For the purpose of ranking implicit conversion sequences as 2194 // described in 13.3.3.2, the ambiguous conversion sequence is 2195 // treated as a user-defined sequence that is indistinguishable 2196 // from any other user-defined conversion sequence. 2197 if (ICS1.getKindRank() < ICS2.getKindRank()) 2198 return ImplicitConversionSequence::Better; 2199 else if (ICS2.getKindRank() < ICS1.getKindRank()) 2200 return ImplicitConversionSequence::Worse; 2201 2202 // The following checks require both conversion sequences to be of 2203 // the same kind. 2204 if (ICS1.getKind() != ICS2.getKind()) 2205 return ImplicitConversionSequence::Indistinguishable; 2206 2207 // Two implicit conversion sequences of the same form are 2208 // indistinguishable conversion sequences unless one of the 2209 // following rules apply: (C++ 13.3.3.2p3): 2210 if (ICS1.isStandard()) 2211 return CompareStandardConversionSequences(S, ICS1.Standard, ICS2.Standard); 2212 else if (ICS1.isUserDefined()) { 2213 // User-defined conversion sequence U1 is a better conversion 2214 // sequence than another user-defined conversion sequence U2 if 2215 // they contain the same user-defined conversion function or 2216 // constructor and if the second standard conversion sequence of 2217 // U1 is better than the second standard conversion sequence of 2218 // U2 (C++ 13.3.3.2p3). 2219 if (ICS1.UserDefined.ConversionFunction == 2220 ICS2.UserDefined.ConversionFunction) 2221 return CompareStandardConversionSequences(S, 2222 ICS1.UserDefined.After, 2223 ICS2.UserDefined.After); 2224 } 2225 2226 return ImplicitConversionSequence::Indistinguishable; 2227} 2228 2229static bool hasSimilarType(ASTContext &Context, QualType T1, QualType T2) { 2230 while (Context.UnwrapSimilarPointerTypes(T1, T2)) { 2231 Qualifiers Quals; 2232 T1 = Context.getUnqualifiedArrayType(T1, Quals); 2233 T2 = Context.getUnqualifiedArrayType(T2, Quals); 2234 } 2235 2236 return Context.hasSameUnqualifiedType(T1, T2); 2237} 2238 2239// Per 13.3.3.2p3, compare the given standard conversion sequences to 2240// determine if one is a proper subset of the other. 2241static ImplicitConversionSequence::CompareKind 2242compareStandardConversionSubsets(ASTContext &Context, 2243 const StandardConversionSequence& SCS1, 2244 const StandardConversionSequence& SCS2) { 2245 ImplicitConversionSequence::CompareKind Result 2246 = ImplicitConversionSequence::Indistinguishable; 2247 2248 // the identity conversion sequence is considered to be a subsequence of 2249 // any non-identity conversion sequence 2250 if (SCS1.ReferenceBinding == SCS2.ReferenceBinding) { 2251 if (SCS1.isIdentityConversion() && !SCS2.isIdentityConversion()) 2252 return ImplicitConversionSequence::Better; 2253 else if (!SCS1.isIdentityConversion() && SCS2.isIdentityConversion()) 2254 return ImplicitConversionSequence::Worse; 2255 } 2256 2257 if (SCS1.Second != SCS2.Second) { 2258 if (SCS1.Second == ICK_Identity) 2259 Result = ImplicitConversionSequence::Better; 2260 else if (SCS2.Second == ICK_Identity) 2261 Result = ImplicitConversionSequence::Worse; 2262 else 2263 return ImplicitConversionSequence::Indistinguishable; 2264 } else if (!hasSimilarType(Context, SCS1.getToType(1), SCS2.getToType(1))) 2265 return ImplicitConversionSequence::Indistinguishable; 2266 2267 if (SCS1.Third == SCS2.Third) { 2268 return Context.hasSameType(SCS1.getToType(2), SCS2.getToType(2))? Result 2269 : ImplicitConversionSequence::Indistinguishable; 2270 } 2271 2272 if (SCS1.Third == ICK_Identity) 2273 return Result == ImplicitConversionSequence::Worse 2274 ? ImplicitConversionSequence::Indistinguishable 2275 : ImplicitConversionSequence::Better; 2276 2277 if (SCS2.Third == ICK_Identity) 2278 return Result == ImplicitConversionSequence::Better 2279 ? ImplicitConversionSequence::Indistinguishable 2280 : ImplicitConversionSequence::Worse; 2281 2282 return ImplicitConversionSequence::Indistinguishable; 2283} 2284 2285/// CompareStandardConversionSequences - Compare two standard 2286/// conversion sequences to determine whether one is better than the 2287/// other or if they are indistinguishable (C++ 13.3.3.2p3). 2288static ImplicitConversionSequence::CompareKind 2289CompareStandardConversionSequences(Sema &S, 2290 const StandardConversionSequence& SCS1, 2291 const StandardConversionSequence& SCS2) 2292{ 2293 // Standard conversion sequence S1 is a better conversion sequence 2294 // than standard conversion sequence S2 if (C++ 13.3.3.2p3): 2295 2296 // -- S1 is a proper subsequence of S2 (comparing the conversion 2297 // sequences in the canonical form defined by 13.3.3.1.1, 2298 // excluding any Lvalue Transformation; the identity conversion 2299 // sequence is considered to be a subsequence of any 2300 // non-identity conversion sequence) or, if not that, 2301 if (ImplicitConversionSequence::CompareKind CK 2302 = compareStandardConversionSubsets(S.Context, SCS1, SCS2)) 2303 return CK; 2304 2305 // -- the rank of S1 is better than the rank of S2 (by the rules 2306 // defined below), or, if not that, 2307 ImplicitConversionRank Rank1 = SCS1.getRank(); 2308 ImplicitConversionRank Rank2 = SCS2.getRank(); 2309 if (Rank1 < Rank2) 2310 return ImplicitConversionSequence::Better; 2311 else if (Rank2 < Rank1) 2312 return ImplicitConversionSequence::Worse; 2313 2314 // (C++ 13.3.3.2p4): Two conversion sequences with the same rank 2315 // are indistinguishable unless one of the following rules 2316 // applies: 2317 2318 // A conversion that is not a conversion of a pointer, or 2319 // pointer to member, to bool is better than another conversion 2320 // that is such a conversion. 2321 if (SCS1.isPointerConversionToBool() != SCS2.isPointerConversionToBool()) 2322 return SCS2.isPointerConversionToBool() 2323 ? ImplicitConversionSequence::Better 2324 : ImplicitConversionSequence::Worse; 2325 2326 // C++ [over.ics.rank]p4b2: 2327 // 2328 // If class B is derived directly or indirectly from class A, 2329 // conversion of B* to A* is better than conversion of B* to 2330 // void*, and conversion of A* to void* is better than conversion 2331 // of B* to void*. 2332 bool SCS1ConvertsToVoid 2333 = SCS1.isPointerConversionToVoidPointer(S.Context); 2334 bool SCS2ConvertsToVoid 2335 = SCS2.isPointerConversionToVoidPointer(S.Context); 2336 if (SCS1ConvertsToVoid != SCS2ConvertsToVoid) { 2337 // Exactly one of the conversion sequences is a conversion to 2338 // a void pointer; it's the worse conversion. 2339 return SCS2ConvertsToVoid ? ImplicitConversionSequence::Better 2340 : ImplicitConversionSequence::Worse; 2341 } else if (!SCS1ConvertsToVoid && !SCS2ConvertsToVoid) { 2342 // Neither conversion sequence converts to a void pointer; compare 2343 // their derived-to-base conversions. 2344 if (ImplicitConversionSequence::CompareKind DerivedCK 2345 = CompareDerivedToBaseConversions(S, SCS1, SCS2)) 2346 return DerivedCK; 2347 } else if (SCS1ConvertsToVoid && SCS2ConvertsToVoid) { 2348 // Both conversion sequences are conversions to void 2349 // pointers. Compare the source types to determine if there's an 2350 // inheritance relationship in their sources. 2351 QualType FromType1 = SCS1.getFromType(); 2352 QualType FromType2 = SCS2.getFromType(); 2353 2354 // Adjust the types we're converting from via the array-to-pointer 2355 // conversion, if we need to. 2356 if (SCS1.First == ICK_Array_To_Pointer) 2357 FromType1 = S.Context.getArrayDecayedType(FromType1); 2358 if (SCS2.First == ICK_Array_To_Pointer) 2359 FromType2 = S.Context.getArrayDecayedType(FromType2); 2360 2361 QualType FromPointee1 2362 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 2363 QualType FromPointee2 2364 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 2365 2366 if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 2367 return ImplicitConversionSequence::Better; 2368 else if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 2369 return ImplicitConversionSequence::Worse; 2370 2371 // Objective-C++: If one interface is more specific than the 2372 // other, it is the better one. 2373 const ObjCObjectType* FromIface1 = FromPointee1->getAs<ObjCObjectType>(); 2374 const ObjCObjectType* FromIface2 = FromPointee2->getAs<ObjCObjectType>(); 2375 if (FromIface1 && FromIface1) { 2376 if (S.Context.canAssignObjCInterfaces(FromIface2, FromIface1)) 2377 return ImplicitConversionSequence::Better; 2378 else if (S.Context.canAssignObjCInterfaces(FromIface1, FromIface2)) 2379 return ImplicitConversionSequence::Worse; 2380 } 2381 } 2382 2383 // Compare based on qualification conversions (C++ 13.3.3.2p3, 2384 // bullet 3). 2385 if (ImplicitConversionSequence::CompareKind QualCK 2386 = CompareQualificationConversions(S, SCS1, SCS2)) 2387 return QualCK; 2388 2389 if (SCS1.ReferenceBinding && SCS2.ReferenceBinding) { 2390 // C++0x [over.ics.rank]p3b4: 2391 // -- S1 and S2 are reference bindings (8.5.3) and neither refers to an 2392 // implicit object parameter of a non-static member function declared 2393 // without a ref-qualifier, and S1 binds an rvalue reference to an 2394 // rvalue and S2 binds an lvalue reference. 2395 // FIXME: We don't know if we're dealing with the implicit object parameter, 2396 // or if the member function in this case has a ref qualifier. 2397 // (Of course, we don't have ref qualifiers yet.) 2398 if (SCS1.RRefBinding != SCS2.RRefBinding) 2399 return SCS1.RRefBinding ? ImplicitConversionSequence::Better 2400 : ImplicitConversionSequence::Worse; 2401 2402 // C++ [over.ics.rank]p3b4: 2403 // -- S1 and S2 are reference bindings (8.5.3), and the types to 2404 // which the references refer are the same type except for 2405 // top-level cv-qualifiers, and the type to which the reference 2406 // initialized by S2 refers is more cv-qualified than the type 2407 // to which the reference initialized by S1 refers. 2408 QualType T1 = SCS1.getToType(2); 2409 QualType T2 = SCS2.getToType(2); 2410 T1 = S.Context.getCanonicalType(T1); 2411 T2 = S.Context.getCanonicalType(T2); 2412 Qualifiers T1Quals, T2Quals; 2413 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals); 2414 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals); 2415 if (UnqualT1 == UnqualT2) { 2416 // If the type is an array type, promote the element qualifiers to the type 2417 // for comparison. 2418 if (isa<ArrayType>(T1) && T1Quals) 2419 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals); 2420 if (isa<ArrayType>(T2) && T2Quals) 2421 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals); 2422 if (T2.isMoreQualifiedThan(T1)) 2423 return ImplicitConversionSequence::Better; 2424 else if (T1.isMoreQualifiedThan(T2)) 2425 return ImplicitConversionSequence::Worse; 2426 } 2427 } 2428 2429 return ImplicitConversionSequence::Indistinguishable; 2430} 2431 2432/// CompareQualificationConversions - Compares two standard conversion 2433/// sequences to determine whether they can be ranked based on their 2434/// qualification conversions (C++ 13.3.3.2p3 bullet 3). 2435ImplicitConversionSequence::CompareKind 2436CompareQualificationConversions(Sema &S, 2437 const StandardConversionSequence& SCS1, 2438 const StandardConversionSequence& SCS2) { 2439 // C++ 13.3.3.2p3: 2440 // -- S1 and S2 differ only in their qualification conversion and 2441 // yield similar types T1 and T2 (C++ 4.4), respectively, and the 2442 // cv-qualification signature of type T1 is a proper subset of 2443 // the cv-qualification signature of type T2, and S1 is not the 2444 // deprecated string literal array-to-pointer conversion (4.2). 2445 if (SCS1.First != SCS2.First || SCS1.Second != SCS2.Second || 2446 SCS1.Third != SCS2.Third || SCS1.Third != ICK_Qualification) 2447 return ImplicitConversionSequence::Indistinguishable; 2448 2449 // FIXME: the example in the standard doesn't use a qualification 2450 // conversion (!) 2451 QualType T1 = SCS1.getToType(2); 2452 QualType T2 = SCS2.getToType(2); 2453 T1 = S.Context.getCanonicalType(T1); 2454 T2 = S.Context.getCanonicalType(T2); 2455 Qualifiers T1Quals, T2Quals; 2456 QualType UnqualT1 = S.Context.getUnqualifiedArrayType(T1, T1Quals); 2457 QualType UnqualT2 = S.Context.getUnqualifiedArrayType(T2, T2Quals); 2458 2459 // If the types are the same, we won't learn anything by unwrapped 2460 // them. 2461 if (UnqualT1 == UnqualT2) 2462 return ImplicitConversionSequence::Indistinguishable; 2463 2464 // If the type is an array type, promote the element qualifiers to the type 2465 // for comparison. 2466 if (isa<ArrayType>(T1) && T1Quals) 2467 T1 = S.Context.getQualifiedType(UnqualT1, T1Quals); 2468 if (isa<ArrayType>(T2) && T2Quals) 2469 T2 = S.Context.getQualifiedType(UnqualT2, T2Quals); 2470 2471 ImplicitConversionSequence::CompareKind Result 2472 = ImplicitConversionSequence::Indistinguishable; 2473 while (S.Context.UnwrapSimilarPointerTypes(T1, T2)) { 2474 // Within each iteration of the loop, we check the qualifiers to 2475 // determine if this still looks like a qualification 2476 // conversion. Then, if all is well, we unwrap one more level of 2477 // pointers or pointers-to-members and do it all again 2478 // until there are no more pointers or pointers-to-members left 2479 // to unwrap. This essentially mimics what 2480 // IsQualificationConversion does, but here we're checking for a 2481 // strict subset of qualifiers. 2482 if (T1.getCVRQualifiers() == T2.getCVRQualifiers()) 2483 // The qualifiers are the same, so this doesn't tell us anything 2484 // about how the sequences rank. 2485 ; 2486 else if (T2.isMoreQualifiedThan(T1)) { 2487 // T1 has fewer qualifiers, so it could be the better sequence. 2488 if (Result == ImplicitConversionSequence::Worse) 2489 // Neither has qualifiers that are a subset of the other's 2490 // qualifiers. 2491 return ImplicitConversionSequence::Indistinguishable; 2492 2493 Result = ImplicitConversionSequence::Better; 2494 } else if (T1.isMoreQualifiedThan(T2)) { 2495 // T2 has fewer qualifiers, so it could be the better sequence. 2496 if (Result == ImplicitConversionSequence::Better) 2497 // Neither has qualifiers that are a subset of the other's 2498 // qualifiers. 2499 return ImplicitConversionSequence::Indistinguishable; 2500 2501 Result = ImplicitConversionSequence::Worse; 2502 } else { 2503 // Qualifiers are disjoint. 2504 return ImplicitConversionSequence::Indistinguishable; 2505 } 2506 2507 // If the types after this point are equivalent, we're done. 2508 if (S.Context.hasSameUnqualifiedType(T1, T2)) 2509 break; 2510 } 2511 2512 // Check that the winning standard conversion sequence isn't using 2513 // the deprecated string literal array to pointer conversion. 2514 switch (Result) { 2515 case ImplicitConversionSequence::Better: 2516 if (SCS1.DeprecatedStringLiteralToCharPtr) 2517 Result = ImplicitConversionSequence::Indistinguishable; 2518 break; 2519 2520 case ImplicitConversionSequence::Indistinguishable: 2521 break; 2522 2523 case ImplicitConversionSequence::Worse: 2524 if (SCS2.DeprecatedStringLiteralToCharPtr) 2525 Result = ImplicitConversionSequence::Indistinguishable; 2526 break; 2527 } 2528 2529 return Result; 2530} 2531 2532/// CompareDerivedToBaseConversions - Compares two standard conversion 2533/// sequences to determine whether they can be ranked based on their 2534/// various kinds of derived-to-base conversions (C++ 2535/// [over.ics.rank]p4b3). As part of these checks, we also look at 2536/// conversions between Objective-C interface types. 2537ImplicitConversionSequence::CompareKind 2538CompareDerivedToBaseConversions(Sema &S, 2539 const StandardConversionSequence& SCS1, 2540 const StandardConversionSequence& SCS2) { 2541 QualType FromType1 = SCS1.getFromType(); 2542 QualType ToType1 = SCS1.getToType(1); 2543 QualType FromType2 = SCS2.getFromType(); 2544 QualType ToType2 = SCS2.getToType(1); 2545 2546 // Adjust the types we're converting from via the array-to-pointer 2547 // conversion, if we need to. 2548 if (SCS1.First == ICK_Array_To_Pointer) 2549 FromType1 = S.Context.getArrayDecayedType(FromType1); 2550 if (SCS2.First == ICK_Array_To_Pointer) 2551 FromType2 = S.Context.getArrayDecayedType(FromType2); 2552 2553 // Canonicalize all of the types. 2554 FromType1 = S.Context.getCanonicalType(FromType1); 2555 ToType1 = S.Context.getCanonicalType(ToType1); 2556 FromType2 = S.Context.getCanonicalType(FromType2); 2557 ToType2 = S.Context.getCanonicalType(ToType2); 2558 2559 // C++ [over.ics.rank]p4b3: 2560 // 2561 // If class B is derived directly or indirectly from class A and 2562 // class C is derived directly or indirectly from B, 2563 // 2564 // For Objective-C, we let A, B, and C also be Objective-C 2565 // interfaces. 2566 2567 // Compare based on pointer conversions. 2568 if (SCS1.Second == ICK_Pointer_Conversion && 2569 SCS2.Second == ICK_Pointer_Conversion && 2570 /*FIXME: Remove if Objective-C id conversions get their own rank*/ 2571 FromType1->isPointerType() && FromType2->isPointerType() && 2572 ToType1->isPointerType() && ToType2->isPointerType()) { 2573 QualType FromPointee1 2574 = FromType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 2575 QualType ToPointee1 2576 = ToType1->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 2577 QualType FromPointee2 2578 = FromType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 2579 QualType ToPointee2 2580 = ToType2->getAs<PointerType>()->getPointeeType().getUnqualifiedType(); 2581 2582 const ObjCObjectType* FromIface1 = FromPointee1->getAs<ObjCObjectType>(); 2583 const ObjCObjectType* FromIface2 = FromPointee2->getAs<ObjCObjectType>(); 2584 const ObjCObjectType* ToIface1 = ToPointee1->getAs<ObjCObjectType>(); 2585 const ObjCObjectType* ToIface2 = ToPointee2->getAs<ObjCObjectType>(); 2586 2587 // -- conversion of C* to B* is better than conversion of C* to A*, 2588 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) { 2589 if (S.IsDerivedFrom(ToPointee1, ToPointee2)) 2590 return ImplicitConversionSequence::Better; 2591 else if (S.IsDerivedFrom(ToPointee2, ToPointee1)) 2592 return ImplicitConversionSequence::Worse; 2593 2594 if (ToIface1 && ToIface2) { 2595 if (S.Context.canAssignObjCInterfaces(ToIface2, ToIface1)) 2596 return ImplicitConversionSequence::Better; 2597 else if (S.Context.canAssignObjCInterfaces(ToIface1, ToIface2)) 2598 return ImplicitConversionSequence::Worse; 2599 } 2600 } 2601 2602 // -- conversion of B* to A* is better than conversion of C* to A*, 2603 if (FromPointee1 != FromPointee2 && ToPointee1 == ToPointee2) { 2604 if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 2605 return ImplicitConversionSequence::Better; 2606 else if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 2607 return ImplicitConversionSequence::Worse; 2608 2609 if (FromIface1 && FromIface2) { 2610 if (S.Context.canAssignObjCInterfaces(FromIface1, FromIface2)) 2611 return ImplicitConversionSequence::Better; 2612 else if (S.Context.canAssignObjCInterfaces(FromIface2, FromIface1)) 2613 return ImplicitConversionSequence::Worse; 2614 } 2615 } 2616 } 2617 2618 // Ranking of member-pointer types. 2619 if (SCS1.Second == ICK_Pointer_Member && SCS2.Second == ICK_Pointer_Member && 2620 FromType1->isMemberPointerType() && FromType2->isMemberPointerType() && 2621 ToType1->isMemberPointerType() && ToType2->isMemberPointerType()) { 2622 const MemberPointerType * FromMemPointer1 = 2623 FromType1->getAs<MemberPointerType>(); 2624 const MemberPointerType * ToMemPointer1 = 2625 ToType1->getAs<MemberPointerType>(); 2626 const MemberPointerType * FromMemPointer2 = 2627 FromType2->getAs<MemberPointerType>(); 2628 const MemberPointerType * ToMemPointer2 = 2629 ToType2->getAs<MemberPointerType>(); 2630 const Type *FromPointeeType1 = FromMemPointer1->getClass(); 2631 const Type *ToPointeeType1 = ToMemPointer1->getClass(); 2632 const Type *FromPointeeType2 = FromMemPointer2->getClass(); 2633 const Type *ToPointeeType2 = ToMemPointer2->getClass(); 2634 QualType FromPointee1 = QualType(FromPointeeType1, 0).getUnqualifiedType(); 2635 QualType ToPointee1 = QualType(ToPointeeType1, 0).getUnqualifiedType(); 2636 QualType FromPointee2 = QualType(FromPointeeType2, 0).getUnqualifiedType(); 2637 QualType ToPointee2 = QualType(ToPointeeType2, 0).getUnqualifiedType(); 2638 // conversion of A::* to B::* is better than conversion of A::* to C::*, 2639 if (FromPointee1 == FromPointee2 && ToPointee1 != ToPointee2) { 2640 if (S.IsDerivedFrom(ToPointee1, ToPointee2)) 2641 return ImplicitConversionSequence::Worse; 2642 else if (S.IsDerivedFrom(ToPointee2, ToPointee1)) 2643 return ImplicitConversionSequence::Better; 2644 } 2645 // conversion of B::* to C::* is better than conversion of A::* to C::* 2646 if (ToPointee1 == ToPointee2 && FromPointee1 != FromPointee2) { 2647 if (S.IsDerivedFrom(FromPointee1, FromPointee2)) 2648 return ImplicitConversionSequence::Better; 2649 else if (S.IsDerivedFrom(FromPointee2, FromPointee1)) 2650 return ImplicitConversionSequence::Worse; 2651 } 2652 } 2653 2654 if (SCS1.Second == ICK_Derived_To_Base) { 2655 // -- conversion of C to B is better than conversion of C to A, 2656 // -- binding of an expression of type C to a reference of type 2657 // B& is better than binding an expression of type C to a 2658 // reference of type A&, 2659 if (S.Context.hasSameUnqualifiedType(FromType1, FromType2) && 2660 !S.Context.hasSameUnqualifiedType(ToType1, ToType2)) { 2661 if (S.IsDerivedFrom(ToType1, ToType2)) 2662 return ImplicitConversionSequence::Better; 2663 else if (S.IsDerivedFrom(ToType2, ToType1)) 2664 return ImplicitConversionSequence::Worse; 2665 } 2666 2667 // -- conversion of B to A is better than conversion of C to A. 2668 // -- binding of an expression of type B to a reference of type 2669 // A& is better than binding an expression of type C to a 2670 // reference of type A&, 2671 if (!S.Context.hasSameUnqualifiedType(FromType1, FromType2) && 2672 S.Context.hasSameUnqualifiedType(ToType1, ToType2)) { 2673 if (S.IsDerivedFrom(FromType2, FromType1)) 2674 return ImplicitConversionSequence::Better; 2675 else if (S.IsDerivedFrom(FromType1, FromType2)) 2676 return ImplicitConversionSequence::Worse; 2677 } 2678 } 2679 2680 return ImplicitConversionSequence::Indistinguishable; 2681} 2682 2683/// CompareReferenceRelationship - Compare the two types T1 and T2 to 2684/// determine whether they are reference-related, 2685/// reference-compatible, reference-compatible with added 2686/// qualification, or incompatible, for use in C++ initialization by 2687/// reference (C++ [dcl.ref.init]p4). Neither type can be a reference 2688/// type, and the first type (T1) is the pointee type of the reference 2689/// type being initialized. 2690Sema::ReferenceCompareResult 2691Sema::CompareReferenceRelationship(SourceLocation Loc, 2692 QualType OrigT1, QualType OrigT2, 2693 bool &DerivedToBase, 2694 bool &ObjCConversion) { 2695 assert(!OrigT1->isReferenceType() && 2696 "T1 must be the pointee type of the reference type"); 2697 assert(!OrigT2->isReferenceType() && "T2 cannot be a reference type"); 2698 2699 QualType T1 = Context.getCanonicalType(OrigT1); 2700 QualType T2 = Context.getCanonicalType(OrigT2); 2701 Qualifiers T1Quals, T2Quals; 2702 QualType UnqualT1 = Context.getUnqualifiedArrayType(T1, T1Quals); 2703 QualType UnqualT2 = Context.getUnqualifiedArrayType(T2, T2Quals); 2704 2705 // C++ [dcl.init.ref]p4: 2706 // Given types "cv1 T1" and "cv2 T2," "cv1 T1" is 2707 // reference-related to "cv2 T2" if T1 is the same type as T2, or 2708 // T1 is a base class of T2. 2709 DerivedToBase = false; 2710 ObjCConversion = false; 2711 if (UnqualT1 == UnqualT2) { 2712 // Nothing to do. 2713 } else if (!RequireCompleteType(Loc, OrigT2, PDiag()) && 2714 IsDerivedFrom(UnqualT2, UnqualT1)) 2715 DerivedToBase = true; 2716 else if (UnqualT1->isObjCObjectOrInterfaceType() && 2717 UnqualT2->isObjCObjectOrInterfaceType() && 2718 Context.canBindObjCObjectType(UnqualT1, UnqualT2)) 2719 ObjCConversion = true; 2720 else 2721 return Ref_Incompatible; 2722 2723 // At this point, we know that T1 and T2 are reference-related (at 2724 // least). 2725 2726 // If the type is an array type, promote the element qualifiers to the type 2727 // for comparison. 2728 if (isa<ArrayType>(T1) && T1Quals) 2729 T1 = Context.getQualifiedType(UnqualT1, T1Quals); 2730 if (isa<ArrayType>(T2) && T2Quals) 2731 T2 = Context.getQualifiedType(UnqualT2, T2Quals); 2732 2733 // C++ [dcl.init.ref]p4: 2734 // "cv1 T1" is reference-compatible with "cv2 T2" if T1 is 2735 // reference-related to T2 and cv1 is the same cv-qualification 2736 // as, or greater cv-qualification than, cv2. For purposes of 2737 // overload resolution, cases for which cv1 is greater 2738 // cv-qualification than cv2 are identified as 2739 // reference-compatible with added qualification (see 13.3.3.2). 2740 if (T1Quals.getCVRQualifiers() == T2Quals.getCVRQualifiers()) 2741 return Ref_Compatible; 2742 else if (T1.isMoreQualifiedThan(T2)) 2743 return Ref_Compatible_With_Added_Qualification; 2744 else 2745 return Ref_Related; 2746} 2747 2748/// \brief Look for a user-defined conversion to an value reference-compatible 2749/// with DeclType. Return true if something definite is found. 2750static bool 2751FindConversionForRefInit(Sema &S, ImplicitConversionSequence &ICS, 2752 QualType DeclType, SourceLocation DeclLoc, 2753 Expr *Init, QualType T2, bool AllowRvalues, 2754 bool AllowExplicit) { 2755 assert(T2->isRecordType() && "Can only find conversions of record types."); 2756 CXXRecordDecl *T2RecordDecl 2757 = dyn_cast<CXXRecordDecl>(T2->getAs<RecordType>()->getDecl()); 2758 2759 QualType ToType 2760 = AllowRvalues? DeclType->getAs<ReferenceType>()->getPointeeType() 2761 : DeclType; 2762 2763 OverloadCandidateSet CandidateSet(DeclLoc); 2764 const UnresolvedSetImpl *Conversions 2765 = T2RecordDecl->getVisibleConversionFunctions(); 2766 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 2767 E = Conversions->end(); I != E; ++I) { 2768 NamedDecl *D = *I; 2769 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(D->getDeclContext()); 2770 if (isa<UsingShadowDecl>(D)) 2771 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 2772 2773 FunctionTemplateDecl *ConvTemplate 2774 = dyn_cast<FunctionTemplateDecl>(D); 2775 CXXConversionDecl *Conv; 2776 if (ConvTemplate) 2777 Conv = cast<CXXConversionDecl>(ConvTemplate->getTemplatedDecl()); 2778 else 2779 Conv = cast<CXXConversionDecl>(D); 2780 2781 // If this is an explicit conversion, and we're not allowed to consider 2782 // explicit conversions, skip it. 2783 if (!AllowExplicit && Conv->isExplicit()) 2784 continue; 2785 2786 if (AllowRvalues) { 2787 bool DerivedToBase = false; 2788 bool ObjCConversion = false; 2789 if (!ConvTemplate && 2790 S.CompareReferenceRelationship(DeclLoc, 2791 Conv->getConversionType().getNonReferenceType().getUnqualifiedType(), 2792 DeclType.getNonReferenceType().getUnqualifiedType(), 2793 DerivedToBase, ObjCConversion) 2794 == Sema::Ref_Incompatible) 2795 continue; 2796 } else { 2797 // If the conversion function doesn't return a reference type, 2798 // it can't be considered for this conversion. An rvalue reference 2799 // is only acceptable if its referencee is a function type. 2800 2801 const ReferenceType *RefType = 2802 Conv->getConversionType()->getAs<ReferenceType>(); 2803 if (!RefType || 2804 (!RefType->isLValueReferenceType() && 2805 !RefType->getPointeeType()->isFunctionType())) 2806 continue; 2807 } 2808 2809 if (ConvTemplate) 2810 S.AddTemplateConversionCandidate(ConvTemplate, I.getPair(), ActingDC, 2811 Init, ToType, CandidateSet); 2812 else 2813 S.AddConversionCandidate(Conv, I.getPair(), ActingDC, Init, 2814 ToType, CandidateSet); 2815 } 2816 2817 OverloadCandidateSet::iterator Best; 2818 switch (CandidateSet.BestViableFunction(S, DeclLoc, Best, true)) { 2819 case OR_Success: 2820 // C++ [over.ics.ref]p1: 2821 // 2822 // [...] If the parameter binds directly to the result of 2823 // applying a conversion function to the argument 2824 // expression, the implicit conversion sequence is a 2825 // user-defined conversion sequence (13.3.3.1.2), with the 2826 // second standard conversion sequence either an identity 2827 // conversion or, if the conversion function returns an 2828 // entity of a type that is a derived class of the parameter 2829 // type, a derived-to-base Conversion. 2830 if (!Best->FinalConversion.DirectBinding) 2831 return false; 2832 2833 ICS.setUserDefined(); 2834 ICS.UserDefined.Before = Best->Conversions[0].Standard; 2835 ICS.UserDefined.After = Best->FinalConversion; 2836 ICS.UserDefined.ConversionFunction = Best->Function; 2837 ICS.UserDefined.EllipsisConversion = false; 2838 assert(ICS.UserDefined.After.ReferenceBinding && 2839 ICS.UserDefined.After.DirectBinding && 2840 "Expected a direct reference binding!"); 2841 return true; 2842 2843 case OR_Ambiguous: 2844 ICS.setAmbiguous(); 2845 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(); 2846 Cand != CandidateSet.end(); ++Cand) 2847 if (Cand->Viable) 2848 ICS.Ambiguous.addConversion(Cand->Function); 2849 return true; 2850 2851 case OR_No_Viable_Function: 2852 case OR_Deleted: 2853 // There was no suitable conversion, or we found a deleted 2854 // conversion; continue with other checks. 2855 return false; 2856 } 2857 2858 return false; 2859} 2860 2861/// \brief Compute an implicit conversion sequence for reference 2862/// initialization. 2863static ImplicitConversionSequence 2864TryReferenceInit(Sema &S, Expr *&Init, QualType DeclType, 2865 SourceLocation DeclLoc, 2866 bool SuppressUserConversions, 2867 bool AllowExplicit) { 2868 assert(DeclType->isReferenceType() && "Reference init needs a reference"); 2869 2870 // Most paths end in a failed conversion. 2871 ImplicitConversionSequence ICS; 2872 ICS.setBad(BadConversionSequence::no_conversion, Init, DeclType); 2873 2874 QualType T1 = DeclType->getAs<ReferenceType>()->getPointeeType(); 2875 QualType T2 = Init->getType(); 2876 2877 // If the initializer is the address of an overloaded function, try 2878 // to resolve the overloaded function. If all goes well, T2 is the 2879 // type of the resulting function. 2880 if (S.Context.getCanonicalType(T2) == S.Context.OverloadTy) { 2881 DeclAccessPair Found; 2882 if (FunctionDecl *Fn = S.ResolveAddressOfOverloadedFunction(Init, DeclType, 2883 false, Found)) 2884 T2 = Fn->getType(); 2885 } 2886 2887 // Compute some basic properties of the types and the initializer. 2888 bool isRValRef = DeclType->isRValueReferenceType(); 2889 bool DerivedToBase = false; 2890 bool ObjCConversion = false; 2891 Expr::Classification InitCategory = Init->Classify(S.Context); 2892 Sema::ReferenceCompareResult RefRelationship 2893 = S.CompareReferenceRelationship(DeclLoc, T1, T2, DerivedToBase, 2894 ObjCConversion); 2895 2896 2897 // C++0x [dcl.init.ref]p5: 2898 // A reference to type "cv1 T1" is initialized by an expression 2899 // of type "cv2 T2" as follows: 2900 2901 // -- If reference is an lvalue reference and the initializer expression 2902 // The next bullet point (T1 is a function) is pretty much equivalent to this 2903 // one, so it's handled here. 2904 if (!isRValRef || T1->isFunctionType()) { 2905 // -- is an lvalue (but is not a bit-field), and "cv1 T1" is 2906 // reference-compatible with "cv2 T2," or 2907 // 2908 // Per C++ [over.ics.ref]p4, we don't check the bit-field property here. 2909 if (InitCategory.isLValue() && 2910 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) { 2911 // C++ [over.ics.ref]p1: 2912 // When a parameter of reference type binds directly (8.5.3) 2913 // to an argument expression, the implicit conversion sequence 2914 // is the identity conversion, unless the argument expression 2915 // has a type that is a derived class of the parameter type, 2916 // in which case the implicit conversion sequence is a 2917 // derived-to-base Conversion (13.3.3.1). 2918 ICS.setStandard(); 2919 ICS.Standard.First = ICK_Identity; 2920 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base 2921 : ObjCConversion? ICK_Compatible_Conversion 2922 : ICK_Identity; 2923 ICS.Standard.Third = ICK_Identity; 2924 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr(); 2925 ICS.Standard.setToType(0, T2); 2926 ICS.Standard.setToType(1, T1); 2927 ICS.Standard.setToType(2, T1); 2928 ICS.Standard.ReferenceBinding = true; 2929 ICS.Standard.DirectBinding = true; 2930 ICS.Standard.RRefBinding = isRValRef; 2931 ICS.Standard.CopyConstructor = 0; 2932 2933 // Nothing more to do: the inaccessibility/ambiguity check for 2934 // derived-to-base conversions is suppressed when we're 2935 // computing the implicit conversion sequence (C++ 2936 // [over.best.ics]p2). 2937 return ICS; 2938 } 2939 2940 // -- has a class type (i.e., T2 is a class type), where T1 is 2941 // not reference-related to T2, and can be implicitly 2942 // converted to an lvalue of type "cv3 T3," where "cv1 T1" 2943 // is reference-compatible with "cv3 T3" 92) (this 2944 // conversion is selected by enumerating the applicable 2945 // conversion functions (13.3.1.6) and choosing the best 2946 // one through overload resolution (13.3)), 2947 if (!SuppressUserConversions && T2->isRecordType() && 2948 !S.RequireCompleteType(DeclLoc, T2, 0) && 2949 RefRelationship == Sema::Ref_Incompatible) { 2950 if (FindConversionForRefInit(S, ICS, DeclType, DeclLoc, 2951 Init, T2, /*AllowRvalues=*/false, 2952 AllowExplicit)) 2953 return ICS; 2954 } 2955 } 2956 2957 // -- Otherwise, the reference shall be an lvalue reference to a 2958 // non-volatile const type (i.e., cv1 shall be const), or the reference 2959 // shall be an rvalue reference and the initializer expression shall be 2960 // an rvalue or have a function type. 2961 // 2962 // We actually handle one oddity of C++ [over.ics.ref] at this 2963 // point, which is that, due to p2 (which short-circuits reference 2964 // binding by only attempting a simple conversion for non-direct 2965 // bindings) and p3's strange wording, we allow a const volatile 2966 // reference to bind to an rvalue. Hence the check for the presence 2967 // of "const" rather than checking for "const" being the only 2968 // qualifier. 2969 // This is also the point where rvalue references and lvalue inits no longer 2970 // go together. 2971 if ((!isRValRef && !T1.isConstQualified()) || 2972 (isRValRef && InitCategory.isLValue())) 2973 return ICS; 2974 2975 // -- If T1 is a function type, then 2976 // -- if T2 is the same type as T1, the reference is bound to the 2977 // initializer expression lvalue; 2978 // -- if T2 is a class type and the initializer expression can be 2979 // implicitly converted to an lvalue of type T1 [...], the 2980 // reference is bound to the function lvalue that is the result 2981 // of the conversion; 2982 // This is the same as for the lvalue case above, so it was handled there. 2983 // -- otherwise, the program is ill-formed. 2984 // This is the one difference to the lvalue case. 2985 if (T1->isFunctionType()) 2986 return ICS; 2987 2988 // -- Otherwise, if T2 is a class type and 2989 // -- the initializer expression is an rvalue and "cv1 T1" 2990 // is reference-compatible with "cv2 T2," or 2991 // 2992 // -- T1 is not reference-related to T2 and the initializer 2993 // expression can be implicitly converted to an rvalue 2994 // of type "cv3 T3" (this conversion is selected by 2995 // enumerating the applicable conversion functions 2996 // (13.3.1.6) and choosing the best one through overload 2997 // resolution (13.3)), 2998 // 2999 // then the reference is bound to the initializer 3000 // expression rvalue in the first case and to the object 3001 // that is the result of the conversion in the second case 3002 // (or, in either case, to the appropriate base class 3003 // subobject of the object). 3004 if (T2->isRecordType()) { 3005 // First case: "cv1 T1" is reference-compatible with "cv2 T2". This is a 3006 // direct binding in C++0x but not in C++03. 3007 if (InitCategory.isRValue() && 3008 RefRelationship >= Sema::Ref_Compatible_With_Added_Qualification) { 3009 ICS.setStandard(); 3010 ICS.Standard.First = ICK_Identity; 3011 ICS.Standard.Second = DerivedToBase? ICK_Derived_To_Base 3012 : ObjCConversion? ICK_Compatible_Conversion 3013 : ICK_Identity; 3014 ICS.Standard.Third = ICK_Identity; 3015 ICS.Standard.FromTypePtr = T2.getAsOpaquePtr(); 3016 ICS.Standard.setToType(0, T2); 3017 ICS.Standard.setToType(1, T1); 3018 ICS.Standard.setToType(2, T1); 3019 ICS.Standard.ReferenceBinding = true; 3020 ICS.Standard.DirectBinding = S.getLangOptions().CPlusPlus0x; 3021 ICS.Standard.RRefBinding = isRValRef; 3022 ICS.Standard.CopyConstructor = 0; 3023 return ICS; 3024 } 3025 3026 // Second case: not reference-related. 3027 if (RefRelationship == Sema::Ref_Incompatible && 3028 !S.RequireCompleteType(DeclLoc, T2, 0) && 3029 FindConversionForRefInit(S, ICS, DeclType, DeclLoc, 3030 Init, T2, /*AllowRvalues=*/true, 3031 AllowExplicit)) 3032 return ICS; 3033 } 3034 3035 // -- Otherwise, a temporary of type "cv1 T1" is created and 3036 // initialized from the initializer expression using the 3037 // rules for a non-reference copy initialization (8.5). The 3038 // reference is then bound to the temporary. If T1 is 3039 // reference-related to T2, cv1 must be the same 3040 // cv-qualification as, or greater cv-qualification than, 3041 // cv2; otherwise, the program is ill-formed. 3042 if (RefRelationship == Sema::Ref_Related) { 3043 // If cv1 == cv2 or cv1 is a greater cv-qualified than cv2, then 3044 // we would be reference-compatible or reference-compatible with 3045 // added qualification. But that wasn't the case, so the reference 3046 // initialization fails. 3047 return ICS; 3048 } 3049 3050 // If at least one of the types is a class type, the types are not 3051 // related, and we aren't allowed any user conversions, the 3052 // reference binding fails. This case is important for breaking 3053 // recursion, since TryImplicitConversion below will attempt to 3054 // create a temporary through the use of a copy constructor. 3055 if (SuppressUserConversions && RefRelationship == Sema::Ref_Incompatible && 3056 (T1->isRecordType() || T2->isRecordType())) 3057 return ICS; 3058 3059 // C++ [over.ics.ref]p2: 3060 // When a parameter of reference type is not bound directly to 3061 // an argument expression, the conversion sequence is the one 3062 // required to convert the argument expression to the 3063 // underlying type of the reference according to 3064 // 13.3.3.1. Conceptually, this conversion sequence corresponds 3065 // to copy-initializing a temporary of the underlying type with 3066 // the argument expression. Any difference in top-level 3067 // cv-qualification is subsumed by the initialization itself 3068 // and does not constitute a conversion. 3069 ICS = TryImplicitConversion(S, Init, T1, SuppressUserConversions, 3070 /*AllowExplicit=*/false, 3071 /*InOverloadResolution=*/false); 3072 3073 // Of course, that's still a reference binding. 3074 if (ICS.isStandard()) { 3075 ICS.Standard.ReferenceBinding = true; 3076 ICS.Standard.RRefBinding = isRValRef; 3077 } else if (ICS.isUserDefined()) { 3078 ICS.UserDefined.After.ReferenceBinding = true; 3079 ICS.UserDefined.After.RRefBinding = isRValRef; 3080 } 3081 return ICS; 3082} 3083 3084/// TryCopyInitialization - Try to copy-initialize a value of type 3085/// ToType from the expression From. Return the implicit conversion 3086/// sequence required to pass this argument, which may be a bad 3087/// conversion sequence (meaning that the argument cannot be passed to 3088/// a parameter of this type). If @p SuppressUserConversions, then we 3089/// do not permit any user-defined conversion sequences. 3090static ImplicitConversionSequence 3091TryCopyInitialization(Sema &S, Expr *From, QualType ToType, 3092 bool SuppressUserConversions, 3093 bool InOverloadResolution) { 3094 if (ToType->isReferenceType()) 3095 return TryReferenceInit(S, From, ToType, 3096 /*FIXME:*/From->getLocStart(), 3097 SuppressUserConversions, 3098 /*AllowExplicit=*/false); 3099 3100 return TryImplicitConversion(S, From, ToType, 3101 SuppressUserConversions, 3102 /*AllowExplicit=*/false, 3103 InOverloadResolution); 3104} 3105 3106/// TryObjectArgumentInitialization - Try to initialize the object 3107/// parameter of the given member function (@c Method) from the 3108/// expression @p From. 3109static ImplicitConversionSequence 3110TryObjectArgumentInitialization(Sema &S, QualType OrigFromType, 3111 CXXMethodDecl *Method, 3112 CXXRecordDecl *ActingContext) { 3113 QualType ClassType = S.Context.getTypeDeclType(ActingContext); 3114 // [class.dtor]p2: A destructor can be invoked for a const, volatile or 3115 // const volatile object. 3116 unsigned Quals = isa<CXXDestructorDecl>(Method) ? 3117 Qualifiers::Const | Qualifiers::Volatile : Method->getTypeQualifiers(); 3118 QualType ImplicitParamType = S.Context.getCVRQualifiedType(ClassType, Quals); 3119 3120 // Set up the conversion sequence as a "bad" conversion, to allow us 3121 // to exit early. 3122 ImplicitConversionSequence ICS; 3123 3124 // We need to have an object of class type. 3125 QualType FromType = OrigFromType; 3126 if (const PointerType *PT = FromType->getAs<PointerType>()) 3127 FromType = PT->getPointeeType(); 3128 3129 assert(FromType->isRecordType()); 3130 3131 // The implicit object parameter is has the type "reference to cv X", 3132 // where X is the class of which the function is a member 3133 // (C++ [over.match.funcs]p4). However, when finding an implicit 3134 // conversion sequence for the argument, we are not allowed to 3135 // create temporaries or perform user-defined conversions 3136 // (C++ [over.match.funcs]p5). We perform a simplified version of 3137 // reference binding here, that allows class rvalues to bind to 3138 // non-constant references. 3139 3140 // First check the qualifiers. We don't care about lvalue-vs-rvalue 3141 // with the implicit object parameter (C++ [over.match.funcs]p5). 3142 QualType FromTypeCanon = S.Context.getCanonicalType(FromType); 3143 if (ImplicitParamType.getCVRQualifiers() 3144 != FromTypeCanon.getLocalCVRQualifiers() && 3145 !ImplicitParamType.isAtLeastAsQualifiedAs(FromTypeCanon)) { 3146 ICS.setBad(BadConversionSequence::bad_qualifiers, 3147 OrigFromType, ImplicitParamType); 3148 return ICS; 3149 } 3150 3151 // Check that we have either the same type or a derived type. It 3152 // affects the conversion rank. 3153 QualType ClassTypeCanon = S.Context.getCanonicalType(ClassType); 3154 ImplicitConversionKind SecondKind; 3155 if (ClassTypeCanon == FromTypeCanon.getLocalUnqualifiedType()) { 3156 SecondKind = ICK_Identity; 3157 } else if (S.IsDerivedFrom(FromType, ClassType)) 3158 SecondKind = ICK_Derived_To_Base; 3159 else { 3160 ICS.setBad(BadConversionSequence::unrelated_class, 3161 FromType, ImplicitParamType); 3162 return ICS; 3163 } 3164 3165 // Success. Mark this as a reference binding. 3166 ICS.setStandard(); 3167 ICS.Standard.setAsIdentityConversion(); 3168 ICS.Standard.Second = SecondKind; 3169 ICS.Standard.setFromType(FromType); 3170 ICS.Standard.setAllToTypes(ImplicitParamType); 3171 ICS.Standard.ReferenceBinding = true; 3172 ICS.Standard.DirectBinding = true; 3173 ICS.Standard.RRefBinding = false; 3174 return ICS; 3175} 3176 3177/// PerformObjectArgumentInitialization - Perform initialization of 3178/// the implicit object parameter for the given Method with the given 3179/// expression. 3180bool 3181Sema::PerformObjectArgumentInitialization(Expr *&From, 3182 NestedNameSpecifier *Qualifier, 3183 NamedDecl *FoundDecl, 3184 CXXMethodDecl *Method) { 3185 QualType FromRecordType, DestType; 3186 QualType ImplicitParamRecordType = 3187 Method->getThisType(Context)->getAs<PointerType>()->getPointeeType(); 3188 3189 if (const PointerType *PT = From->getType()->getAs<PointerType>()) { 3190 FromRecordType = PT->getPointeeType(); 3191 DestType = Method->getThisType(Context); 3192 } else { 3193 FromRecordType = From->getType(); 3194 DestType = ImplicitParamRecordType; 3195 } 3196 3197 // Note that we always use the true parent context when performing 3198 // the actual argument initialization. 3199 ImplicitConversionSequence ICS 3200 = TryObjectArgumentInitialization(*this, From->getType(), Method, 3201 Method->getParent()); 3202 if (ICS.isBad()) { 3203 if (ICS.Bad.Kind == BadConversionSequence::bad_qualifiers) { 3204 Qualifiers FromQs = FromRecordType.getQualifiers(); 3205 Qualifiers ToQs = DestType.getQualifiers(); 3206 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers(); 3207 if (CVR) { 3208 Diag(From->getSourceRange().getBegin(), 3209 diag::err_member_function_call_bad_cvr) 3210 << Method->getDeclName() << FromRecordType << (CVR - 1) 3211 << From->getSourceRange(); 3212 Diag(Method->getLocation(), diag::note_previous_decl) 3213 << Method->getDeclName(); 3214 return true; 3215 } 3216 } 3217 3218 return Diag(From->getSourceRange().getBegin(), 3219 diag::err_implicit_object_parameter_init) 3220 << ImplicitParamRecordType << FromRecordType << From->getSourceRange(); 3221 } 3222 3223 if (ICS.Standard.Second == ICK_Derived_To_Base) 3224 return PerformObjectMemberConversion(From, Qualifier, FoundDecl, Method); 3225 3226 if (!Context.hasSameType(From->getType(), DestType)) 3227 ImpCastExprToType(From, DestType, CK_NoOp, 3228 From->getType()->isPointerType() ? VK_RValue : VK_LValue); 3229 return false; 3230} 3231 3232/// TryContextuallyConvertToBool - Attempt to contextually convert the 3233/// expression From to bool (C++0x [conv]p3). 3234static ImplicitConversionSequence 3235TryContextuallyConvertToBool(Sema &S, Expr *From) { 3236 // FIXME: This is pretty broken. 3237 return TryImplicitConversion(S, From, S.Context.BoolTy, 3238 // FIXME: Are these flags correct? 3239 /*SuppressUserConversions=*/false, 3240 /*AllowExplicit=*/true, 3241 /*InOverloadResolution=*/false); 3242} 3243 3244/// PerformContextuallyConvertToBool - Perform a contextual conversion 3245/// of the expression From to bool (C++0x [conv]p3). 3246bool Sema::PerformContextuallyConvertToBool(Expr *&From) { 3247 ImplicitConversionSequence ICS = TryContextuallyConvertToBool(*this, From); 3248 if (!ICS.isBad()) 3249 return PerformImplicitConversion(From, Context.BoolTy, ICS, AA_Converting); 3250 3251 if (!DiagnoseMultipleUserDefinedConversion(From, Context.BoolTy)) 3252 return Diag(From->getSourceRange().getBegin(), 3253 diag::err_typecheck_bool_condition) 3254 << From->getType() << From->getSourceRange(); 3255 return true; 3256} 3257 3258/// TryContextuallyConvertToObjCId - Attempt to contextually convert the 3259/// expression From to 'id'. 3260static ImplicitConversionSequence 3261TryContextuallyConvertToObjCId(Sema &S, Expr *From) { 3262 QualType Ty = S.Context.getObjCIdType(); 3263 return TryImplicitConversion(S, From, Ty, 3264 // FIXME: Are these flags correct? 3265 /*SuppressUserConversions=*/false, 3266 /*AllowExplicit=*/true, 3267 /*InOverloadResolution=*/false); 3268} 3269 3270/// PerformContextuallyConvertToObjCId - Perform a contextual conversion 3271/// of the expression From to 'id'. 3272bool Sema::PerformContextuallyConvertToObjCId(Expr *&From) { 3273 QualType Ty = Context.getObjCIdType(); 3274 ImplicitConversionSequence ICS = TryContextuallyConvertToObjCId(*this, From); 3275 if (!ICS.isBad()) 3276 return PerformImplicitConversion(From, Ty, ICS, AA_Converting); 3277 return true; 3278} 3279 3280/// \brief Attempt to convert the given expression to an integral or 3281/// enumeration type. 3282/// 3283/// This routine will attempt to convert an expression of class type to an 3284/// integral or enumeration type, if that class type only has a single 3285/// conversion to an integral or enumeration type. 3286/// 3287/// \param Loc The source location of the construct that requires the 3288/// conversion. 3289/// 3290/// \param FromE The expression we're converting from. 3291/// 3292/// \param NotIntDiag The diagnostic to be emitted if the expression does not 3293/// have integral or enumeration type. 3294/// 3295/// \param IncompleteDiag The diagnostic to be emitted if the expression has 3296/// incomplete class type. 3297/// 3298/// \param ExplicitConvDiag The diagnostic to be emitted if we're calling an 3299/// explicit conversion function (because no implicit conversion functions 3300/// were available). This is a recovery mode. 3301/// 3302/// \param ExplicitConvNote The note to be emitted with \p ExplicitConvDiag, 3303/// showing which conversion was picked. 3304/// 3305/// \param AmbigDiag The diagnostic to be emitted if there is more than one 3306/// conversion function that could convert to integral or enumeration type. 3307/// 3308/// \param AmbigNote The note to be emitted with \p AmbigDiag for each 3309/// usable conversion function. 3310/// 3311/// \param ConvDiag The diagnostic to be emitted if we are calling a conversion 3312/// function, which may be an extension in this case. 3313/// 3314/// \returns The expression, converted to an integral or enumeration type if 3315/// successful. 3316ExprResult 3317Sema::ConvertToIntegralOrEnumerationType(SourceLocation Loc, Expr *From, 3318 const PartialDiagnostic &NotIntDiag, 3319 const PartialDiagnostic &IncompleteDiag, 3320 const PartialDiagnostic &ExplicitConvDiag, 3321 const PartialDiagnostic &ExplicitConvNote, 3322 const PartialDiagnostic &AmbigDiag, 3323 const PartialDiagnostic &AmbigNote, 3324 const PartialDiagnostic &ConvDiag) { 3325 // We can't perform any more checking for type-dependent expressions. 3326 if (From->isTypeDependent()) 3327 return Owned(From); 3328 3329 // If the expression already has integral or enumeration type, we're golden. 3330 QualType T = From->getType(); 3331 if (T->isIntegralOrEnumerationType()) 3332 return Owned(From); 3333 3334 // FIXME: Check for missing '()' if T is a function type? 3335 3336 // If we don't have a class type in C++, there's no way we can get an 3337 // expression of integral or enumeration type. 3338 const RecordType *RecordTy = T->getAs<RecordType>(); 3339 if (!RecordTy || !getLangOptions().CPlusPlus) { 3340 Diag(Loc, NotIntDiag) 3341 << T << From->getSourceRange(); 3342 return Owned(From); 3343 } 3344 3345 // We must have a complete class type. 3346 if (RequireCompleteType(Loc, T, IncompleteDiag)) 3347 return Owned(From); 3348 3349 // Look for a conversion to an integral or enumeration type. 3350 UnresolvedSet<4> ViableConversions; 3351 UnresolvedSet<4> ExplicitConversions; 3352 const UnresolvedSetImpl *Conversions 3353 = cast<CXXRecordDecl>(RecordTy->getDecl())->getVisibleConversionFunctions(); 3354 3355 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 3356 E = Conversions->end(); 3357 I != E; 3358 ++I) { 3359 if (CXXConversionDecl *Conversion 3360 = dyn_cast<CXXConversionDecl>((*I)->getUnderlyingDecl())) 3361 if (Conversion->getConversionType().getNonReferenceType() 3362 ->isIntegralOrEnumerationType()) { 3363 if (Conversion->isExplicit()) 3364 ExplicitConversions.addDecl(I.getDecl(), I.getAccess()); 3365 else 3366 ViableConversions.addDecl(I.getDecl(), I.getAccess()); 3367 } 3368 } 3369 3370 switch (ViableConversions.size()) { 3371 case 0: 3372 if (ExplicitConversions.size() == 1) { 3373 DeclAccessPair Found = ExplicitConversions[0]; 3374 CXXConversionDecl *Conversion 3375 = cast<CXXConversionDecl>(Found->getUnderlyingDecl()); 3376 3377 // The user probably meant to invoke the given explicit 3378 // conversion; use it. 3379 QualType ConvTy 3380 = Conversion->getConversionType().getNonReferenceType(); 3381 std::string TypeStr; 3382 ConvTy.getAsStringInternal(TypeStr, Context.PrintingPolicy); 3383 3384 Diag(Loc, ExplicitConvDiag) 3385 << T << ConvTy 3386 << FixItHint::CreateInsertion(From->getLocStart(), 3387 "static_cast<" + TypeStr + ">(") 3388 << FixItHint::CreateInsertion(PP.getLocForEndOfToken(From->getLocEnd()), 3389 ")"); 3390 Diag(Conversion->getLocation(), ExplicitConvNote) 3391 << ConvTy->isEnumeralType() << ConvTy; 3392 3393 // If we aren't in a SFINAE context, build a call to the 3394 // explicit conversion function. 3395 if (isSFINAEContext()) 3396 return ExprError(); 3397 3398 CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found); 3399 From = BuildCXXMemberCallExpr(From, Found, Conversion); 3400 } 3401 3402 // We'll complain below about a non-integral condition type. 3403 break; 3404 3405 case 1: { 3406 // Apply this conversion. 3407 DeclAccessPair Found = ViableConversions[0]; 3408 CheckMemberOperatorAccess(From->getExprLoc(), From, 0, Found); 3409 3410 CXXConversionDecl *Conversion 3411 = cast<CXXConversionDecl>(Found->getUnderlyingDecl()); 3412 QualType ConvTy 3413 = Conversion->getConversionType().getNonReferenceType(); 3414 if (ConvDiag.getDiagID()) { 3415 if (isSFINAEContext()) 3416 return ExprError(); 3417 3418 Diag(Loc, ConvDiag) 3419 << T << ConvTy->isEnumeralType() << ConvTy << From->getSourceRange(); 3420 } 3421 3422 From = BuildCXXMemberCallExpr(From, Found, 3423 cast<CXXConversionDecl>(Found->getUnderlyingDecl())); 3424 break; 3425 } 3426 3427 default: 3428 Diag(Loc, AmbigDiag) 3429 << T << From->getSourceRange(); 3430 for (unsigned I = 0, N = ViableConversions.size(); I != N; ++I) { 3431 CXXConversionDecl *Conv 3432 = cast<CXXConversionDecl>(ViableConversions[I]->getUnderlyingDecl()); 3433 QualType ConvTy = Conv->getConversionType().getNonReferenceType(); 3434 Diag(Conv->getLocation(), AmbigNote) 3435 << ConvTy->isEnumeralType() << ConvTy; 3436 } 3437 return Owned(From); 3438 } 3439 3440 if (!From->getType()->isIntegralOrEnumerationType()) 3441 Diag(Loc, NotIntDiag) 3442 << From->getType() << From->getSourceRange(); 3443 3444 return Owned(From); 3445} 3446 3447/// AddOverloadCandidate - Adds the given function to the set of 3448/// candidate functions, using the given function call arguments. If 3449/// @p SuppressUserConversions, then don't allow user-defined 3450/// conversions via constructors or conversion operators. 3451/// 3452/// \para PartialOverloading true if we are performing "partial" overloading 3453/// based on an incomplete set of function arguments. This feature is used by 3454/// code completion. 3455void 3456Sema::AddOverloadCandidate(FunctionDecl *Function, 3457 DeclAccessPair FoundDecl, 3458 Expr **Args, unsigned NumArgs, 3459 OverloadCandidateSet& CandidateSet, 3460 bool SuppressUserConversions, 3461 bool PartialOverloading) { 3462 const FunctionProtoType* Proto 3463 = dyn_cast<FunctionProtoType>(Function->getType()->getAs<FunctionType>()); 3464 assert(Proto && "Functions without a prototype cannot be overloaded"); 3465 assert(!Function->getDescribedFunctionTemplate() && 3466 "Use AddTemplateOverloadCandidate for function templates"); 3467 3468 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Function)) { 3469 if (!isa<CXXConstructorDecl>(Method)) { 3470 // If we get here, it's because we're calling a member function 3471 // that is named without a member access expression (e.g., 3472 // "this->f") that was either written explicitly or created 3473 // implicitly. This can happen with a qualified call to a member 3474 // function, e.g., X::f(). We use an empty type for the implied 3475 // object argument (C++ [over.call.func]p3), and the acting context 3476 // is irrelevant. 3477 AddMethodCandidate(Method, FoundDecl, Method->getParent(), 3478 QualType(), Args, NumArgs, CandidateSet, 3479 SuppressUserConversions); 3480 return; 3481 } 3482 // We treat a constructor like a non-member function, since its object 3483 // argument doesn't participate in overload resolution. 3484 } 3485 3486 if (!CandidateSet.isNewCandidate(Function)) 3487 return; 3488 3489 // Overload resolution is always an unevaluated context. 3490 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 3491 3492 if (CXXConstructorDecl *Constructor = dyn_cast<CXXConstructorDecl>(Function)){ 3493 // C++ [class.copy]p3: 3494 // A member function template is never instantiated to perform the copy 3495 // of a class object to an object of its class type. 3496 QualType ClassType = Context.getTypeDeclType(Constructor->getParent()); 3497 if (NumArgs == 1 && 3498 Constructor->isSpecializationCopyingObject() && 3499 (Context.hasSameUnqualifiedType(ClassType, Args[0]->getType()) || 3500 IsDerivedFrom(Args[0]->getType(), ClassType))) 3501 return; 3502 } 3503 3504 // Add this candidate 3505 CandidateSet.push_back(OverloadCandidate()); 3506 OverloadCandidate& Candidate = CandidateSet.back(); 3507 Candidate.FoundDecl = FoundDecl; 3508 Candidate.Function = Function; 3509 Candidate.Viable = true; 3510 Candidate.IsSurrogate = false; 3511 Candidate.IgnoreObjectArgument = false; 3512 3513 unsigned NumArgsInProto = Proto->getNumArgs(); 3514 3515 // (C++ 13.3.2p2): A candidate function having fewer than m 3516 // parameters is viable only if it has an ellipsis in its parameter 3517 // list (8.3.5). 3518 if ((NumArgs + (PartialOverloading && NumArgs)) > NumArgsInProto && 3519 !Proto->isVariadic()) { 3520 Candidate.Viable = false; 3521 Candidate.FailureKind = ovl_fail_too_many_arguments; 3522 return; 3523 } 3524 3525 // (C++ 13.3.2p2): A candidate function having more than m parameters 3526 // is viable only if the (m+1)st parameter has a default argument 3527 // (8.3.6). For the purposes of overload resolution, the 3528 // parameter list is truncated on the right, so that there are 3529 // exactly m parameters. 3530 unsigned MinRequiredArgs = Function->getMinRequiredArguments(); 3531 if (NumArgs < MinRequiredArgs && !PartialOverloading) { 3532 // Not enough arguments. 3533 Candidate.Viable = false; 3534 Candidate.FailureKind = ovl_fail_too_few_arguments; 3535 return; 3536 } 3537 3538 // Determine the implicit conversion sequences for each of the 3539 // arguments. 3540 Candidate.Conversions.resize(NumArgs); 3541 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 3542 if (ArgIdx < NumArgsInProto) { 3543 // (C++ 13.3.2p3): for F to be a viable function, there shall 3544 // exist for each argument an implicit conversion sequence 3545 // (13.3.3.1) that converts that argument to the corresponding 3546 // parameter of F. 3547 QualType ParamType = Proto->getArgType(ArgIdx); 3548 Candidate.Conversions[ArgIdx] 3549 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 3550 SuppressUserConversions, 3551 /*InOverloadResolution=*/true); 3552 if (Candidate.Conversions[ArgIdx].isBad()) { 3553 Candidate.Viable = false; 3554 Candidate.FailureKind = ovl_fail_bad_conversion; 3555 break; 3556 } 3557 } else { 3558 // (C++ 13.3.2p2): For the purposes of overload resolution, any 3559 // argument for which there is no corresponding parameter is 3560 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 3561 Candidate.Conversions[ArgIdx].setEllipsis(); 3562 } 3563 } 3564} 3565 3566/// \brief Add all of the function declarations in the given function set to 3567/// the overload canddiate set. 3568void Sema::AddFunctionCandidates(const UnresolvedSetImpl &Fns, 3569 Expr **Args, unsigned NumArgs, 3570 OverloadCandidateSet& CandidateSet, 3571 bool SuppressUserConversions) { 3572 for (UnresolvedSetIterator F = Fns.begin(), E = Fns.end(); F != E; ++F) { 3573 NamedDecl *D = F.getDecl()->getUnderlyingDecl(); 3574 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 3575 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic()) 3576 AddMethodCandidate(cast<CXXMethodDecl>(FD), F.getPair(), 3577 cast<CXXMethodDecl>(FD)->getParent(), 3578 Args[0]->getType(), Args + 1, NumArgs - 1, 3579 CandidateSet, SuppressUserConversions); 3580 else 3581 AddOverloadCandidate(FD, F.getPair(), Args, NumArgs, CandidateSet, 3582 SuppressUserConversions); 3583 } else { 3584 FunctionTemplateDecl *FunTmpl = cast<FunctionTemplateDecl>(D); 3585 if (isa<CXXMethodDecl>(FunTmpl->getTemplatedDecl()) && 3586 !cast<CXXMethodDecl>(FunTmpl->getTemplatedDecl())->isStatic()) 3587 AddMethodTemplateCandidate(FunTmpl, F.getPair(), 3588 cast<CXXRecordDecl>(FunTmpl->getDeclContext()), 3589 /*FIXME: explicit args */ 0, 3590 Args[0]->getType(), Args + 1, NumArgs - 1, 3591 CandidateSet, 3592 SuppressUserConversions); 3593 else 3594 AddTemplateOverloadCandidate(FunTmpl, F.getPair(), 3595 /*FIXME: explicit args */ 0, 3596 Args, NumArgs, CandidateSet, 3597 SuppressUserConversions); 3598 } 3599 } 3600} 3601 3602/// AddMethodCandidate - Adds a named decl (which is some kind of 3603/// method) as a method candidate to the given overload set. 3604void Sema::AddMethodCandidate(DeclAccessPair FoundDecl, 3605 QualType ObjectType, 3606 Expr **Args, unsigned NumArgs, 3607 OverloadCandidateSet& CandidateSet, 3608 bool SuppressUserConversions) { 3609 NamedDecl *Decl = FoundDecl.getDecl(); 3610 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(Decl->getDeclContext()); 3611 3612 if (isa<UsingShadowDecl>(Decl)) 3613 Decl = cast<UsingShadowDecl>(Decl)->getTargetDecl(); 3614 3615 if (FunctionTemplateDecl *TD = dyn_cast<FunctionTemplateDecl>(Decl)) { 3616 assert(isa<CXXMethodDecl>(TD->getTemplatedDecl()) && 3617 "Expected a member function template"); 3618 AddMethodTemplateCandidate(TD, FoundDecl, ActingContext, 3619 /*ExplicitArgs*/ 0, 3620 ObjectType, Args, NumArgs, 3621 CandidateSet, 3622 SuppressUserConversions); 3623 } else { 3624 AddMethodCandidate(cast<CXXMethodDecl>(Decl), FoundDecl, ActingContext, 3625 ObjectType, Args, NumArgs, 3626 CandidateSet, SuppressUserConversions); 3627 } 3628} 3629 3630/// AddMethodCandidate - Adds the given C++ member function to the set 3631/// of candidate functions, using the given function call arguments 3632/// and the object argument (@c Object). For example, in a call 3633/// @c o.f(a1,a2), @c Object will contain @c o and @c Args will contain 3634/// both @c a1 and @c a2. If @p SuppressUserConversions, then don't 3635/// allow user-defined conversions via constructors or conversion 3636/// operators. 3637void 3638Sema::AddMethodCandidate(CXXMethodDecl *Method, DeclAccessPair FoundDecl, 3639 CXXRecordDecl *ActingContext, QualType ObjectType, 3640 Expr **Args, unsigned NumArgs, 3641 OverloadCandidateSet& CandidateSet, 3642 bool SuppressUserConversions) { 3643 const FunctionProtoType* Proto 3644 = dyn_cast<FunctionProtoType>(Method->getType()->getAs<FunctionType>()); 3645 assert(Proto && "Methods without a prototype cannot be overloaded"); 3646 assert(!isa<CXXConstructorDecl>(Method) && 3647 "Use AddOverloadCandidate for constructors"); 3648 3649 if (!CandidateSet.isNewCandidate(Method)) 3650 return; 3651 3652 // Overload resolution is always an unevaluated context. 3653 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 3654 3655 // Add this candidate 3656 CandidateSet.push_back(OverloadCandidate()); 3657 OverloadCandidate& Candidate = CandidateSet.back(); 3658 Candidate.FoundDecl = FoundDecl; 3659 Candidate.Function = Method; 3660 Candidate.IsSurrogate = false; 3661 Candidate.IgnoreObjectArgument = false; 3662 3663 unsigned NumArgsInProto = Proto->getNumArgs(); 3664 3665 // (C++ 13.3.2p2): A candidate function having fewer than m 3666 // parameters is viable only if it has an ellipsis in its parameter 3667 // list (8.3.5). 3668 if (NumArgs > NumArgsInProto && !Proto->isVariadic()) { 3669 Candidate.Viable = false; 3670 Candidate.FailureKind = ovl_fail_too_many_arguments; 3671 return; 3672 } 3673 3674 // (C++ 13.3.2p2): A candidate function having more than m parameters 3675 // is viable only if the (m+1)st parameter has a default argument 3676 // (8.3.6). For the purposes of overload resolution, the 3677 // parameter list is truncated on the right, so that there are 3678 // exactly m parameters. 3679 unsigned MinRequiredArgs = Method->getMinRequiredArguments(); 3680 if (NumArgs < MinRequiredArgs) { 3681 // Not enough arguments. 3682 Candidate.Viable = false; 3683 Candidate.FailureKind = ovl_fail_too_few_arguments; 3684 return; 3685 } 3686 3687 Candidate.Viable = true; 3688 Candidate.Conversions.resize(NumArgs + 1); 3689 3690 if (Method->isStatic() || ObjectType.isNull()) 3691 // The implicit object argument is ignored. 3692 Candidate.IgnoreObjectArgument = true; 3693 else { 3694 // Determine the implicit conversion sequence for the object 3695 // parameter. 3696 Candidate.Conversions[0] 3697 = TryObjectArgumentInitialization(*this, ObjectType, Method, 3698 ActingContext); 3699 if (Candidate.Conversions[0].isBad()) { 3700 Candidate.Viable = false; 3701 Candidate.FailureKind = ovl_fail_bad_conversion; 3702 return; 3703 } 3704 } 3705 3706 // Determine the implicit conversion sequences for each of the 3707 // arguments. 3708 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 3709 if (ArgIdx < NumArgsInProto) { 3710 // (C++ 13.3.2p3): for F to be a viable function, there shall 3711 // exist for each argument an implicit conversion sequence 3712 // (13.3.3.1) that converts that argument to the corresponding 3713 // parameter of F. 3714 QualType ParamType = Proto->getArgType(ArgIdx); 3715 Candidate.Conversions[ArgIdx + 1] 3716 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 3717 SuppressUserConversions, 3718 /*InOverloadResolution=*/true); 3719 if (Candidate.Conversions[ArgIdx + 1].isBad()) { 3720 Candidate.Viable = false; 3721 Candidate.FailureKind = ovl_fail_bad_conversion; 3722 break; 3723 } 3724 } else { 3725 // (C++ 13.3.2p2): For the purposes of overload resolution, any 3726 // argument for which there is no corresponding parameter is 3727 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 3728 Candidate.Conversions[ArgIdx + 1].setEllipsis(); 3729 } 3730 } 3731} 3732 3733/// \brief Add a C++ member function template as a candidate to the candidate 3734/// set, using template argument deduction to produce an appropriate member 3735/// function template specialization. 3736void 3737Sema::AddMethodTemplateCandidate(FunctionTemplateDecl *MethodTmpl, 3738 DeclAccessPair FoundDecl, 3739 CXXRecordDecl *ActingContext, 3740 const TemplateArgumentListInfo *ExplicitTemplateArgs, 3741 QualType ObjectType, 3742 Expr **Args, unsigned NumArgs, 3743 OverloadCandidateSet& CandidateSet, 3744 bool SuppressUserConversions) { 3745 if (!CandidateSet.isNewCandidate(MethodTmpl)) 3746 return; 3747 3748 // C++ [over.match.funcs]p7: 3749 // In each case where a candidate is a function template, candidate 3750 // function template specializations are generated using template argument 3751 // deduction (14.8.3, 14.8.2). Those candidates are then handled as 3752 // candidate functions in the usual way.113) A given name can refer to one 3753 // or more function templates and also to a set of overloaded non-template 3754 // functions. In such a case, the candidate functions generated from each 3755 // function template are combined with the set of non-template candidate 3756 // functions. 3757 TemplateDeductionInfo Info(Context, CandidateSet.getLocation()); 3758 FunctionDecl *Specialization = 0; 3759 if (TemplateDeductionResult Result 3760 = DeduceTemplateArguments(MethodTmpl, ExplicitTemplateArgs, 3761 Args, NumArgs, Specialization, Info)) { 3762 CandidateSet.push_back(OverloadCandidate()); 3763 OverloadCandidate &Candidate = CandidateSet.back(); 3764 Candidate.FoundDecl = FoundDecl; 3765 Candidate.Function = MethodTmpl->getTemplatedDecl(); 3766 Candidate.Viable = false; 3767 Candidate.FailureKind = ovl_fail_bad_deduction; 3768 Candidate.IsSurrogate = false; 3769 Candidate.IgnoreObjectArgument = false; 3770 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 3771 Info); 3772 return; 3773 } 3774 3775 // Add the function template specialization produced by template argument 3776 // deduction as a candidate. 3777 assert(Specialization && "Missing member function template specialization?"); 3778 assert(isa<CXXMethodDecl>(Specialization) && 3779 "Specialization is not a member function?"); 3780 AddMethodCandidate(cast<CXXMethodDecl>(Specialization), FoundDecl, 3781 ActingContext, ObjectType, Args, NumArgs, 3782 CandidateSet, SuppressUserConversions); 3783} 3784 3785/// \brief Add a C++ function template specialization as a candidate 3786/// in the candidate set, using template argument deduction to produce 3787/// an appropriate function template specialization. 3788void 3789Sema::AddTemplateOverloadCandidate(FunctionTemplateDecl *FunctionTemplate, 3790 DeclAccessPair FoundDecl, 3791 const TemplateArgumentListInfo *ExplicitTemplateArgs, 3792 Expr **Args, unsigned NumArgs, 3793 OverloadCandidateSet& CandidateSet, 3794 bool SuppressUserConversions) { 3795 if (!CandidateSet.isNewCandidate(FunctionTemplate)) 3796 return; 3797 3798 // C++ [over.match.funcs]p7: 3799 // In each case where a candidate is a function template, candidate 3800 // function template specializations are generated using template argument 3801 // deduction (14.8.3, 14.8.2). Those candidates are then handled as 3802 // candidate functions in the usual way.113) A given name can refer to one 3803 // or more function templates and also to a set of overloaded non-template 3804 // functions. In such a case, the candidate functions generated from each 3805 // function template are combined with the set of non-template candidate 3806 // functions. 3807 TemplateDeductionInfo Info(Context, CandidateSet.getLocation()); 3808 FunctionDecl *Specialization = 0; 3809 if (TemplateDeductionResult Result 3810 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 3811 Args, NumArgs, Specialization, Info)) { 3812 CandidateSet.push_back(OverloadCandidate()); 3813 OverloadCandidate &Candidate = CandidateSet.back(); 3814 Candidate.FoundDecl = FoundDecl; 3815 Candidate.Function = FunctionTemplate->getTemplatedDecl(); 3816 Candidate.Viable = false; 3817 Candidate.FailureKind = ovl_fail_bad_deduction; 3818 Candidate.IsSurrogate = false; 3819 Candidate.IgnoreObjectArgument = false; 3820 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 3821 Info); 3822 return; 3823 } 3824 3825 // Add the function template specialization produced by template argument 3826 // deduction as a candidate. 3827 assert(Specialization && "Missing function template specialization?"); 3828 AddOverloadCandidate(Specialization, FoundDecl, Args, NumArgs, CandidateSet, 3829 SuppressUserConversions); 3830} 3831 3832/// AddConversionCandidate - Add a C++ conversion function as a 3833/// candidate in the candidate set (C++ [over.match.conv], 3834/// C++ [over.match.copy]). From is the expression we're converting from, 3835/// and ToType is the type that we're eventually trying to convert to 3836/// (which may or may not be the same type as the type that the 3837/// conversion function produces). 3838void 3839Sema::AddConversionCandidate(CXXConversionDecl *Conversion, 3840 DeclAccessPair FoundDecl, 3841 CXXRecordDecl *ActingContext, 3842 Expr *From, QualType ToType, 3843 OverloadCandidateSet& CandidateSet) { 3844 assert(!Conversion->getDescribedFunctionTemplate() && 3845 "Conversion function templates use AddTemplateConversionCandidate"); 3846 QualType ConvType = Conversion->getConversionType().getNonReferenceType(); 3847 if (!CandidateSet.isNewCandidate(Conversion)) 3848 return; 3849 3850 // Overload resolution is always an unevaluated context. 3851 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 3852 3853 // Add this candidate 3854 CandidateSet.push_back(OverloadCandidate()); 3855 OverloadCandidate& Candidate = CandidateSet.back(); 3856 Candidate.FoundDecl = FoundDecl; 3857 Candidate.Function = Conversion; 3858 Candidate.IsSurrogate = false; 3859 Candidate.IgnoreObjectArgument = false; 3860 Candidate.FinalConversion.setAsIdentityConversion(); 3861 Candidate.FinalConversion.setFromType(ConvType); 3862 Candidate.FinalConversion.setAllToTypes(ToType); 3863 Candidate.Viable = true; 3864 Candidate.Conversions.resize(1); 3865 3866 // C++ [over.match.funcs]p4: 3867 // For conversion functions, the function is considered to be a member of 3868 // the class of the implicit implied object argument for the purpose of 3869 // defining the type of the implicit object parameter. 3870 // 3871 // Determine the implicit conversion sequence for the implicit 3872 // object parameter. 3873 QualType ImplicitParamType = From->getType(); 3874 if (const PointerType *FromPtrType = ImplicitParamType->getAs<PointerType>()) 3875 ImplicitParamType = FromPtrType->getPointeeType(); 3876 CXXRecordDecl *ConversionContext 3877 = cast<CXXRecordDecl>(ImplicitParamType->getAs<RecordType>()->getDecl()); 3878 3879 Candidate.Conversions[0] 3880 = TryObjectArgumentInitialization(*this, From->getType(), Conversion, 3881 ConversionContext); 3882 3883 if (Candidate.Conversions[0].isBad()) { 3884 Candidate.Viable = false; 3885 Candidate.FailureKind = ovl_fail_bad_conversion; 3886 return; 3887 } 3888 3889 // We won't go through a user-define type conversion function to convert a 3890 // derived to base as such conversions are given Conversion Rank. They only 3891 // go through a copy constructor. 13.3.3.1.2-p4 [over.ics.user] 3892 QualType FromCanon 3893 = Context.getCanonicalType(From->getType().getUnqualifiedType()); 3894 QualType ToCanon = Context.getCanonicalType(ToType).getUnqualifiedType(); 3895 if (FromCanon == ToCanon || IsDerivedFrom(FromCanon, ToCanon)) { 3896 Candidate.Viable = false; 3897 Candidate.FailureKind = ovl_fail_trivial_conversion; 3898 return; 3899 } 3900 3901 // To determine what the conversion from the result of calling the 3902 // conversion function to the type we're eventually trying to 3903 // convert to (ToType), we need to synthesize a call to the 3904 // conversion function and attempt copy initialization from it. This 3905 // makes sure that we get the right semantics with respect to 3906 // lvalues/rvalues and the type. Fortunately, we can allocate this 3907 // call on the stack and we don't need its arguments to be 3908 // well-formed. 3909 DeclRefExpr ConversionRef(Conversion, Conversion->getType(), 3910 VK_LValue, From->getLocStart()); 3911 ImplicitCastExpr ConversionFn(ImplicitCastExpr::OnStack, 3912 Context.getPointerType(Conversion->getType()), 3913 CK_FunctionToPointerDecay, 3914 &ConversionRef, VK_RValue); 3915 3916 QualType CallResultType 3917 = Conversion->getConversionType().getNonLValueExprType(Context); 3918 if (RequireCompleteType(From->getLocStart(), CallResultType, 0)) { 3919 Candidate.Viable = false; 3920 Candidate.FailureKind = ovl_fail_bad_final_conversion; 3921 return; 3922 } 3923 3924 ExprValueKind VK = Expr::getValueKindForType(Conversion->getConversionType()); 3925 3926 // Note that it is safe to allocate CallExpr on the stack here because 3927 // there are 0 arguments (i.e., nothing is allocated using ASTContext's 3928 // allocator). 3929 CallExpr Call(Context, &ConversionFn, 0, 0, CallResultType, VK, 3930 From->getLocStart()); 3931 ImplicitConversionSequence ICS = 3932 TryCopyInitialization(*this, &Call, ToType, 3933 /*SuppressUserConversions=*/true, 3934 /*InOverloadResolution=*/false); 3935 3936 switch (ICS.getKind()) { 3937 case ImplicitConversionSequence::StandardConversion: 3938 Candidate.FinalConversion = ICS.Standard; 3939 3940 // C++ [over.ics.user]p3: 3941 // If the user-defined conversion is specified by a specialization of a 3942 // conversion function template, the second standard conversion sequence 3943 // shall have exact match rank. 3944 if (Conversion->getPrimaryTemplate() && 3945 GetConversionRank(ICS.Standard.Second) != ICR_Exact_Match) { 3946 Candidate.Viable = false; 3947 Candidate.FailureKind = ovl_fail_final_conversion_not_exact; 3948 } 3949 3950 break; 3951 3952 case ImplicitConversionSequence::BadConversion: 3953 Candidate.Viable = false; 3954 Candidate.FailureKind = ovl_fail_bad_final_conversion; 3955 break; 3956 3957 default: 3958 assert(false && 3959 "Can only end up with a standard conversion sequence or failure"); 3960 } 3961} 3962 3963/// \brief Adds a conversion function template specialization 3964/// candidate to the overload set, using template argument deduction 3965/// to deduce the template arguments of the conversion function 3966/// template from the type that we are converting to (C++ 3967/// [temp.deduct.conv]). 3968void 3969Sema::AddTemplateConversionCandidate(FunctionTemplateDecl *FunctionTemplate, 3970 DeclAccessPair FoundDecl, 3971 CXXRecordDecl *ActingDC, 3972 Expr *From, QualType ToType, 3973 OverloadCandidateSet &CandidateSet) { 3974 assert(isa<CXXConversionDecl>(FunctionTemplate->getTemplatedDecl()) && 3975 "Only conversion function templates permitted here"); 3976 3977 if (!CandidateSet.isNewCandidate(FunctionTemplate)) 3978 return; 3979 3980 TemplateDeductionInfo Info(Context, CandidateSet.getLocation()); 3981 CXXConversionDecl *Specialization = 0; 3982 if (TemplateDeductionResult Result 3983 = DeduceTemplateArguments(FunctionTemplate, ToType, 3984 Specialization, Info)) { 3985 CandidateSet.push_back(OverloadCandidate()); 3986 OverloadCandidate &Candidate = CandidateSet.back(); 3987 Candidate.FoundDecl = FoundDecl; 3988 Candidate.Function = FunctionTemplate->getTemplatedDecl(); 3989 Candidate.Viable = false; 3990 Candidate.FailureKind = ovl_fail_bad_deduction; 3991 Candidate.IsSurrogate = false; 3992 Candidate.IgnoreObjectArgument = false; 3993 Candidate.DeductionFailure = MakeDeductionFailureInfo(Context, Result, 3994 Info); 3995 return; 3996 } 3997 3998 // Add the conversion function template specialization produced by 3999 // template argument deduction as a candidate. 4000 assert(Specialization && "Missing function template specialization?"); 4001 AddConversionCandidate(Specialization, FoundDecl, ActingDC, From, ToType, 4002 CandidateSet); 4003} 4004 4005/// AddSurrogateCandidate - Adds a "surrogate" candidate function that 4006/// converts the given @c Object to a function pointer via the 4007/// conversion function @c Conversion, and then attempts to call it 4008/// with the given arguments (C++ [over.call.object]p2-4). Proto is 4009/// the type of function that we'll eventually be calling. 4010void Sema::AddSurrogateCandidate(CXXConversionDecl *Conversion, 4011 DeclAccessPair FoundDecl, 4012 CXXRecordDecl *ActingContext, 4013 const FunctionProtoType *Proto, 4014 QualType ObjectType, 4015 Expr **Args, unsigned NumArgs, 4016 OverloadCandidateSet& CandidateSet) { 4017 if (!CandidateSet.isNewCandidate(Conversion)) 4018 return; 4019 4020 // Overload resolution is always an unevaluated context. 4021 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 4022 4023 CandidateSet.push_back(OverloadCandidate()); 4024 OverloadCandidate& Candidate = CandidateSet.back(); 4025 Candidate.FoundDecl = FoundDecl; 4026 Candidate.Function = 0; 4027 Candidate.Surrogate = Conversion; 4028 Candidate.Viable = true; 4029 Candidate.IsSurrogate = true; 4030 Candidate.IgnoreObjectArgument = false; 4031 Candidate.Conversions.resize(NumArgs + 1); 4032 4033 // Determine the implicit conversion sequence for the implicit 4034 // object parameter. 4035 ImplicitConversionSequence ObjectInit 4036 = TryObjectArgumentInitialization(*this, ObjectType, Conversion, 4037 ActingContext); 4038 if (ObjectInit.isBad()) { 4039 Candidate.Viable = false; 4040 Candidate.FailureKind = ovl_fail_bad_conversion; 4041 Candidate.Conversions[0] = ObjectInit; 4042 return; 4043 } 4044 4045 // The first conversion is actually a user-defined conversion whose 4046 // first conversion is ObjectInit's standard conversion (which is 4047 // effectively a reference binding). Record it as such. 4048 Candidate.Conversions[0].setUserDefined(); 4049 Candidate.Conversions[0].UserDefined.Before = ObjectInit.Standard; 4050 Candidate.Conversions[0].UserDefined.EllipsisConversion = false; 4051 Candidate.Conversions[0].UserDefined.ConversionFunction = Conversion; 4052 Candidate.Conversions[0].UserDefined.After 4053 = Candidate.Conversions[0].UserDefined.Before; 4054 Candidate.Conversions[0].UserDefined.After.setAsIdentityConversion(); 4055 4056 // Find the 4057 unsigned NumArgsInProto = Proto->getNumArgs(); 4058 4059 // (C++ 13.3.2p2): A candidate function having fewer than m 4060 // parameters is viable only if it has an ellipsis in its parameter 4061 // list (8.3.5). 4062 if (NumArgs > NumArgsInProto && !Proto->isVariadic()) { 4063 Candidate.Viable = false; 4064 Candidate.FailureKind = ovl_fail_too_many_arguments; 4065 return; 4066 } 4067 4068 // Function types don't have any default arguments, so just check if 4069 // we have enough arguments. 4070 if (NumArgs < NumArgsInProto) { 4071 // Not enough arguments. 4072 Candidate.Viable = false; 4073 Candidate.FailureKind = ovl_fail_too_few_arguments; 4074 return; 4075 } 4076 4077 // Determine the implicit conversion sequences for each of the 4078 // arguments. 4079 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 4080 if (ArgIdx < NumArgsInProto) { 4081 // (C++ 13.3.2p3): for F to be a viable function, there shall 4082 // exist for each argument an implicit conversion sequence 4083 // (13.3.3.1) that converts that argument to the corresponding 4084 // parameter of F. 4085 QualType ParamType = Proto->getArgType(ArgIdx); 4086 Candidate.Conversions[ArgIdx + 1] 4087 = TryCopyInitialization(*this, Args[ArgIdx], ParamType, 4088 /*SuppressUserConversions=*/false, 4089 /*InOverloadResolution=*/false); 4090 if (Candidate.Conversions[ArgIdx + 1].isBad()) { 4091 Candidate.Viable = false; 4092 Candidate.FailureKind = ovl_fail_bad_conversion; 4093 break; 4094 } 4095 } else { 4096 // (C++ 13.3.2p2): For the purposes of overload resolution, any 4097 // argument for which there is no corresponding parameter is 4098 // considered to ""match the ellipsis" (C+ 13.3.3.1.3). 4099 Candidate.Conversions[ArgIdx + 1].setEllipsis(); 4100 } 4101 } 4102} 4103 4104/// \brief Add overload candidates for overloaded operators that are 4105/// member functions. 4106/// 4107/// Add the overloaded operator candidates that are member functions 4108/// for the operator Op that was used in an operator expression such 4109/// as "x Op y". , Args/NumArgs provides the operator arguments, and 4110/// CandidateSet will store the added overload candidates. (C++ 4111/// [over.match.oper]). 4112void Sema::AddMemberOperatorCandidates(OverloadedOperatorKind Op, 4113 SourceLocation OpLoc, 4114 Expr **Args, unsigned NumArgs, 4115 OverloadCandidateSet& CandidateSet, 4116 SourceRange OpRange) { 4117 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 4118 4119 // C++ [over.match.oper]p3: 4120 // For a unary operator @ with an operand of a type whose 4121 // cv-unqualified version is T1, and for a binary operator @ with 4122 // a left operand of a type whose cv-unqualified version is T1 and 4123 // a right operand of a type whose cv-unqualified version is T2, 4124 // three sets of candidate functions, designated member 4125 // candidates, non-member candidates and built-in candidates, are 4126 // constructed as follows: 4127 QualType T1 = Args[0]->getType(); 4128 4129 // -- If T1 is a class type, the set of member candidates is the 4130 // result of the qualified lookup of T1::operator@ 4131 // (13.3.1.1.1); otherwise, the set of member candidates is 4132 // empty. 4133 if (const RecordType *T1Rec = T1->getAs<RecordType>()) { 4134 // Complete the type if it can be completed. Otherwise, we're done. 4135 if (RequireCompleteType(OpLoc, T1, PDiag())) 4136 return; 4137 4138 LookupResult Operators(*this, OpName, OpLoc, LookupOrdinaryName); 4139 LookupQualifiedName(Operators, T1Rec->getDecl()); 4140 Operators.suppressDiagnostics(); 4141 4142 for (LookupResult::iterator Oper = Operators.begin(), 4143 OperEnd = Operators.end(); 4144 Oper != OperEnd; 4145 ++Oper) 4146 AddMethodCandidate(Oper.getPair(), Args[0]->getType(), 4147 Args + 1, NumArgs - 1, CandidateSet, 4148 /* SuppressUserConversions = */ false); 4149 } 4150} 4151 4152/// AddBuiltinCandidate - Add a candidate for a built-in 4153/// operator. ResultTy and ParamTys are the result and parameter types 4154/// of the built-in candidate, respectively. Args and NumArgs are the 4155/// arguments being passed to the candidate. IsAssignmentOperator 4156/// should be true when this built-in candidate is an assignment 4157/// operator. NumContextualBoolArguments is the number of arguments 4158/// (at the beginning of the argument list) that will be contextually 4159/// converted to bool. 4160void Sema::AddBuiltinCandidate(QualType ResultTy, QualType *ParamTys, 4161 Expr **Args, unsigned NumArgs, 4162 OverloadCandidateSet& CandidateSet, 4163 bool IsAssignmentOperator, 4164 unsigned NumContextualBoolArguments) { 4165 // Overload resolution is always an unevaluated context. 4166 EnterExpressionEvaluationContext Unevaluated(*this, Sema::Unevaluated); 4167 4168 // Add this candidate 4169 CandidateSet.push_back(OverloadCandidate()); 4170 OverloadCandidate& Candidate = CandidateSet.back(); 4171 Candidate.FoundDecl = DeclAccessPair::make(0, AS_none); 4172 Candidate.Function = 0; 4173 Candidate.IsSurrogate = false; 4174 Candidate.IgnoreObjectArgument = false; 4175 Candidate.BuiltinTypes.ResultTy = ResultTy; 4176 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) 4177 Candidate.BuiltinTypes.ParamTypes[ArgIdx] = ParamTys[ArgIdx]; 4178 4179 // Determine the implicit conversion sequences for each of the 4180 // arguments. 4181 Candidate.Viable = true; 4182 Candidate.Conversions.resize(NumArgs); 4183 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 4184 // C++ [over.match.oper]p4: 4185 // For the built-in assignment operators, conversions of the 4186 // left operand are restricted as follows: 4187 // -- no temporaries are introduced to hold the left operand, and 4188 // -- no user-defined conversions are applied to the left 4189 // operand to achieve a type match with the left-most 4190 // parameter of a built-in candidate. 4191 // 4192 // We block these conversions by turning off user-defined 4193 // conversions, since that is the only way that initialization of 4194 // a reference to a non-class type can occur from something that 4195 // is not of the same type. 4196 if (ArgIdx < NumContextualBoolArguments) { 4197 assert(ParamTys[ArgIdx] == Context.BoolTy && 4198 "Contextual conversion to bool requires bool type"); 4199 Candidate.Conversions[ArgIdx] 4200 = TryContextuallyConvertToBool(*this, Args[ArgIdx]); 4201 } else { 4202 Candidate.Conversions[ArgIdx] 4203 = TryCopyInitialization(*this, Args[ArgIdx], ParamTys[ArgIdx], 4204 ArgIdx == 0 && IsAssignmentOperator, 4205 /*InOverloadResolution=*/false); 4206 } 4207 if (Candidate.Conversions[ArgIdx].isBad()) { 4208 Candidate.Viable = false; 4209 Candidate.FailureKind = ovl_fail_bad_conversion; 4210 break; 4211 } 4212 } 4213} 4214 4215/// BuiltinCandidateTypeSet - A set of types that will be used for the 4216/// candidate operator functions for built-in operators (C++ 4217/// [over.built]). The types are separated into pointer types and 4218/// enumeration types. 4219class BuiltinCandidateTypeSet { 4220 /// TypeSet - A set of types. 4221 typedef llvm::SmallPtrSet<QualType, 8> TypeSet; 4222 4223 /// PointerTypes - The set of pointer types that will be used in the 4224 /// built-in candidates. 4225 TypeSet PointerTypes; 4226 4227 /// MemberPointerTypes - The set of member pointer types that will be 4228 /// used in the built-in candidates. 4229 TypeSet MemberPointerTypes; 4230 4231 /// EnumerationTypes - The set of enumeration types that will be 4232 /// used in the built-in candidates. 4233 TypeSet EnumerationTypes; 4234 4235 /// \brief The set of vector types that will be used in the built-in 4236 /// candidates. 4237 TypeSet VectorTypes; 4238 4239 /// Sema - The semantic analysis instance where we are building the 4240 /// candidate type set. 4241 Sema &SemaRef; 4242 4243 /// Context - The AST context in which we will build the type sets. 4244 ASTContext &Context; 4245 4246 bool AddPointerWithMoreQualifiedTypeVariants(QualType Ty, 4247 const Qualifiers &VisibleQuals); 4248 bool AddMemberPointerWithMoreQualifiedTypeVariants(QualType Ty); 4249 4250public: 4251 /// iterator - Iterates through the types that are part of the set. 4252 typedef TypeSet::iterator iterator; 4253 4254 BuiltinCandidateTypeSet(Sema &SemaRef) 4255 : SemaRef(SemaRef), Context(SemaRef.Context) { } 4256 4257 void AddTypesConvertedFrom(QualType Ty, 4258 SourceLocation Loc, 4259 bool AllowUserConversions, 4260 bool AllowExplicitConversions, 4261 const Qualifiers &VisibleTypeConversionsQuals); 4262 4263 /// pointer_begin - First pointer type found; 4264 iterator pointer_begin() { return PointerTypes.begin(); } 4265 4266 /// pointer_end - Past the last pointer type found; 4267 iterator pointer_end() { return PointerTypes.end(); } 4268 4269 /// member_pointer_begin - First member pointer type found; 4270 iterator member_pointer_begin() { return MemberPointerTypes.begin(); } 4271 4272 /// member_pointer_end - Past the last member pointer type found; 4273 iterator member_pointer_end() { return MemberPointerTypes.end(); } 4274 4275 /// enumeration_begin - First enumeration type found; 4276 iterator enumeration_begin() { return EnumerationTypes.begin(); } 4277 4278 /// enumeration_end - Past the last enumeration type found; 4279 iterator enumeration_end() { return EnumerationTypes.end(); } 4280 4281 iterator vector_begin() { return VectorTypes.begin(); } 4282 iterator vector_end() { return VectorTypes.end(); } 4283}; 4284 4285/// AddPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty to 4286/// the set of pointer types along with any more-qualified variants of 4287/// that type. For example, if @p Ty is "int const *", this routine 4288/// will add "int const *", "int const volatile *", "int const 4289/// restrict *", and "int const volatile restrict *" to the set of 4290/// pointer types. Returns true if the add of @p Ty itself succeeded, 4291/// false otherwise. 4292/// 4293/// FIXME: what to do about extended qualifiers? 4294bool 4295BuiltinCandidateTypeSet::AddPointerWithMoreQualifiedTypeVariants(QualType Ty, 4296 const Qualifiers &VisibleQuals) { 4297 4298 // Insert this type. 4299 if (!PointerTypes.insert(Ty)) 4300 return false; 4301 4302 QualType PointeeTy; 4303 const PointerType *PointerTy = Ty->getAs<PointerType>(); 4304 bool buildObjCPtr = false; 4305 if (!PointerTy) { 4306 if (const ObjCObjectPointerType *PTy = Ty->getAs<ObjCObjectPointerType>()) { 4307 PointeeTy = PTy->getPointeeType(); 4308 buildObjCPtr = true; 4309 } 4310 else 4311 assert(false && "type was not a pointer type!"); 4312 } 4313 else 4314 PointeeTy = PointerTy->getPointeeType(); 4315 4316 // Don't add qualified variants of arrays. For one, they're not allowed 4317 // (the qualifier would sink to the element type), and for another, the 4318 // only overload situation where it matters is subscript or pointer +- int, 4319 // and those shouldn't have qualifier variants anyway. 4320 if (PointeeTy->isArrayType()) 4321 return true; 4322 unsigned BaseCVR = PointeeTy.getCVRQualifiers(); 4323 if (const ConstantArrayType *Array =Context.getAsConstantArrayType(PointeeTy)) 4324 BaseCVR = Array->getElementType().getCVRQualifiers(); 4325 bool hasVolatile = VisibleQuals.hasVolatile(); 4326 bool hasRestrict = VisibleQuals.hasRestrict(); 4327 4328 // Iterate through all strict supersets of BaseCVR. 4329 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) { 4330 if ((CVR | BaseCVR) != CVR) continue; 4331 // Skip over Volatile/Restrict if no Volatile/Restrict found anywhere 4332 // in the types. 4333 if ((CVR & Qualifiers::Volatile) && !hasVolatile) continue; 4334 if ((CVR & Qualifiers::Restrict) && !hasRestrict) continue; 4335 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR); 4336 if (!buildObjCPtr) 4337 PointerTypes.insert(Context.getPointerType(QPointeeTy)); 4338 else 4339 PointerTypes.insert(Context.getObjCObjectPointerType(QPointeeTy)); 4340 } 4341 4342 return true; 4343} 4344 4345/// AddMemberPointerWithMoreQualifiedTypeVariants - Add the pointer type @p Ty 4346/// to the set of pointer types along with any more-qualified variants of 4347/// that type. For example, if @p Ty is "int const *", this routine 4348/// will add "int const *", "int const volatile *", "int const 4349/// restrict *", and "int const volatile restrict *" to the set of 4350/// pointer types. Returns true if the add of @p Ty itself succeeded, 4351/// false otherwise. 4352/// 4353/// FIXME: what to do about extended qualifiers? 4354bool 4355BuiltinCandidateTypeSet::AddMemberPointerWithMoreQualifiedTypeVariants( 4356 QualType Ty) { 4357 // Insert this type. 4358 if (!MemberPointerTypes.insert(Ty)) 4359 return false; 4360 4361 const MemberPointerType *PointerTy = Ty->getAs<MemberPointerType>(); 4362 assert(PointerTy && "type was not a member pointer type!"); 4363 4364 QualType PointeeTy = PointerTy->getPointeeType(); 4365 // Don't add qualified variants of arrays. For one, they're not allowed 4366 // (the qualifier would sink to the element type), and for another, the 4367 // only overload situation where it matters is subscript or pointer +- int, 4368 // and those shouldn't have qualifier variants anyway. 4369 if (PointeeTy->isArrayType()) 4370 return true; 4371 const Type *ClassTy = PointerTy->getClass(); 4372 4373 // Iterate through all strict supersets of the pointee type's CVR 4374 // qualifiers. 4375 unsigned BaseCVR = PointeeTy.getCVRQualifiers(); 4376 for (unsigned CVR = BaseCVR+1; CVR <= Qualifiers::CVRMask; ++CVR) { 4377 if ((CVR | BaseCVR) != CVR) continue; 4378 4379 QualType QPointeeTy = Context.getCVRQualifiedType(PointeeTy, CVR); 4380 MemberPointerTypes.insert(Context.getMemberPointerType(QPointeeTy, ClassTy)); 4381 } 4382 4383 return true; 4384} 4385 4386/// AddTypesConvertedFrom - Add each of the types to which the type @p 4387/// Ty can be implicit converted to the given set of @p Types. We're 4388/// primarily interested in pointer types and enumeration types. We also 4389/// take member pointer types, for the conditional operator. 4390/// AllowUserConversions is true if we should look at the conversion 4391/// functions of a class type, and AllowExplicitConversions if we 4392/// should also include the explicit conversion functions of a class 4393/// type. 4394void 4395BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty, 4396 SourceLocation Loc, 4397 bool AllowUserConversions, 4398 bool AllowExplicitConversions, 4399 const Qualifiers &VisibleQuals) { 4400 // Only deal with canonical types. 4401 Ty = Context.getCanonicalType(Ty); 4402 4403 // Look through reference types; they aren't part of the type of an 4404 // expression for the purposes of conversions. 4405 if (const ReferenceType *RefTy = Ty->getAs<ReferenceType>()) 4406 Ty = RefTy->getPointeeType(); 4407 4408 // We don't care about qualifiers on the type. 4409 Ty = Ty.getLocalUnqualifiedType(); 4410 4411 // If we're dealing with an array type, decay to the pointer. 4412 if (Ty->isArrayType()) 4413 Ty = SemaRef.Context.getArrayDecayedType(Ty); 4414 if (Ty->isObjCIdType() || Ty->isObjCClassType()) 4415 PointerTypes.insert(Ty); 4416 else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) { 4417 // Insert our type, and its more-qualified variants, into the set 4418 // of types. 4419 if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals)) 4420 return; 4421 } else if (Ty->isMemberPointerType()) { 4422 // Member pointers are far easier, since the pointee can't be converted. 4423 if (!AddMemberPointerWithMoreQualifiedTypeVariants(Ty)) 4424 return; 4425 } else if (Ty->isEnumeralType()) { 4426 EnumerationTypes.insert(Ty); 4427 } else if (Ty->isVectorType()) { 4428 VectorTypes.insert(Ty); 4429 } else if (AllowUserConversions) { 4430 if (const RecordType *TyRec = Ty->getAs<RecordType>()) { 4431 if (SemaRef.RequireCompleteType(Loc, Ty, 0)) { 4432 // No conversion functions in incomplete types. 4433 return; 4434 } 4435 4436 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl()); 4437 const UnresolvedSetImpl *Conversions 4438 = ClassDecl->getVisibleConversionFunctions(); 4439 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 4440 E = Conversions->end(); I != E; ++I) { 4441 NamedDecl *D = I.getDecl(); 4442 if (isa<UsingShadowDecl>(D)) 4443 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 4444 4445 // Skip conversion function templates; they don't tell us anything 4446 // about which builtin types we can convert to. 4447 if (isa<FunctionTemplateDecl>(D)) 4448 continue; 4449 4450 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 4451 if (AllowExplicitConversions || !Conv->isExplicit()) { 4452 AddTypesConvertedFrom(Conv->getConversionType(), Loc, false, false, 4453 VisibleQuals); 4454 } 4455 } 4456 } 4457 } 4458} 4459 4460/// \brief Helper function for AddBuiltinOperatorCandidates() that adds 4461/// the volatile- and non-volatile-qualified assignment operators for the 4462/// given type to the candidate set. 4463static void AddBuiltinAssignmentOperatorCandidates(Sema &S, 4464 QualType T, 4465 Expr **Args, 4466 unsigned NumArgs, 4467 OverloadCandidateSet &CandidateSet) { 4468 QualType ParamTypes[2]; 4469 4470 // T& operator=(T&, T) 4471 ParamTypes[0] = S.Context.getLValueReferenceType(T); 4472 ParamTypes[1] = T; 4473 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 4474 /*IsAssignmentOperator=*/true); 4475 4476 if (!S.Context.getCanonicalType(T).isVolatileQualified()) { 4477 // volatile T& operator=(volatile T&, T) 4478 ParamTypes[0] 4479 = S.Context.getLValueReferenceType(S.Context.getVolatileType(T)); 4480 ParamTypes[1] = T; 4481 S.AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 4482 /*IsAssignmentOperator=*/true); 4483 } 4484} 4485 4486/// CollectVRQualifiers - This routine returns Volatile/Restrict qualifiers, 4487/// if any, found in visible type conversion functions found in ArgExpr's type. 4488static Qualifiers CollectVRQualifiers(ASTContext &Context, Expr* ArgExpr) { 4489 Qualifiers VRQuals; 4490 const RecordType *TyRec; 4491 if (const MemberPointerType *RHSMPType = 4492 ArgExpr->getType()->getAs<MemberPointerType>()) 4493 TyRec = RHSMPType->getClass()->getAs<RecordType>(); 4494 else 4495 TyRec = ArgExpr->getType()->getAs<RecordType>(); 4496 if (!TyRec) { 4497 // Just to be safe, assume the worst case. 4498 VRQuals.addVolatile(); 4499 VRQuals.addRestrict(); 4500 return VRQuals; 4501 } 4502 4503 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(TyRec->getDecl()); 4504 if (!ClassDecl->hasDefinition()) 4505 return VRQuals; 4506 4507 const UnresolvedSetImpl *Conversions = 4508 ClassDecl->getVisibleConversionFunctions(); 4509 4510 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 4511 E = Conversions->end(); I != E; ++I) { 4512 NamedDecl *D = I.getDecl(); 4513 if (isa<UsingShadowDecl>(D)) 4514 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 4515 if (CXXConversionDecl *Conv = dyn_cast<CXXConversionDecl>(D)) { 4516 QualType CanTy = Context.getCanonicalType(Conv->getConversionType()); 4517 if (const ReferenceType *ResTypeRef = CanTy->getAs<ReferenceType>()) 4518 CanTy = ResTypeRef->getPointeeType(); 4519 // Need to go down the pointer/mempointer chain and add qualifiers 4520 // as see them. 4521 bool done = false; 4522 while (!done) { 4523 if (const PointerType *ResTypePtr = CanTy->getAs<PointerType>()) 4524 CanTy = ResTypePtr->getPointeeType(); 4525 else if (const MemberPointerType *ResTypeMPtr = 4526 CanTy->getAs<MemberPointerType>()) 4527 CanTy = ResTypeMPtr->getPointeeType(); 4528 else 4529 done = true; 4530 if (CanTy.isVolatileQualified()) 4531 VRQuals.addVolatile(); 4532 if (CanTy.isRestrictQualified()) 4533 VRQuals.addRestrict(); 4534 if (VRQuals.hasRestrict() && VRQuals.hasVolatile()) 4535 return VRQuals; 4536 } 4537 } 4538 } 4539 return VRQuals; 4540} 4541 4542 4543/// AddBuiltinOperatorCandidates - Add the appropriate built-in 4544/// operator overloads to the candidate set (C++ [over.built]), based 4545/// on the operator @p Op and the arguments given. For example, if the 4546/// operator is a binary '+', this routine might add "int 4547/// operator+(int, int)" to cover integer addition. 4548void 4549Sema::AddBuiltinOperatorCandidates(OverloadedOperatorKind Op, 4550 SourceLocation OpLoc, 4551 Expr **Args, unsigned NumArgs, 4552 OverloadCandidateSet& CandidateSet) { 4553 // Information about arithmetic types useful to builtin-type 4554 // calculations. 4555 4556 // The "promoted arithmetic types" are the arithmetic 4557 // types are that preserved by promotion (C++ [over.built]p2). 4558 4559 static const unsigned FirstIntegralType = 3; 4560 static const unsigned LastIntegralType = 18; 4561 static const unsigned FirstPromotedIntegralType = 3, 4562 LastPromotedIntegralType = 9; 4563 static const unsigned FirstPromotedArithmeticType = 0, 4564 LastPromotedArithmeticType = 9; 4565 static const unsigned NumArithmeticTypes = 18; 4566 4567 static CanQualType ASTContext::* const ArithmeticTypes[NumArithmeticTypes] = { 4568 // Start of promoted types. 4569 &ASTContext::FloatTy, 4570 &ASTContext::DoubleTy, 4571 &ASTContext::LongDoubleTy, 4572 4573 // Start of integral types. 4574 &ASTContext::IntTy, 4575 &ASTContext::LongTy, 4576 &ASTContext::LongLongTy, 4577 &ASTContext::UnsignedIntTy, 4578 &ASTContext::UnsignedLongTy, 4579 &ASTContext::UnsignedLongLongTy, 4580 // End of promoted types. 4581 4582 &ASTContext::BoolTy, 4583 &ASTContext::CharTy, 4584 &ASTContext::WCharTy, 4585 &ASTContext::Char16Ty, 4586 &ASTContext::Char32Ty, 4587 &ASTContext::SignedCharTy, 4588 &ASTContext::ShortTy, 4589 &ASTContext::UnsignedCharTy, 4590 &ASTContext::UnsignedShortTy 4591 // End of integral types. 4592 }; 4593 // FIXME: What about complex? 4594 assert(ArithmeticTypes[FirstPromotedIntegralType] == &ASTContext::IntTy && 4595 "Invalid first promoted integral type"); 4596 assert(ArithmeticTypes[LastPromotedIntegralType - 1] 4597 == &ASTContext::UnsignedLongLongTy && 4598 "Invalid last promoted integral type"); 4599 assert(ArithmeticTypes[FirstPromotedArithmeticType] == &ASTContext::FloatTy && 4600 "Invalid first promoted arithmetic type"); 4601 assert(ArithmeticTypes[LastPromotedArithmeticType - 1] 4602 == &ASTContext::UnsignedLongLongTy && 4603 "Invalid last promoted arithmetic type"); 4604 4605 // Accelerator table for performing the usual arithmetic conversions. 4606 // The rules are basically: 4607 // - if either is floating-point, use the wider floating-point 4608 // - if same signedness, use the higher rank 4609 // - if same size, use unsigned of the higher rank 4610 // - use the larger type 4611 // These rules, together with the axiom that higher ranks are 4612 // never smaller, are sufficient to precompute all of these results 4613 // *except* when dealing with signed types of higher rank. 4614 // (we could precompute SLL x UI for all known platforms, but it's 4615 // better not to make any assumptions). 4616 enum PromT { Flt, Dbl, LDbl, SI, SL, SLL, UI, UL, ULL, Dep=-1 }; 4617 static PromT UsualArithmeticConversionsTypes 4618 [LastPromotedArithmeticType][LastPromotedArithmeticType] = { 4619 /* Flt*/ { Flt, Dbl, LDbl, Flt, Flt, Flt, Flt, Flt, Flt }, 4620 /* Dbl*/ { Dbl, Dbl, LDbl, Dbl, Dbl, Dbl, Dbl, Dbl, Dbl }, 4621 /*LDbl*/ { LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl, LDbl }, 4622 /* SI*/ { Flt, Dbl, LDbl, SI, SL, SLL, UI, UL, ULL }, 4623 /* SL*/ { Flt, Dbl, LDbl, SL, SL, SLL, Dep, UL, ULL }, 4624 /* SLL*/ { Flt, Dbl, LDbl, SLL, SLL, SLL, Dep, Dep, ULL }, 4625 /* UI*/ { Flt, Dbl, LDbl, UI, Dep, Dep, UI, UL, ULL }, 4626 /* UL*/ { Flt, Dbl, LDbl, UL, UL, Dep, UL, UL, ULL }, 4627 /* ULL*/ { Flt, Dbl, LDbl, ULL, ULL, ULL, ULL, ULL, ULL } 4628 }; 4629 struct UsualArithmeticConversionsType { 4630 static CanQualType find(ASTContext &C, unsigned L, unsigned R) { 4631 assert(L < LastPromotedArithmeticType); 4632 assert(R < LastPromotedArithmeticType); 4633 signed char Idx = UsualArithmeticConversionsTypes[L][R]; 4634 4635 // Fast path: the table gives us a concrete answer. 4636 if (Idx != Dep) return C.*ArithmeticTypes[Idx]; 4637 4638 // Slow path: we need to compare widths. 4639 // An invariant is that the signed type has higher rank. 4640 CanQualType LT = C.*ArithmeticTypes[L], RT = C.*ArithmeticTypes[R]; 4641 unsigned LW = C.getIntWidth(LT), RW = C.getIntWidth(RT); 4642 4643 // If they're different widths, use the signed type. 4644 if (LW > RW) return LT; 4645 else if (LW > RW) return RT; 4646 4647 // Otherwise, use the unsigned type of the signed type's rank. 4648 if (L == SL || R == SL) return C.UnsignedLongTy; 4649 assert(L == SLL || R == SLL); 4650 return C.UnsignedLongLongTy; 4651 } 4652 }; 4653 4654 // Find all of the types that the arguments can convert to, but only 4655 // if the operator we're looking at has built-in operator candidates 4656 // that make use of these types. 4657 Qualifiers VisibleTypeConversionsQuals; 4658 VisibleTypeConversionsQuals.addConst(); 4659 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) 4660 VisibleTypeConversionsQuals += CollectVRQualifiers(Context, Args[ArgIdx]); 4661 4662 llvm::SmallVector<BuiltinCandidateTypeSet, 2> CandidateTypes; 4663 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 4664 CandidateTypes.push_back(BuiltinCandidateTypeSet(*this)); 4665 CandidateTypes[ArgIdx].AddTypesConvertedFrom(Args[ArgIdx]->getType(), 4666 OpLoc, 4667 true, 4668 (Op == OO_Exclaim || 4669 Op == OO_AmpAmp || 4670 Op == OO_PipePipe), 4671 VisibleTypeConversionsQuals); 4672 } 4673 4674 // C++ [over.built]p1: 4675 // If there is a user-written candidate with the same name and parameter 4676 // types as a built-in candidate operator function, the built-in operator 4677 // function is hidden and is not included in the set of candidate functions. 4678 // 4679 // The text is actually in a note, but if we don't implement it then we end 4680 // up with ambiguities when the user provides an overloaded operator for 4681 // an enumeration type. Note that only enumeration types have this problem, 4682 // so we track which enumeration types we've seen operators for. 4683 llvm::DenseSet<std::pair<CanQualType, CanQualType> > 4684 UserDefinedBinaryOperators; 4685 4686 /// Set of (canonical) types that we've already handled. 4687 llvm::SmallPtrSet<QualType, 8> AddedTypes; 4688 4689 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 4690 if (CandidateTypes[ArgIdx].enumeration_begin() 4691 != CandidateTypes[ArgIdx].enumeration_end()) { 4692 for (OverloadCandidateSet::iterator C = CandidateSet.begin(), 4693 CEnd = CandidateSet.end(); 4694 C != CEnd; ++C) { 4695 if (!C->Viable || !C->Function || C->Function->getNumParams() != 2) 4696 continue; 4697 4698 // Check if the first parameter is of enumeration type. 4699 QualType FirstParamType 4700 = C->Function->getParamDecl(0)->getType().getUnqualifiedType(); 4701 if (!FirstParamType->isEnumeralType()) 4702 continue; 4703 4704 // Check if the second parameter is of enumeration type. 4705 QualType SecondParamType 4706 = C->Function->getParamDecl(1)->getType().getUnqualifiedType(); 4707 if (!SecondParamType->isEnumeralType()) 4708 continue; 4709 4710 // Add this operator to the set of known user-defined operators. 4711 UserDefinedBinaryOperators.insert( 4712 std::make_pair(Context.getCanonicalType(FirstParamType), 4713 Context.getCanonicalType(SecondParamType))); 4714 } 4715 } 4716 } 4717 4718 bool isComparison = false; 4719 switch (Op) { 4720 case OO_None: 4721 case NUM_OVERLOADED_OPERATORS: 4722 assert(false && "Expected an overloaded operator"); 4723 break; 4724 4725 case OO_Star: // '*' is either unary or binary 4726 if (NumArgs == 1) 4727 goto UnaryStar; 4728 else 4729 goto BinaryStar; 4730 break; 4731 4732 case OO_Plus: // '+' is either unary or binary 4733 if (NumArgs == 1) 4734 goto UnaryPlus; 4735 else 4736 goto BinaryPlus; 4737 break; 4738 4739 case OO_Minus: // '-' is either unary or binary 4740 if (NumArgs == 1) 4741 goto UnaryMinus; 4742 else 4743 goto BinaryMinus; 4744 break; 4745 4746 case OO_Amp: // '&' is either unary or binary 4747 if (NumArgs == 1) 4748 goto UnaryAmp; 4749 else 4750 goto BinaryAmp; 4751 4752 case OO_PlusPlus: 4753 case OO_MinusMinus: 4754 // C++ [over.built]p3: 4755 // 4756 // For every pair (T, VQ), where T is an arithmetic type, and VQ 4757 // is either volatile or empty, there exist candidate operator 4758 // functions of the form 4759 // 4760 // VQ T& operator++(VQ T&); 4761 // T operator++(VQ T&, int); 4762 // 4763 // C++ [over.built]p4: 4764 // 4765 // For every pair (T, VQ), where T is an arithmetic type other 4766 // than bool, and VQ is either volatile or empty, there exist 4767 // candidate operator functions of the form 4768 // 4769 // VQ T& operator--(VQ T&); 4770 // T operator--(VQ T&, int); 4771 for (unsigned Arith = (Op == OO_PlusPlus? 0 : 1); 4772 Arith < NumArithmeticTypes; ++Arith) { 4773 QualType ArithTy = Context.*ArithmeticTypes[Arith]; 4774 QualType ParamTypes[2] 4775 = { Context.getLValueReferenceType(ArithTy), Context.IntTy }; 4776 4777 // Non-volatile version. 4778 if (NumArgs == 1) 4779 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet); 4780 else 4781 AddBuiltinCandidate(ArithTy, ParamTypes, Args, 2, CandidateSet); 4782 // heuristic to reduce number of builtin candidates in the set. 4783 // Add volatile version only if there are conversions to a volatile type. 4784 if (VisibleTypeConversionsQuals.hasVolatile()) { 4785 // Volatile version 4786 ParamTypes[0] 4787 = Context.getLValueReferenceType(Context.getVolatileType(ArithTy)); 4788 if (NumArgs == 1) 4789 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet); 4790 else 4791 AddBuiltinCandidate(ArithTy, ParamTypes, Args, 2, CandidateSet); 4792 } 4793 } 4794 4795 // C++ [over.built]p5: 4796 // 4797 // For every pair (T, VQ), where T is a cv-qualified or 4798 // cv-unqualified object type, and VQ is either volatile or 4799 // empty, there exist candidate operator functions of the form 4800 // 4801 // T*VQ& operator++(T*VQ&); 4802 // T*VQ& operator--(T*VQ&); 4803 // T* operator++(T*VQ&, int); 4804 // T* operator--(T*VQ&, int); 4805 for (BuiltinCandidateTypeSet::iterator 4806 Ptr = CandidateTypes[0].pointer_begin(), 4807 PtrEnd = CandidateTypes[0].pointer_end(); 4808 Ptr != PtrEnd; ++Ptr) { 4809 // Skip pointer types that aren't pointers to object types. 4810 if (!(*Ptr)->getPointeeType()->isIncompleteOrObjectType()) 4811 continue; 4812 4813 QualType ParamTypes[2] = { 4814 Context.getLValueReferenceType(*Ptr), Context.IntTy 4815 }; 4816 4817 // Without volatile 4818 if (NumArgs == 1) 4819 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet); 4820 else 4821 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet); 4822 4823 if (!Context.getCanonicalType(*Ptr).isVolatileQualified() && 4824 VisibleTypeConversionsQuals.hasVolatile()) { 4825 // With volatile 4826 ParamTypes[0] 4827 = Context.getLValueReferenceType(Context.getVolatileType(*Ptr)); 4828 if (NumArgs == 1) 4829 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 1, CandidateSet); 4830 else 4831 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet); 4832 } 4833 } 4834 break; 4835 4836 UnaryStar: 4837 // C++ [over.built]p6: 4838 // For every cv-qualified or cv-unqualified object type T, there 4839 // exist candidate operator functions of the form 4840 // 4841 // T& operator*(T*); 4842 // 4843 // C++ [over.built]p7: 4844 // For every function type T, there exist candidate operator 4845 // functions of the form 4846 // T& operator*(T*); 4847 for (BuiltinCandidateTypeSet::iterator 4848 Ptr = CandidateTypes[0].pointer_begin(), 4849 PtrEnd = CandidateTypes[0].pointer_end(); 4850 Ptr != PtrEnd; ++Ptr) { 4851 QualType ParamTy = *Ptr; 4852 QualType PointeeTy = ParamTy->getPointeeType(); 4853 AddBuiltinCandidate(Context.getLValueReferenceType(PointeeTy), 4854 &ParamTy, Args, 1, CandidateSet); 4855 } 4856 break; 4857 4858 UnaryPlus: 4859 // C++ [over.built]p8: 4860 // For every type T, there exist candidate operator functions of 4861 // the form 4862 // 4863 // T* operator+(T*); 4864 for (BuiltinCandidateTypeSet::iterator 4865 Ptr = CandidateTypes[0].pointer_begin(), 4866 PtrEnd = CandidateTypes[0].pointer_end(); 4867 Ptr != PtrEnd; ++Ptr) { 4868 QualType ParamTy = *Ptr; 4869 AddBuiltinCandidate(ParamTy, &ParamTy, Args, 1, CandidateSet); 4870 } 4871 4872 // Fall through 4873 4874 UnaryMinus: 4875 // C++ [over.built]p9: 4876 // For every promoted arithmetic type T, there exist candidate 4877 // operator functions of the form 4878 // 4879 // T operator+(T); 4880 // T operator-(T); 4881 for (unsigned Arith = FirstPromotedArithmeticType; 4882 Arith < LastPromotedArithmeticType; ++Arith) { 4883 QualType ArithTy = Context.*ArithmeticTypes[Arith]; 4884 AddBuiltinCandidate(ArithTy, &ArithTy, Args, 1, CandidateSet); 4885 } 4886 4887 // Extension: We also add these operators for vector types. 4888 for (BuiltinCandidateTypeSet::iterator 4889 Vec = CandidateTypes[0].vector_begin(), 4890 VecEnd = CandidateTypes[0].vector_end(); 4891 Vec != VecEnd; ++Vec) { 4892 QualType VecTy = *Vec; 4893 AddBuiltinCandidate(VecTy, &VecTy, Args, 1, CandidateSet); 4894 } 4895 break; 4896 4897 case OO_Tilde: 4898 // C++ [over.built]p10: 4899 // For every promoted integral type T, there exist candidate 4900 // operator functions of the form 4901 // 4902 // T operator~(T); 4903 for (unsigned Int = FirstPromotedIntegralType; 4904 Int < LastPromotedIntegralType; ++Int) { 4905 QualType IntTy = Context.*ArithmeticTypes[Int]; 4906 AddBuiltinCandidate(IntTy, &IntTy, Args, 1, CandidateSet); 4907 } 4908 4909 // Extension: We also add this operator for vector types. 4910 for (BuiltinCandidateTypeSet::iterator 4911 Vec = CandidateTypes[0].vector_begin(), 4912 VecEnd = CandidateTypes[0].vector_end(); 4913 Vec != VecEnd; ++Vec) { 4914 QualType VecTy = *Vec; 4915 AddBuiltinCandidate(VecTy, &VecTy, Args, 1, CandidateSet); 4916 } 4917 break; 4918 4919 case OO_New: 4920 case OO_Delete: 4921 case OO_Array_New: 4922 case OO_Array_Delete: 4923 case OO_Call: 4924 assert(false && "Special operators don't use AddBuiltinOperatorCandidates"); 4925 break; 4926 4927 case OO_Comma: 4928 UnaryAmp: 4929 case OO_Arrow: 4930 // C++ [over.match.oper]p3: 4931 // -- For the operator ',', the unary operator '&', or the 4932 // operator '->', the built-in candidates set is empty. 4933 break; 4934 4935 case OO_EqualEqual: 4936 case OO_ExclaimEqual: 4937 // C++ [over.match.oper]p16: 4938 // For every pointer to member type T, there exist candidate operator 4939 // functions of the form 4940 // 4941 // bool operator==(T,T); 4942 // bool operator!=(T,T); 4943 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 4944 for (BuiltinCandidateTypeSet::iterator 4945 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(), 4946 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end(); 4947 MemPtr != MemPtrEnd; 4948 ++MemPtr) { 4949 // Don't add the same builtin candidate twice. 4950 if (!AddedTypes.insert(Context.getCanonicalType(*MemPtr))) 4951 continue; 4952 4953 QualType ParamTypes[2] = { *MemPtr, *MemPtr }; 4954 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet); 4955 } 4956 } 4957 AddedTypes.clear(); 4958 4959 // Fall through 4960 4961 case OO_Less: 4962 case OO_Greater: 4963 case OO_LessEqual: 4964 case OO_GreaterEqual: 4965 // C++ [over.built]p15: 4966 // 4967 // For every pointer or enumeration type T, there exist 4968 // candidate operator functions of the form 4969 // 4970 // bool operator<(T, T); 4971 // bool operator>(T, T); 4972 // bool operator<=(T, T); 4973 // bool operator>=(T, T); 4974 // bool operator==(T, T); 4975 // bool operator!=(T, T); 4976 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 4977 for (BuiltinCandidateTypeSet::iterator 4978 Ptr = CandidateTypes[ArgIdx].pointer_begin(), 4979 PtrEnd = CandidateTypes[ArgIdx].pointer_end(); 4980 Ptr != PtrEnd; ++Ptr) { 4981 // Don't add the same builtin candidate twice. 4982 if (!AddedTypes.insert(Context.getCanonicalType(*Ptr))) 4983 continue; 4984 4985 QualType ParamTypes[2] = { *Ptr, *Ptr }; 4986 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet); 4987 } 4988 for (BuiltinCandidateTypeSet::iterator 4989 Enum = CandidateTypes[ArgIdx].enumeration_begin(), 4990 EnumEnd = CandidateTypes[ArgIdx].enumeration_end(); 4991 Enum != EnumEnd; ++Enum) { 4992 // Don't add the same builtin candidate twice. 4993 if (!AddedTypes.insert(Context.getCanonicalType(*Enum))) 4994 continue; 4995 4996 QualType ParamTypes[2] = { *Enum, *Enum }; 4997 CanQualType CanonType = Context.getCanonicalType(*Enum); 4998 if (!UserDefinedBinaryOperators.count( 4999 std::make_pair(CanonType, CanonType))) 5000 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet); 5001 } 5002 } 5003 AddedTypes.clear(); 5004 5005 // Fall through. 5006 isComparison = true; 5007 5008 BinaryPlus: 5009 BinaryMinus: 5010 if (!isComparison) { 5011 // We didn't fall through, so we must have OO_Plus or OO_Minus. 5012 5013 // C++ [over.built]p13: 5014 // 5015 // For every cv-qualified or cv-unqualified object type T 5016 // there exist candidate operator functions of the form 5017 // 5018 // T* operator+(T*, ptrdiff_t); 5019 // T& operator[](T*, ptrdiff_t); [BELOW] 5020 // T* operator-(T*, ptrdiff_t); 5021 // T* operator+(ptrdiff_t, T*); 5022 // T& operator[](ptrdiff_t, T*); [BELOW] 5023 // 5024 // C++ [over.built]p14: 5025 // 5026 // For every T, where T is a pointer to object type, there 5027 // exist candidate operator functions of the form 5028 // 5029 // ptrdiff_t operator-(T, T); 5030 for (BuiltinCandidateTypeSet::iterator 5031 Ptr = CandidateTypes[0].pointer_begin(), 5032 PtrEnd = CandidateTypes[0].pointer_end(); 5033 Ptr != PtrEnd; ++Ptr) { 5034 QualType ParamTypes[2] = { *Ptr, Context.getPointerDiffType() }; 5035 5036 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t) 5037 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet); 5038 5039 if (Op == OO_Minus) { 5040 // ptrdiff_t operator-(T, T); 5041 if (!AddedTypes.insert(Context.getCanonicalType(*Ptr))) 5042 continue; 5043 5044 ParamTypes[1] = *Ptr; 5045 AddBuiltinCandidate(Context.getPointerDiffType(), ParamTypes, 5046 Args, 2, CandidateSet); 5047 } 5048 } 5049 5050 for (BuiltinCandidateTypeSet::iterator 5051 Ptr = CandidateTypes[1].pointer_begin(), 5052 PtrEnd = CandidateTypes[1].pointer_end(); 5053 Ptr != PtrEnd; ++Ptr) { 5054 if (Op == OO_Plus) { 5055 // T* operator+(ptrdiff_t, T*); 5056 QualType ParamTypes[2] = { Context.getPointerDiffType(), *Ptr }; 5057 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet); 5058 } else { 5059 // ptrdiff_t operator-(T, T); 5060 if (!AddedTypes.insert(Context.getCanonicalType(*Ptr))) 5061 continue; 5062 5063 QualType ParamTypes[2] = { *Ptr, *Ptr }; 5064 AddBuiltinCandidate(Context.getPointerDiffType(), ParamTypes, 5065 Args, 2, CandidateSet); 5066 } 5067 } 5068 5069 AddedTypes.clear(); 5070 } 5071 // Fall through 5072 5073 case OO_Slash: 5074 BinaryStar: 5075 Conditional: 5076 // C++ [over.built]p12: 5077 // 5078 // For every pair of promoted arithmetic types L and R, there 5079 // exist candidate operator functions of the form 5080 // 5081 // LR operator*(L, R); 5082 // LR operator/(L, R); 5083 // LR operator+(L, R); 5084 // LR operator-(L, R); 5085 // bool operator<(L, R); 5086 // bool operator>(L, R); 5087 // bool operator<=(L, R); 5088 // bool operator>=(L, R); 5089 // bool operator==(L, R); 5090 // bool operator!=(L, R); 5091 // 5092 // where LR is the result of the usual arithmetic conversions 5093 // between types L and R. 5094 // 5095 // C++ [over.built]p24: 5096 // 5097 // For every pair of promoted arithmetic types L and R, there exist 5098 // candidate operator functions of the form 5099 // 5100 // LR operator?(bool, L, R); 5101 // 5102 // where LR is the result of the usual arithmetic conversions 5103 // between types L and R. 5104 // Our candidates ignore the first parameter. 5105 for (unsigned Left = FirstPromotedArithmeticType; 5106 Left < LastPromotedArithmeticType; ++Left) { 5107 for (unsigned Right = FirstPromotedArithmeticType; 5108 Right < LastPromotedArithmeticType; ++Right) { 5109 QualType LandR[2] = { Context.*ArithmeticTypes[Left], 5110 Context.*ArithmeticTypes[Right] }; 5111 QualType Result 5112 = isComparison 5113 ? Context.BoolTy 5114 : UsualArithmeticConversionsType::find(Context, Left, Right); 5115 AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet); 5116 } 5117 } 5118 5119 // Extension: Add the binary operators ==, !=, <, <=, >=, >, *, /, and the 5120 // conditional operator for vector types. 5121 for (BuiltinCandidateTypeSet::iterator 5122 Vec1 = CandidateTypes[0].vector_begin(), 5123 Vec1End = CandidateTypes[0].vector_end(); 5124 Vec1 != Vec1End; ++Vec1) 5125 for (BuiltinCandidateTypeSet::iterator 5126 Vec2 = CandidateTypes[1].vector_begin(), 5127 Vec2End = CandidateTypes[1].vector_end(); 5128 Vec2 != Vec2End; ++Vec2) { 5129 QualType LandR[2] = { *Vec1, *Vec2 }; 5130 QualType Result; 5131 if (isComparison) 5132 Result = Context.BoolTy; 5133 else { 5134 if ((*Vec1)->isExtVectorType() || !(*Vec2)->isExtVectorType()) 5135 Result = *Vec1; 5136 else 5137 Result = *Vec2; 5138 } 5139 5140 AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet); 5141 } 5142 5143 break; 5144 5145 case OO_Percent: 5146 BinaryAmp: 5147 case OO_Caret: 5148 case OO_Pipe: 5149 case OO_LessLess: 5150 case OO_GreaterGreater: 5151 // C++ [over.built]p17: 5152 // 5153 // For every pair of promoted integral types L and R, there 5154 // exist candidate operator functions of the form 5155 // 5156 // LR operator%(L, R); 5157 // LR operator&(L, R); 5158 // LR operator^(L, R); 5159 // LR operator|(L, R); 5160 // L operator<<(L, R); 5161 // L operator>>(L, R); 5162 // 5163 // where LR is the result of the usual arithmetic conversions 5164 // between types L and R. 5165 for (unsigned Left = FirstPromotedIntegralType; 5166 Left < LastPromotedIntegralType; ++Left) { 5167 for (unsigned Right = FirstPromotedIntegralType; 5168 Right < LastPromotedIntegralType; ++Right) { 5169 QualType LandR[2] = { Context.*ArithmeticTypes[Left], 5170 Context.*ArithmeticTypes[Right] }; 5171 QualType Result = (Op == OO_LessLess || Op == OO_GreaterGreater) 5172 ? LandR[0] 5173 : UsualArithmeticConversionsType::find(Context, Left, Right); 5174 AddBuiltinCandidate(Result, LandR, Args, 2, CandidateSet); 5175 } 5176 } 5177 break; 5178 5179 case OO_Equal: 5180 // C++ [over.built]p20: 5181 // 5182 // For every pair (T, VQ), where T is an enumeration or 5183 // pointer to member type and VQ is either volatile or 5184 // empty, there exist candidate operator functions of the form 5185 // 5186 // VQ T& operator=(VQ T&, T); 5187 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 5188 for (BuiltinCandidateTypeSet::iterator 5189 Enum = CandidateTypes[ArgIdx].enumeration_begin(), 5190 EnumEnd = CandidateTypes[ArgIdx].enumeration_end(); 5191 Enum != EnumEnd; ++Enum) { 5192 if (!AddedTypes.insert(Context.getCanonicalType(*Enum))) 5193 continue; 5194 5195 AddBuiltinAssignmentOperatorCandidates(*this, *Enum, Args, 2, 5196 CandidateSet); 5197 } 5198 5199 for (BuiltinCandidateTypeSet::iterator 5200 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(), 5201 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end(); 5202 MemPtr != MemPtrEnd; ++MemPtr) { 5203 if (!AddedTypes.insert(Context.getCanonicalType(*MemPtr))) 5204 continue; 5205 5206 AddBuiltinAssignmentOperatorCandidates(*this, *MemPtr, Args, 2, 5207 CandidateSet); 5208 } 5209 } 5210 AddedTypes.clear(); 5211 5212 // Fall through. 5213 5214 case OO_PlusEqual: 5215 case OO_MinusEqual: 5216 // C++ [over.built]p19: 5217 // 5218 // For every pair (T, VQ), where T is any type and VQ is either 5219 // volatile or empty, there exist candidate operator functions 5220 // of the form 5221 // 5222 // T*VQ& operator=(T*VQ&, T*); 5223 // 5224 // C++ [over.built]p21: 5225 // 5226 // For every pair (T, VQ), where T is a cv-qualified or 5227 // cv-unqualified object type and VQ is either volatile or 5228 // empty, there exist candidate operator functions of the form 5229 // 5230 // T*VQ& operator+=(T*VQ&, ptrdiff_t); 5231 // T*VQ& operator-=(T*VQ&, ptrdiff_t); 5232 for (BuiltinCandidateTypeSet::iterator 5233 Ptr = CandidateTypes[0].pointer_begin(), 5234 PtrEnd = CandidateTypes[0].pointer_end(); 5235 Ptr != PtrEnd; ++Ptr) { 5236 QualType ParamTypes[2]; 5237 ParamTypes[1] = (Op == OO_Equal)? *Ptr : Context.getPointerDiffType(); 5238 5239 // If this is operator=, keep track of the builtin candidates we added. 5240 if (Op == OO_Equal) 5241 AddedTypes.insert(Context.getCanonicalType(*Ptr)); 5242 5243 // non-volatile version 5244 ParamTypes[0] = Context.getLValueReferenceType(*Ptr); 5245 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5246 /*IsAssigmentOperator=*/Op == OO_Equal); 5247 5248 if (!Context.getCanonicalType(*Ptr).isVolatileQualified() && 5249 VisibleTypeConversionsQuals.hasVolatile()) { 5250 // volatile version 5251 ParamTypes[0] 5252 = Context.getLValueReferenceType(Context.getVolatileType(*Ptr)); 5253 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5254 /*IsAssigmentOperator=*/Op == OO_Equal); 5255 } 5256 } 5257 5258 if (Op == OO_Equal) { 5259 for (BuiltinCandidateTypeSet::iterator 5260 Ptr = CandidateTypes[1].pointer_begin(), 5261 PtrEnd = CandidateTypes[1].pointer_end(); 5262 Ptr != PtrEnd; ++Ptr) { 5263 // Make sure we don't add the same candidate twice. 5264 if (!AddedTypes.insert(Context.getCanonicalType(*Ptr))) 5265 continue; 5266 5267 QualType ParamTypes[2] = { Context.getLValueReferenceType(*Ptr), *Ptr }; 5268 5269 // non-volatile version 5270 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5271 /*IsAssigmentOperator=*/true); 5272 5273 if (!Context.getCanonicalType(*Ptr).isVolatileQualified() && 5274 VisibleTypeConversionsQuals.hasVolatile()) { 5275 // volatile version 5276 ParamTypes[0] 5277 = Context.getLValueReferenceType(Context.getVolatileType(*Ptr)); 5278 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5279 /*IsAssigmentOperator=*/true); 5280 } 5281 } 5282 AddedTypes.clear(); 5283 } 5284 // Fall through. 5285 5286 case OO_StarEqual: 5287 case OO_SlashEqual: 5288 // C++ [over.built]p18: 5289 // 5290 // For every triple (L, VQ, R), where L is an arithmetic type, 5291 // VQ is either volatile or empty, and R is a promoted 5292 // arithmetic type, there exist candidate operator functions of 5293 // the form 5294 // 5295 // VQ L& operator=(VQ L&, R); 5296 // VQ L& operator*=(VQ L&, R); 5297 // VQ L& operator/=(VQ L&, R); 5298 // VQ L& operator+=(VQ L&, R); 5299 // VQ L& operator-=(VQ L&, R); 5300 for (unsigned Left = 0; Left < NumArithmeticTypes; ++Left) { 5301 for (unsigned Right = FirstPromotedArithmeticType; 5302 Right < LastPromotedArithmeticType; ++Right) { 5303 QualType ParamTypes[2]; 5304 ParamTypes[1] = Context.*ArithmeticTypes[Right]; 5305 5306 // Add this built-in operator as a candidate (VQ is empty). 5307 ParamTypes[0] = 5308 Context.getLValueReferenceType(Context.*ArithmeticTypes[Left]); 5309 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5310 /*IsAssigmentOperator=*/Op == OO_Equal); 5311 5312 // Add this built-in operator as a candidate (VQ is 'volatile'). 5313 if (VisibleTypeConversionsQuals.hasVolatile()) { 5314 ParamTypes[0] = 5315 Context.getVolatileType(Context.*ArithmeticTypes[Left]); 5316 ParamTypes[0] = Context.getLValueReferenceType(ParamTypes[0]); 5317 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5318 /*IsAssigmentOperator=*/Op == OO_Equal); 5319 } 5320 } 5321 } 5322 5323 // Extension: Add the binary operators =, +=, -=, *=, /= for vector types. 5324 for (BuiltinCandidateTypeSet::iterator 5325 Vec1 = CandidateTypes[0].vector_begin(), 5326 Vec1End = CandidateTypes[0].vector_end(); 5327 Vec1 != Vec1End; ++Vec1) 5328 for (BuiltinCandidateTypeSet::iterator 5329 Vec2 = CandidateTypes[1].vector_begin(), 5330 Vec2End = CandidateTypes[1].vector_end(); 5331 Vec2 != Vec2End; ++Vec2) { 5332 QualType ParamTypes[2]; 5333 ParamTypes[1] = *Vec2; 5334 // Add this built-in operator as a candidate (VQ is empty). 5335 ParamTypes[0] = Context.getLValueReferenceType(*Vec1); 5336 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5337 /*IsAssigmentOperator=*/Op == OO_Equal); 5338 5339 // Add this built-in operator as a candidate (VQ is 'volatile'). 5340 if (VisibleTypeConversionsQuals.hasVolatile()) { 5341 ParamTypes[0] = Context.getVolatileType(*Vec1); 5342 ParamTypes[0] = Context.getLValueReferenceType(ParamTypes[0]); 5343 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet, 5344 /*IsAssigmentOperator=*/Op == OO_Equal); 5345 } 5346 } 5347 break; 5348 5349 case OO_PercentEqual: 5350 case OO_LessLessEqual: 5351 case OO_GreaterGreaterEqual: 5352 case OO_AmpEqual: 5353 case OO_CaretEqual: 5354 case OO_PipeEqual: 5355 // C++ [over.built]p22: 5356 // 5357 // For every triple (L, VQ, R), where L is an integral type, VQ 5358 // is either volatile or empty, and R is a promoted integral 5359 // type, there exist candidate operator functions of the form 5360 // 5361 // VQ L& operator%=(VQ L&, R); 5362 // VQ L& operator<<=(VQ L&, R); 5363 // VQ L& operator>>=(VQ L&, R); 5364 // VQ L& operator&=(VQ L&, R); 5365 // VQ L& operator^=(VQ L&, R); 5366 // VQ L& operator|=(VQ L&, R); 5367 for (unsigned Left = FirstIntegralType; Left < LastIntegralType; ++Left) { 5368 for (unsigned Right = FirstPromotedIntegralType; 5369 Right < LastPromotedIntegralType; ++Right) { 5370 QualType ParamTypes[2]; 5371 ParamTypes[1] = Context.*ArithmeticTypes[Right]; 5372 5373 // Add this built-in operator as a candidate (VQ is empty). 5374 ParamTypes[0] = 5375 Context.getLValueReferenceType(Context.*ArithmeticTypes[Left]); 5376 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet); 5377 if (VisibleTypeConversionsQuals.hasVolatile()) { 5378 // Add this built-in operator as a candidate (VQ is 'volatile'). 5379 ParamTypes[0] = Context.*ArithmeticTypes[Left]; 5380 ParamTypes[0] = Context.getVolatileType(ParamTypes[0]); 5381 ParamTypes[0] = Context.getLValueReferenceType(ParamTypes[0]); 5382 AddBuiltinCandidate(ParamTypes[0], ParamTypes, Args, 2, CandidateSet); 5383 } 5384 } 5385 } 5386 break; 5387 5388 case OO_Exclaim: { 5389 // C++ [over.operator]p23: 5390 // 5391 // There also exist candidate operator functions of the form 5392 // 5393 // bool operator!(bool); 5394 // bool operator&&(bool, bool); [BELOW] 5395 // bool operator||(bool, bool); [BELOW] 5396 QualType ParamTy = Context.BoolTy; 5397 AddBuiltinCandidate(ParamTy, &ParamTy, Args, 1, CandidateSet, 5398 /*IsAssignmentOperator=*/false, 5399 /*NumContextualBoolArguments=*/1); 5400 break; 5401 } 5402 5403 case OO_AmpAmp: 5404 case OO_PipePipe: { 5405 // C++ [over.operator]p23: 5406 // 5407 // There also exist candidate operator functions of the form 5408 // 5409 // bool operator!(bool); [ABOVE] 5410 // bool operator&&(bool, bool); 5411 // bool operator||(bool, bool); 5412 QualType ParamTypes[2] = { Context.BoolTy, Context.BoolTy }; 5413 AddBuiltinCandidate(Context.BoolTy, ParamTypes, Args, 2, CandidateSet, 5414 /*IsAssignmentOperator=*/false, 5415 /*NumContextualBoolArguments=*/2); 5416 break; 5417 } 5418 5419 case OO_Subscript: 5420 // C++ [over.built]p13: 5421 // 5422 // For every cv-qualified or cv-unqualified object type T there 5423 // exist candidate operator functions of the form 5424 // 5425 // T* operator+(T*, ptrdiff_t); [ABOVE] 5426 // T& operator[](T*, ptrdiff_t); 5427 // T* operator-(T*, ptrdiff_t); [ABOVE] 5428 // T* operator+(ptrdiff_t, T*); [ABOVE] 5429 // T& operator[](ptrdiff_t, T*); 5430 for (BuiltinCandidateTypeSet::iterator 5431 Ptr = CandidateTypes[0].pointer_begin(), 5432 PtrEnd = CandidateTypes[0].pointer_end(); 5433 Ptr != PtrEnd; ++Ptr) { 5434 QualType ParamTypes[2] = { *Ptr, Context.getPointerDiffType() }; 5435 QualType PointeeType = (*Ptr)->getPointeeType(); 5436 QualType ResultTy = Context.getLValueReferenceType(PointeeType); 5437 5438 // T& operator[](T*, ptrdiff_t) 5439 AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet); 5440 } 5441 5442 for (BuiltinCandidateTypeSet::iterator 5443 Ptr = CandidateTypes[1].pointer_begin(), 5444 PtrEnd = CandidateTypes[1].pointer_end(); 5445 Ptr != PtrEnd; ++Ptr) { 5446 QualType ParamTypes[2] = { Context.getPointerDiffType(), *Ptr }; 5447 QualType PointeeType = (*Ptr)->getPointeeType(); 5448 QualType ResultTy = Context.getLValueReferenceType(PointeeType); 5449 5450 // T& operator[](ptrdiff_t, T*) 5451 AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet); 5452 } 5453 break; 5454 5455 case OO_ArrowStar: 5456 // C++ [over.built]p11: 5457 // For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, 5458 // C1 is the same type as C2 or is a derived class of C2, T is an object 5459 // type or a function type, and CV1 and CV2 are cv-qualifier-seqs, 5460 // there exist candidate operator functions of the form 5461 // 5462 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*); 5463 // 5464 // where CV12 is the union of CV1 and CV2. 5465 { 5466 for (BuiltinCandidateTypeSet::iterator 5467 Ptr = CandidateTypes[0].pointer_begin(), 5468 PtrEnd = CandidateTypes[0].pointer_end(); 5469 Ptr != PtrEnd; ++Ptr) { 5470 QualType C1Ty = (*Ptr); 5471 QualType C1; 5472 QualifierCollector Q1; 5473 C1 = QualType(Q1.strip(C1Ty->getPointeeType()), 0); 5474 if (!isa<RecordType>(C1)) 5475 continue; 5476 // heuristic to reduce number of builtin candidates in the set. 5477 // Add volatile/restrict version only if there are conversions to a 5478 // volatile/restrict type. 5479 if (!VisibleTypeConversionsQuals.hasVolatile() && Q1.hasVolatile()) 5480 continue; 5481 if (!VisibleTypeConversionsQuals.hasRestrict() && Q1.hasRestrict()) 5482 continue; 5483 for (BuiltinCandidateTypeSet::iterator 5484 MemPtr = CandidateTypes[1].member_pointer_begin(), 5485 MemPtrEnd = CandidateTypes[1].member_pointer_end(); 5486 MemPtr != MemPtrEnd; ++MemPtr) { 5487 const MemberPointerType *mptr = cast<MemberPointerType>(*MemPtr); 5488 QualType C2 = QualType(mptr->getClass(), 0); 5489 C2 = C2.getUnqualifiedType(); 5490 if (C1 != C2 && !IsDerivedFrom(C1, C2)) 5491 break; 5492 QualType ParamTypes[2] = { *Ptr, *MemPtr }; 5493 // build CV12 T& 5494 QualType T = mptr->getPointeeType(); 5495 if (!VisibleTypeConversionsQuals.hasVolatile() && 5496 T.isVolatileQualified()) 5497 continue; 5498 if (!VisibleTypeConversionsQuals.hasRestrict() && 5499 T.isRestrictQualified()) 5500 continue; 5501 T = Q1.apply(T); 5502 QualType ResultTy = Context.getLValueReferenceType(T); 5503 AddBuiltinCandidate(ResultTy, ParamTypes, Args, 2, CandidateSet); 5504 } 5505 } 5506 } 5507 break; 5508 5509 case OO_Conditional: 5510 // Note that we don't consider the first argument, since it has been 5511 // contextually converted to bool long ago. The candidates below are 5512 // therefore added as binary. 5513 // 5514 // C++ [over.built]p25: 5515 // For every type T, where T is a pointer, pointer-to-member, or scoped 5516 // enumeration type, there exist candidate operator functions of the form 5517 // 5518 // T operator?(bool, T, T); 5519 // 5520 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) { 5521 for (BuiltinCandidateTypeSet::iterator 5522 Ptr = CandidateTypes[ArgIdx].pointer_begin(), 5523 PtrEnd = CandidateTypes[ArgIdx].pointer_end(); 5524 Ptr != PtrEnd; ++Ptr) { 5525 if (!AddedTypes.insert(Context.getCanonicalType(*Ptr))) 5526 continue; 5527 5528 QualType ParamTypes[2] = { *Ptr, *Ptr }; 5529 AddBuiltinCandidate(*Ptr, ParamTypes, Args, 2, CandidateSet); 5530 } 5531 5532 for (BuiltinCandidateTypeSet::iterator 5533 MemPtr = CandidateTypes[ArgIdx].member_pointer_begin(), 5534 MemPtrEnd = CandidateTypes[ArgIdx].member_pointer_end(); 5535 MemPtr != MemPtrEnd; ++MemPtr) { 5536 if (!AddedTypes.insert(Context.getCanonicalType(*MemPtr))) 5537 continue; 5538 5539 QualType ParamTypes[2] = { *MemPtr, *MemPtr }; 5540 AddBuiltinCandidate(*MemPtr, ParamTypes, Args, 2, CandidateSet); 5541 } 5542 5543 if (getLangOptions().CPlusPlus0x) { 5544 for (BuiltinCandidateTypeSet::iterator 5545 Enum = CandidateTypes[ArgIdx].enumeration_begin(), 5546 EnumEnd = CandidateTypes[ArgIdx].enumeration_end(); 5547 Enum != EnumEnd; ++Enum) { 5548 if (!(*Enum)->getAs<EnumType>()->getDecl()->isScoped()) 5549 continue; 5550 5551 if (!AddedTypes.insert(Context.getCanonicalType(*Enum))) 5552 continue; 5553 5554 QualType ParamTypes[2] = { *Enum, *Enum }; 5555 AddBuiltinCandidate(*Enum, ParamTypes, Args, 2, CandidateSet); 5556 } 5557 } 5558 } 5559 goto Conditional; 5560 } 5561} 5562 5563/// \brief Add function candidates found via argument-dependent lookup 5564/// to the set of overloading candidates. 5565/// 5566/// This routine performs argument-dependent name lookup based on the 5567/// given function name (which may also be an operator name) and adds 5568/// all of the overload candidates found by ADL to the overload 5569/// candidate set (C++ [basic.lookup.argdep]). 5570void 5571Sema::AddArgumentDependentLookupCandidates(DeclarationName Name, 5572 bool Operator, 5573 Expr **Args, unsigned NumArgs, 5574 const TemplateArgumentListInfo *ExplicitTemplateArgs, 5575 OverloadCandidateSet& CandidateSet, 5576 bool PartialOverloading) { 5577 ADLResult Fns; 5578 5579 // FIXME: This approach for uniquing ADL results (and removing 5580 // redundant candidates from the set) relies on pointer-equality, 5581 // which means we need to key off the canonical decl. However, 5582 // always going back to the canonical decl might not get us the 5583 // right set of default arguments. What default arguments are 5584 // we supposed to consider on ADL candidates, anyway? 5585 5586 // FIXME: Pass in the explicit template arguments? 5587 ArgumentDependentLookup(Name, Operator, Args, NumArgs, Fns); 5588 5589 // Erase all of the candidates we already knew about. 5590 for (OverloadCandidateSet::iterator Cand = CandidateSet.begin(), 5591 CandEnd = CandidateSet.end(); 5592 Cand != CandEnd; ++Cand) 5593 if (Cand->Function) { 5594 Fns.erase(Cand->Function); 5595 if (FunctionTemplateDecl *FunTmpl = Cand->Function->getPrimaryTemplate()) 5596 Fns.erase(FunTmpl); 5597 } 5598 5599 // For each of the ADL candidates we found, add it to the overload 5600 // set. 5601 for (ADLResult::iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 5602 DeclAccessPair FoundDecl = DeclAccessPair::make(*I, AS_none); 5603 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 5604 if (ExplicitTemplateArgs) 5605 continue; 5606 5607 AddOverloadCandidate(FD, FoundDecl, Args, NumArgs, CandidateSet, 5608 false, PartialOverloading); 5609 } else 5610 AddTemplateOverloadCandidate(cast<FunctionTemplateDecl>(*I), 5611 FoundDecl, ExplicitTemplateArgs, 5612 Args, NumArgs, CandidateSet); 5613 } 5614} 5615 5616/// isBetterOverloadCandidate - Determines whether the first overload 5617/// candidate is a better candidate than the second (C++ 13.3.3p1). 5618bool 5619isBetterOverloadCandidate(Sema &S, 5620 const OverloadCandidate &Cand1, 5621 const OverloadCandidate &Cand2, 5622 SourceLocation Loc, 5623 bool UserDefinedConversion) { 5624 // Define viable functions to be better candidates than non-viable 5625 // functions. 5626 if (!Cand2.Viable) 5627 return Cand1.Viable; 5628 else if (!Cand1.Viable) 5629 return false; 5630 5631 // C++ [over.match.best]p1: 5632 // 5633 // -- if F is a static member function, ICS1(F) is defined such 5634 // that ICS1(F) is neither better nor worse than ICS1(G) for 5635 // any function G, and, symmetrically, ICS1(G) is neither 5636 // better nor worse than ICS1(F). 5637 unsigned StartArg = 0; 5638 if (Cand1.IgnoreObjectArgument || Cand2.IgnoreObjectArgument) 5639 StartArg = 1; 5640 5641 // C++ [over.match.best]p1: 5642 // A viable function F1 is defined to be a better function than another 5643 // viable function F2 if for all arguments i, ICSi(F1) is not a worse 5644 // conversion sequence than ICSi(F2), and then... 5645 unsigned NumArgs = Cand1.Conversions.size(); 5646 assert(Cand2.Conversions.size() == NumArgs && "Overload candidate mismatch"); 5647 bool HasBetterConversion = false; 5648 for (unsigned ArgIdx = StartArg; ArgIdx < NumArgs; ++ArgIdx) { 5649 switch (CompareImplicitConversionSequences(S, 5650 Cand1.Conversions[ArgIdx], 5651 Cand2.Conversions[ArgIdx])) { 5652 case ImplicitConversionSequence::Better: 5653 // Cand1 has a better conversion sequence. 5654 HasBetterConversion = true; 5655 break; 5656 5657 case ImplicitConversionSequence::Worse: 5658 // Cand1 can't be better than Cand2. 5659 return false; 5660 5661 case ImplicitConversionSequence::Indistinguishable: 5662 // Do nothing. 5663 break; 5664 } 5665 } 5666 5667 // -- for some argument j, ICSj(F1) is a better conversion sequence than 5668 // ICSj(F2), or, if not that, 5669 if (HasBetterConversion) 5670 return true; 5671 5672 // - F1 is a non-template function and F2 is a function template 5673 // specialization, or, if not that, 5674 if ((!Cand1.Function || !Cand1.Function->getPrimaryTemplate()) && 5675 Cand2.Function && Cand2.Function->getPrimaryTemplate()) 5676 return true; 5677 5678 // -- F1 and F2 are function template specializations, and the function 5679 // template for F1 is more specialized than the template for F2 5680 // according to the partial ordering rules described in 14.5.5.2, or, 5681 // if not that, 5682 if (Cand1.Function && Cand1.Function->getPrimaryTemplate() && 5683 Cand2.Function && Cand2.Function->getPrimaryTemplate()) 5684 if (FunctionTemplateDecl *BetterTemplate 5685 = S.getMoreSpecializedTemplate(Cand1.Function->getPrimaryTemplate(), 5686 Cand2.Function->getPrimaryTemplate(), 5687 Loc, 5688 isa<CXXConversionDecl>(Cand1.Function)? TPOC_Conversion 5689 : TPOC_Call)) 5690 return BetterTemplate == Cand1.Function->getPrimaryTemplate(); 5691 5692 // -- the context is an initialization by user-defined conversion 5693 // (see 8.5, 13.3.1.5) and the standard conversion sequence 5694 // from the return type of F1 to the destination type (i.e., 5695 // the type of the entity being initialized) is a better 5696 // conversion sequence than the standard conversion sequence 5697 // from the return type of F2 to the destination type. 5698 if (UserDefinedConversion && Cand1.Function && Cand2.Function && 5699 isa<CXXConversionDecl>(Cand1.Function) && 5700 isa<CXXConversionDecl>(Cand2.Function)) { 5701 switch (CompareStandardConversionSequences(S, 5702 Cand1.FinalConversion, 5703 Cand2.FinalConversion)) { 5704 case ImplicitConversionSequence::Better: 5705 // Cand1 has a better conversion sequence. 5706 return true; 5707 5708 case ImplicitConversionSequence::Worse: 5709 // Cand1 can't be better than Cand2. 5710 return false; 5711 5712 case ImplicitConversionSequence::Indistinguishable: 5713 // Do nothing 5714 break; 5715 } 5716 } 5717 5718 return false; 5719} 5720 5721/// \brief Computes the best viable function (C++ 13.3.3) 5722/// within an overload candidate set. 5723/// 5724/// \param CandidateSet the set of candidate functions. 5725/// 5726/// \param Loc the location of the function name (or operator symbol) for 5727/// which overload resolution occurs. 5728/// 5729/// \param Best f overload resolution was successful or found a deleted 5730/// function, Best points to the candidate function found. 5731/// 5732/// \returns The result of overload resolution. 5733OverloadingResult 5734OverloadCandidateSet::BestViableFunction(Sema &S, SourceLocation Loc, 5735 iterator &Best, 5736 bool UserDefinedConversion) { 5737 // Find the best viable function. 5738 Best = end(); 5739 for (iterator Cand = begin(); Cand != end(); ++Cand) { 5740 if (Cand->Viable) 5741 if (Best == end() || isBetterOverloadCandidate(S, *Cand, *Best, Loc, 5742 UserDefinedConversion)) 5743 Best = Cand; 5744 } 5745 5746 // If we didn't find any viable functions, abort. 5747 if (Best == end()) 5748 return OR_No_Viable_Function; 5749 5750 // Make sure that this function is better than every other viable 5751 // function. If not, we have an ambiguity. 5752 for (iterator Cand = begin(); Cand != end(); ++Cand) { 5753 if (Cand->Viable && 5754 Cand != Best && 5755 !isBetterOverloadCandidate(S, *Best, *Cand, Loc, 5756 UserDefinedConversion)) { 5757 Best = end(); 5758 return OR_Ambiguous; 5759 } 5760 } 5761 5762 // Best is the best viable function. 5763 if (Best->Function && 5764 (Best->Function->isDeleted() || 5765 Best->Function->getAttr<UnavailableAttr>())) 5766 return OR_Deleted; 5767 5768 // C++ [basic.def.odr]p2: 5769 // An overloaded function is used if it is selected by overload resolution 5770 // when referred to from a potentially-evaluated expression. [Note: this 5771 // covers calls to named functions (5.2.2), operator overloading 5772 // (clause 13), user-defined conversions (12.3.2), allocation function for 5773 // placement new (5.3.4), as well as non-default initialization (8.5). 5774 if (Best->Function) 5775 S.MarkDeclarationReferenced(Loc, Best->Function); 5776 5777 return OR_Success; 5778} 5779 5780namespace { 5781 5782enum OverloadCandidateKind { 5783 oc_function, 5784 oc_method, 5785 oc_constructor, 5786 oc_function_template, 5787 oc_method_template, 5788 oc_constructor_template, 5789 oc_implicit_default_constructor, 5790 oc_implicit_copy_constructor, 5791 oc_implicit_copy_assignment 5792}; 5793 5794OverloadCandidateKind ClassifyOverloadCandidate(Sema &S, 5795 FunctionDecl *Fn, 5796 std::string &Description) { 5797 bool isTemplate = false; 5798 5799 if (FunctionTemplateDecl *FunTmpl = Fn->getPrimaryTemplate()) { 5800 isTemplate = true; 5801 Description = S.getTemplateArgumentBindingsText( 5802 FunTmpl->getTemplateParameters(), *Fn->getTemplateSpecializationArgs()); 5803 } 5804 5805 if (CXXConstructorDecl *Ctor = dyn_cast<CXXConstructorDecl>(Fn)) { 5806 if (!Ctor->isImplicit()) 5807 return isTemplate ? oc_constructor_template : oc_constructor; 5808 5809 return Ctor->isCopyConstructor() ? oc_implicit_copy_constructor 5810 : oc_implicit_default_constructor; 5811 } 5812 5813 if (CXXMethodDecl *Meth = dyn_cast<CXXMethodDecl>(Fn)) { 5814 // This actually gets spelled 'candidate function' for now, but 5815 // it doesn't hurt to split it out. 5816 if (!Meth->isImplicit()) 5817 return isTemplate ? oc_method_template : oc_method; 5818 5819 assert(Meth->isCopyAssignmentOperator() 5820 && "implicit method is not copy assignment operator?"); 5821 return oc_implicit_copy_assignment; 5822 } 5823 5824 return isTemplate ? oc_function_template : oc_function; 5825} 5826 5827} // end anonymous namespace 5828 5829// Notes the location of an overload candidate. 5830void Sema::NoteOverloadCandidate(FunctionDecl *Fn) { 5831 std::string FnDesc; 5832 OverloadCandidateKind K = ClassifyOverloadCandidate(*this, Fn, FnDesc); 5833 Diag(Fn->getLocation(), diag::note_ovl_candidate) 5834 << (unsigned) K << FnDesc; 5835} 5836 5837/// Diagnoses an ambiguous conversion. The partial diagnostic is the 5838/// "lead" diagnostic; it will be given two arguments, the source and 5839/// target types of the conversion. 5840void ImplicitConversionSequence::DiagnoseAmbiguousConversion( 5841 Sema &S, 5842 SourceLocation CaretLoc, 5843 const PartialDiagnostic &PDiag) const { 5844 S.Diag(CaretLoc, PDiag) 5845 << Ambiguous.getFromType() << Ambiguous.getToType(); 5846 for (AmbiguousConversionSequence::const_iterator 5847 I = Ambiguous.begin(), E = Ambiguous.end(); I != E; ++I) { 5848 S.NoteOverloadCandidate(*I); 5849 } 5850} 5851 5852namespace { 5853 5854void DiagnoseBadConversion(Sema &S, OverloadCandidate *Cand, unsigned I) { 5855 const ImplicitConversionSequence &Conv = Cand->Conversions[I]; 5856 assert(Conv.isBad()); 5857 assert(Cand->Function && "for now, candidate must be a function"); 5858 FunctionDecl *Fn = Cand->Function; 5859 5860 // There's a conversion slot for the object argument if this is a 5861 // non-constructor method. Note that 'I' corresponds the 5862 // conversion-slot index. 5863 bool isObjectArgument = false; 5864 if (isa<CXXMethodDecl>(Fn) && !isa<CXXConstructorDecl>(Fn)) { 5865 if (I == 0) 5866 isObjectArgument = true; 5867 else 5868 I--; 5869 } 5870 5871 std::string FnDesc; 5872 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc); 5873 5874 Expr *FromExpr = Conv.Bad.FromExpr; 5875 QualType FromTy = Conv.Bad.getFromType(); 5876 QualType ToTy = Conv.Bad.getToType(); 5877 5878 if (FromTy == S.Context.OverloadTy) { 5879 assert(FromExpr && "overload set argument came from implicit argument?"); 5880 Expr *E = FromExpr->IgnoreParens(); 5881 if (isa<UnaryOperator>(E)) 5882 E = cast<UnaryOperator>(E)->getSubExpr()->IgnoreParens(); 5883 DeclarationName Name = cast<OverloadExpr>(E)->getName(); 5884 5885 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_overload) 5886 << (unsigned) FnKind << FnDesc 5887 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 5888 << ToTy << Name << I+1; 5889 return; 5890 } 5891 5892 // Do some hand-waving analysis to see if the non-viability is due 5893 // to a qualifier mismatch. 5894 CanQualType CFromTy = S.Context.getCanonicalType(FromTy); 5895 CanQualType CToTy = S.Context.getCanonicalType(ToTy); 5896 if (CanQual<ReferenceType> RT = CToTy->getAs<ReferenceType>()) 5897 CToTy = RT->getPointeeType(); 5898 else { 5899 // TODO: detect and diagnose the full richness of const mismatches. 5900 if (CanQual<PointerType> FromPT = CFromTy->getAs<PointerType>()) 5901 if (CanQual<PointerType> ToPT = CToTy->getAs<PointerType>()) 5902 CFromTy = FromPT->getPointeeType(), CToTy = ToPT->getPointeeType(); 5903 } 5904 5905 if (CToTy.getUnqualifiedType() == CFromTy.getUnqualifiedType() && 5906 !CToTy.isAtLeastAsQualifiedAs(CFromTy)) { 5907 // It is dumb that we have to do this here. 5908 while (isa<ArrayType>(CFromTy)) 5909 CFromTy = CFromTy->getAs<ArrayType>()->getElementType(); 5910 while (isa<ArrayType>(CToTy)) 5911 CToTy = CFromTy->getAs<ArrayType>()->getElementType(); 5912 5913 Qualifiers FromQs = CFromTy.getQualifiers(); 5914 Qualifiers ToQs = CToTy.getQualifiers(); 5915 5916 if (FromQs.getAddressSpace() != ToQs.getAddressSpace()) { 5917 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_addrspace) 5918 << (unsigned) FnKind << FnDesc 5919 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 5920 << FromTy 5921 << FromQs.getAddressSpace() << ToQs.getAddressSpace() 5922 << (unsigned) isObjectArgument << I+1; 5923 return; 5924 } 5925 5926 unsigned CVR = FromQs.getCVRQualifiers() & ~ToQs.getCVRQualifiers(); 5927 assert(CVR && "unexpected qualifiers mismatch"); 5928 5929 if (isObjectArgument) { 5930 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr_this) 5931 << (unsigned) FnKind << FnDesc 5932 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 5933 << FromTy << (CVR - 1); 5934 } else { 5935 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_cvr) 5936 << (unsigned) FnKind << FnDesc 5937 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 5938 << FromTy << (CVR - 1) << I+1; 5939 } 5940 return; 5941 } 5942 5943 // Diagnose references or pointers to incomplete types differently, 5944 // since it's far from impossible that the incompleteness triggered 5945 // the failure. 5946 QualType TempFromTy = FromTy.getNonReferenceType(); 5947 if (const PointerType *PTy = TempFromTy->getAs<PointerType>()) 5948 TempFromTy = PTy->getPointeeType(); 5949 if (TempFromTy->isIncompleteType()) { 5950 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv_incomplete) 5951 << (unsigned) FnKind << FnDesc 5952 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 5953 << FromTy << ToTy << (unsigned) isObjectArgument << I+1; 5954 return; 5955 } 5956 5957 // Diagnose base -> derived pointer conversions. 5958 unsigned BaseToDerivedConversion = 0; 5959 if (const PointerType *FromPtrTy = FromTy->getAs<PointerType>()) { 5960 if (const PointerType *ToPtrTy = ToTy->getAs<PointerType>()) { 5961 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs( 5962 FromPtrTy->getPointeeType()) && 5963 !FromPtrTy->getPointeeType()->isIncompleteType() && 5964 !ToPtrTy->getPointeeType()->isIncompleteType() && 5965 S.IsDerivedFrom(ToPtrTy->getPointeeType(), 5966 FromPtrTy->getPointeeType())) 5967 BaseToDerivedConversion = 1; 5968 } 5969 } else if (const ObjCObjectPointerType *FromPtrTy 5970 = FromTy->getAs<ObjCObjectPointerType>()) { 5971 if (const ObjCObjectPointerType *ToPtrTy 5972 = ToTy->getAs<ObjCObjectPointerType>()) 5973 if (const ObjCInterfaceDecl *FromIface = FromPtrTy->getInterfaceDecl()) 5974 if (const ObjCInterfaceDecl *ToIface = ToPtrTy->getInterfaceDecl()) 5975 if (ToPtrTy->getPointeeType().isAtLeastAsQualifiedAs( 5976 FromPtrTy->getPointeeType()) && 5977 FromIface->isSuperClassOf(ToIface)) 5978 BaseToDerivedConversion = 2; 5979 } else if (const ReferenceType *ToRefTy = ToTy->getAs<ReferenceType>()) { 5980 if (ToRefTy->getPointeeType().isAtLeastAsQualifiedAs(FromTy) && 5981 !FromTy->isIncompleteType() && 5982 !ToRefTy->getPointeeType()->isIncompleteType() && 5983 S.IsDerivedFrom(ToRefTy->getPointeeType(), FromTy)) 5984 BaseToDerivedConversion = 3; 5985 } 5986 5987 if (BaseToDerivedConversion) { 5988 S.Diag(Fn->getLocation(), 5989 diag::note_ovl_candidate_bad_base_to_derived_conv) 5990 << (unsigned) FnKind << FnDesc 5991 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 5992 << (BaseToDerivedConversion - 1) 5993 << FromTy << ToTy << I+1; 5994 return; 5995 } 5996 5997 // TODO: specialize more based on the kind of mismatch 5998 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_conv) 5999 << (unsigned) FnKind << FnDesc 6000 << (FromExpr ? FromExpr->getSourceRange() : SourceRange()) 6001 << FromTy << ToTy << (unsigned) isObjectArgument << I+1; 6002} 6003 6004void DiagnoseArityMismatch(Sema &S, OverloadCandidate *Cand, 6005 unsigned NumFormalArgs) { 6006 // TODO: treat calls to a missing default constructor as a special case 6007 6008 FunctionDecl *Fn = Cand->Function; 6009 const FunctionProtoType *FnTy = Fn->getType()->getAs<FunctionProtoType>(); 6010 6011 unsigned MinParams = Fn->getMinRequiredArguments(); 6012 6013 // at least / at most / exactly 6014 // FIXME: variadic templates "at most" should account for parameter packs 6015 unsigned mode, modeCount; 6016 if (NumFormalArgs < MinParams) { 6017 assert((Cand->FailureKind == ovl_fail_too_few_arguments) || 6018 (Cand->FailureKind == ovl_fail_bad_deduction && 6019 Cand->DeductionFailure.Result == Sema::TDK_TooFewArguments)); 6020 if (MinParams != FnTy->getNumArgs() || FnTy->isVariadic()) 6021 mode = 0; // "at least" 6022 else 6023 mode = 2; // "exactly" 6024 modeCount = MinParams; 6025 } else { 6026 assert((Cand->FailureKind == ovl_fail_too_many_arguments) || 6027 (Cand->FailureKind == ovl_fail_bad_deduction && 6028 Cand->DeductionFailure.Result == Sema::TDK_TooManyArguments)); 6029 if (MinParams != FnTy->getNumArgs()) 6030 mode = 1; // "at most" 6031 else 6032 mode = 2; // "exactly" 6033 modeCount = FnTy->getNumArgs(); 6034 } 6035 6036 std::string Description; 6037 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, Description); 6038 6039 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_arity) 6040 << (unsigned) FnKind << (Fn->getDescribedFunctionTemplate() != 0) << mode 6041 << modeCount << NumFormalArgs; 6042} 6043 6044/// Diagnose a failed template-argument deduction. 6045void DiagnoseBadDeduction(Sema &S, OverloadCandidate *Cand, 6046 Expr **Args, unsigned NumArgs) { 6047 FunctionDecl *Fn = Cand->Function; // pattern 6048 6049 TemplateParameter Param = Cand->DeductionFailure.getTemplateParameter(); 6050 NamedDecl *ParamD; 6051 (ParamD = Param.dyn_cast<TemplateTypeParmDecl*>()) || 6052 (ParamD = Param.dyn_cast<NonTypeTemplateParmDecl*>()) || 6053 (ParamD = Param.dyn_cast<TemplateTemplateParmDecl*>()); 6054 switch (Cand->DeductionFailure.Result) { 6055 case Sema::TDK_Success: 6056 llvm_unreachable("TDK_success while diagnosing bad deduction"); 6057 6058 case Sema::TDK_Incomplete: { 6059 assert(ParamD && "no parameter found for incomplete deduction result"); 6060 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_incomplete_deduction) 6061 << ParamD->getDeclName(); 6062 return; 6063 } 6064 6065 case Sema::TDK_Underqualified: { 6066 assert(ParamD && "no parameter found for bad qualifiers deduction result"); 6067 TemplateTypeParmDecl *TParam = cast<TemplateTypeParmDecl>(ParamD); 6068 6069 QualType Param = Cand->DeductionFailure.getFirstArg()->getAsType(); 6070 6071 // Param will have been canonicalized, but it should just be a 6072 // qualified version of ParamD, so move the qualifiers to that. 6073 QualifierCollector Qs(S.Context); 6074 Qs.strip(Param); 6075 QualType NonCanonParam = Qs.apply(TParam->getTypeForDecl()); 6076 assert(S.Context.hasSameType(Param, NonCanonParam)); 6077 6078 // Arg has also been canonicalized, but there's nothing we can do 6079 // about that. It also doesn't matter as much, because it won't 6080 // have any template parameters in it (because deduction isn't 6081 // done on dependent types). 6082 QualType Arg = Cand->DeductionFailure.getSecondArg()->getAsType(); 6083 6084 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_underqualified) 6085 << ParamD->getDeclName() << Arg << NonCanonParam; 6086 return; 6087 } 6088 6089 case Sema::TDK_Inconsistent: { 6090 assert(ParamD && "no parameter found for inconsistent deduction result"); 6091 int which = 0; 6092 if (isa<TemplateTypeParmDecl>(ParamD)) 6093 which = 0; 6094 else if (isa<NonTypeTemplateParmDecl>(ParamD)) 6095 which = 1; 6096 else { 6097 which = 2; 6098 } 6099 6100 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_inconsistent_deduction) 6101 << which << ParamD->getDeclName() 6102 << *Cand->DeductionFailure.getFirstArg() 6103 << *Cand->DeductionFailure.getSecondArg(); 6104 return; 6105 } 6106 6107 case Sema::TDK_InvalidExplicitArguments: 6108 assert(ParamD && "no parameter found for invalid explicit arguments"); 6109 if (ParamD->getDeclName()) 6110 S.Diag(Fn->getLocation(), 6111 diag::note_ovl_candidate_explicit_arg_mismatch_named) 6112 << ParamD->getDeclName(); 6113 else { 6114 int index = 0; 6115 if (TemplateTypeParmDecl *TTP = dyn_cast<TemplateTypeParmDecl>(ParamD)) 6116 index = TTP->getIndex(); 6117 else if (NonTypeTemplateParmDecl *NTTP 6118 = dyn_cast<NonTypeTemplateParmDecl>(ParamD)) 6119 index = NTTP->getIndex(); 6120 else 6121 index = cast<TemplateTemplateParmDecl>(ParamD)->getIndex(); 6122 S.Diag(Fn->getLocation(), 6123 diag::note_ovl_candidate_explicit_arg_mismatch_unnamed) 6124 << (index + 1); 6125 } 6126 return; 6127 6128 case Sema::TDK_TooManyArguments: 6129 case Sema::TDK_TooFewArguments: 6130 DiagnoseArityMismatch(S, Cand, NumArgs); 6131 return; 6132 6133 case Sema::TDK_InstantiationDepth: 6134 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_instantiation_depth); 6135 return; 6136 6137 case Sema::TDK_SubstitutionFailure: { 6138 std::string ArgString; 6139 if (TemplateArgumentList *Args 6140 = Cand->DeductionFailure.getTemplateArgumentList()) 6141 ArgString = S.getTemplateArgumentBindingsText( 6142 Fn->getDescribedFunctionTemplate()->getTemplateParameters(), 6143 *Args); 6144 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_substitution_failure) 6145 << ArgString; 6146 return; 6147 } 6148 6149 // TODO: diagnose these individually, then kill off 6150 // note_ovl_candidate_bad_deduction, which is uselessly vague. 6151 case Sema::TDK_NonDeducedMismatch: 6152 case Sema::TDK_FailedOverloadResolution: 6153 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_bad_deduction); 6154 return; 6155 } 6156} 6157 6158/// Generates a 'note' diagnostic for an overload candidate. We've 6159/// already generated a primary error at the call site. 6160/// 6161/// It really does need to be a single diagnostic with its caret 6162/// pointed at the candidate declaration. Yes, this creates some 6163/// major challenges of technical writing. Yes, this makes pointing 6164/// out problems with specific arguments quite awkward. It's still 6165/// better than generating twenty screens of text for every failed 6166/// overload. 6167/// 6168/// It would be great to be able to express per-candidate problems 6169/// more richly for those diagnostic clients that cared, but we'd 6170/// still have to be just as careful with the default diagnostics. 6171void NoteFunctionCandidate(Sema &S, OverloadCandidate *Cand, 6172 Expr **Args, unsigned NumArgs) { 6173 FunctionDecl *Fn = Cand->Function; 6174 6175 // Note deleted candidates, but only if they're viable. 6176 if (Cand->Viable && (Fn->isDeleted() || Fn->hasAttr<UnavailableAttr>())) { 6177 std::string FnDesc; 6178 OverloadCandidateKind FnKind = ClassifyOverloadCandidate(S, Fn, FnDesc); 6179 6180 S.Diag(Fn->getLocation(), diag::note_ovl_candidate_deleted) 6181 << FnKind << FnDesc << Fn->isDeleted(); 6182 return; 6183 } 6184 6185 // We don't really have anything else to say about viable candidates. 6186 if (Cand->Viable) { 6187 S.NoteOverloadCandidate(Fn); 6188 return; 6189 } 6190 6191 switch (Cand->FailureKind) { 6192 case ovl_fail_too_many_arguments: 6193 case ovl_fail_too_few_arguments: 6194 return DiagnoseArityMismatch(S, Cand, NumArgs); 6195 6196 case ovl_fail_bad_deduction: 6197 return DiagnoseBadDeduction(S, Cand, Args, NumArgs); 6198 6199 case ovl_fail_trivial_conversion: 6200 case ovl_fail_bad_final_conversion: 6201 case ovl_fail_final_conversion_not_exact: 6202 return S.NoteOverloadCandidate(Fn); 6203 6204 case ovl_fail_bad_conversion: { 6205 unsigned I = (Cand->IgnoreObjectArgument ? 1 : 0); 6206 for (unsigned N = Cand->Conversions.size(); I != N; ++I) 6207 if (Cand->Conversions[I].isBad()) 6208 return DiagnoseBadConversion(S, Cand, I); 6209 6210 // FIXME: this currently happens when we're called from SemaInit 6211 // when user-conversion overload fails. Figure out how to handle 6212 // those conditions and diagnose them well. 6213 return S.NoteOverloadCandidate(Fn); 6214 } 6215 } 6216} 6217 6218void NoteSurrogateCandidate(Sema &S, OverloadCandidate *Cand) { 6219 // Desugar the type of the surrogate down to a function type, 6220 // retaining as many typedefs as possible while still showing 6221 // the function type (and, therefore, its parameter types). 6222 QualType FnType = Cand->Surrogate->getConversionType(); 6223 bool isLValueReference = false; 6224 bool isRValueReference = false; 6225 bool isPointer = false; 6226 if (const LValueReferenceType *FnTypeRef = 6227 FnType->getAs<LValueReferenceType>()) { 6228 FnType = FnTypeRef->getPointeeType(); 6229 isLValueReference = true; 6230 } else if (const RValueReferenceType *FnTypeRef = 6231 FnType->getAs<RValueReferenceType>()) { 6232 FnType = FnTypeRef->getPointeeType(); 6233 isRValueReference = true; 6234 } 6235 if (const PointerType *FnTypePtr = FnType->getAs<PointerType>()) { 6236 FnType = FnTypePtr->getPointeeType(); 6237 isPointer = true; 6238 } 6239 // Desugar down to a function type. 6240 FnType = QualType(FnType->getAs<FunctionType>(), 0); 6241 // Reconstruct the pointer/reference as appropriate. 6242 if (isPointer) FnType = S.Context.getPointerType(FnType); 6243 if (isRValueReference) FnType = S.Context.getRValueReferenceType(FnType); 6244 if (isLValueReference) FnType = S.Context.getLValueReferenceType(FnType); 6245 6246 S.Diag(Cand->Surrogate->getLocation(), diag::note_ovl_surrogate_cand) 6247 << FnType; 6248} 6249 6250void NoteBuiltinOperatorCandidate(Sema &S, 6251 const char *Opc, 6252 SourceLocation OpLoc, 6253 OverloadCandidate *Cand) { 6254 assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary"); 6255 std::string TypeStr("operator"); 6256 TypeStr += Opc; 6257 TypeStr += "("; 6258 TypeStr += Cand->BuiltinTypes.ParamTypes[0].getAsString(); 6259 if (Cand->Conversions.size() == 1) { 6260 TypeStr += ")"; 6261 S.Diag(OpLoc, diag::note_ovl_builtin_unary_candidate) << TypeStr; 6262 } else { 6263 TypeStr += ", "; 6264 TypeStr += Cand->BuiltinTypes.ParamTypes[1].getAsString(); 6265 TypeStr += ")"; 6266 S.Diag(OpLoc, diag::note_ovl_builtin_binary_candidate) << TypeStr; 6267 } 6268} 6269 6270void NoteAmbiguousUserConversions(Sema &S, SourceLocation OpLoc, 6271 OverloadCandidate *Cand) { 6272 unsigned NoOperands = Cand->Conversions.size(); 6273 for (unsigned ArgIdx = 0; ArgIdx < NoOperands; ++ArgIdx) { 6274 const ImplicitConversionSequence &ICS = Cand->Conversions[ArgIdx]; 6275 if (ICS.isBad()) break; // all meaningless after first invalid 6276 if (!ICS.isAmbiguous()) continue; 6277 6278 ICS.DiagnoseAmbiguousConversion(S, OpLoc, 6279 S.PDiag(diag::note_ambiguous_type_conversion)); 6280 } 6281} 6282 6283SourceLocation GetLocationForCandidate(const OverloadCandidate *Cand) { 6284 if (Cand->Function) 6285 return Cand->Function->getLocation(); 6286 if (Cand->IsSurrogate) 6287 return Cand->Surrogate->getLocation(); 6288 return SourceLocation(); 6289} 6290 6291struct CompareOverloadCandidatesForDisplay { 6292 Sema &S; 6293 CompareOverloadCandidatesForDisplay(Sema &S) : S(S) {} 6294 6295 bool operator()(const OverloadCandidate *L, 6296 const OverloadCandidate *R) { 6297 // Fast-path this check. 6298 if (L == R) return false; 6299 6300 // Order first by viability. 6301 if (L->Viable) { 6302 if (!R->Viable) return true; 6303 6304 // TODO: introduce a tri-valued comparison for overload 6305 // candidates. Would be more worthwhile if we had a sort 6306 // that could exploit it. 6307 if (isBetterOverloadCandidate(S, *L, *R, SourceLocation())) return true; 6308 if (isBetterOverloadCandidate(S, *R, *L, SourceLocation())) return false; 6309 } else if (R->Viable) 6310 return false; 6311 6312 assert(L->Viable == R->Viable); 6313 6314 // Criteria by which we can sort non-viable candidates: 6315 if (!L->Viable) { 6316 // 1. Arity mismatches come after other candidates. 6317 if (L->FailureKind == ovl_fail_too_many_arguments || 6318 L->FailureKind == ovl_fail_too_few_arguments) 6319 return false; 6320 if (R->FailureKind == ovl_fail_too_many_arguments || 6321 R->FailureKind == ovl_fail_too_few_arguments) 6322 return true; 6323 6324 // 2. Bad conversions come first and are ordered by the number 6325 // of bad conversions and quality of good conversions. 6326 if (L->FailureKind == ovl_fail_bad_conversion) { 6327 if (R->FailureKind != ovl_fail_bad_conversion) 6328 return true; 6329 6330 // If there's any ordering between the defined conversions... 6331 // FIXME: this might not be transitive. 6332 assert(L->Conversions.size() == R->Conversions.size()); 6333 6334 int leftBetter = 0; 6335 unsigned I = (L->IgnoreObjectArgument || R->IgnoreObjectArgument); 6336 for (unsigned E = L->Conversions.size(); I != E; ++I) { 6337 switch (CompareImplicitConversionSequences(S, 6338 L->Conversions[I], 6339 R->Conversions[I])) { 6340 case ImplicitConversionSequence::Better: 6341 leftBetter++; 6342 break; 6343 6344 case ImplicitConversionSequence::Worse: 6345 leftBetter--; 6346 break; 6347 6348 case ImplicitConversionSequence::Indistinguishable: 6349 break; 6350 } 6351 } 6352 if (leftBetter > 0) return true; 6353 if (leftBetter < 0) return false; 6354 6355 } else if (R->FailureKind == ovl_fail_bad_conversion) 6356 return false; 6357 6358 // TODO: others? 6359 } 6360 6361 // Sort everything else by location. 6362 SourceLocation LLoc = GetLocationForCandidate(L); 6363 SourceLocation RLoc = GetLocationForCandidate(R); 6364 6365 // Put candidates without locations (e.g. builtins) at the end. 6366 if (LLoc.isInvalid()) return false; 6367 if (RLoc.isInvalid()) return true; 6368 6369 return S.SourceMgr.isBeforeInTranslationUnit(LLoc, RLoc); 6370 } 6371}; 6372 6373/// CompleteNonViableCandidate - Normally, overload resolution only 6374/// computes up to the first 6375void CompleteNonViableCandidate(Sema &S, OverloadCandidate *Cand, 6376 Expr **Args, unsigned NumArgs) { 6377 assert(!Cand->Viable); 6378 6379 // Don't do anything on failures other than bad conversion. 6380 if (Cand->FailureKind != ovl_fail_bad_conversion) return; 6381 6382 // Skip forward to the first bad conversion. 6383 unsigned ConvIdx = (Cand->IgnoreObjectArgument ? 1 : 0); 6384 unsigned ConvCount = Cand->Conversions.size(); 6385 while (true) { 6386 assert(ConvIdx != ConvCount && "no bad conversion in candidate"); 6387 ConvIdx++; 6388 if (Cand->Conversions[ConvIdx - 1].isBad()) 6389 break; 6390 } 6391 6392 if (ConvIdx == ConvCount) 6393 return; 6394 6395 assert(!Cand->Conversions[ConvIdx].isInitialized() && 6396 "remaining conversion is initialized?"); 6397 6398 // FIXME: this should probably be preserved from the overload 6399 // operation somehow. 6400 bool SuppressUserConversions = false; 6401 6402 const FunctionProtoType* Proto; 6403 unsigned ArgIdx = ConvIdx; 6404 6405 if (Cand->IsSurrogate) { 6406 QualType ConvType 6407 = Cand->Surrogate->getConversionType().getNonReferenceType(); 6408 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 6409 ConvType = ConvPtrType->getPointeeType(); 6410 Proto = ConvType->getAs<FunctionProtoType>(); 6411 ArgIdx--; 6412 } else if (Cand->Function) { 6413 Proto = Cand->Function->getType()->getAs<FunctionProtoType>(); 6414 if (isa<CXXMethodDecl>(Cand->Function) && 6415 !isa<CXXConstructorDecl>(Cand->Function)) 6416 ArgIdx--; 6417 } else { 6418 // Builtin binary operator with a bad first conversion. 6419 assert(ConvCount <= 3); 6420 for (; ConvIdx != ConvCount; ++ConvIdx) 6421 Cand->Conversions[ConvIdx] 6422 = TryCopyInitialization(S, Args[ConvIdx], 6423 Cand->BuiltinTypes.ParamTypes[ConvIdx], 6424 SuppressUserConversions, 6425 /*InOverloadResolution*/ true); 6426 return; 6427 } 6428 6429 // Fill in the rest of the conversions. 6430 unsigned NumArgsInProto = Proto->getNumArgs(); 6431 for (; ConvIdx != ConvCount; ++ConvIdx, ++ArgIdx) { 6432 if (ArgIdx < NumArgsInProto) 6433 Cand->Conversions[ConvIdx] 6434 = TryCopyInitialization(S, Args[ArgIdx], Proto->getArgType(ArgIdx), 6435 SuppressUserConversions, 6436 /*InOverloadResolution=*/true); 6437 else 6438 Cand->Conversions[ConvIdx].setEllipsis(); 6439 } 6440} 6441 6442} // end anonymous namespace 6443 6444/// PrintOverloadCandidates - When overload resolution fails, prints 6445/// diagnostic messages containing the candidates in the candidate 6446/// set. 6447void OverloadCandidateSet::NoteCandidates(Sema &S, 6448 OverloadCandidateDisplayKind OCD, 6449 Expr **Args, unsigned NumArgs, 6450 const char *Opc, 6451 SourceLocation OpLoc) { 6452 // Sort the candidates by viability and position. Sorting directly would 6453 // be prohibitive, so we make a set of pointers and sort those. 6454 llvm::SmallVector<OverloadCandidate*, 32> Cands; 6455 if (OCD == OCD_AllCandidates) Cands.reserve(size()); 6456 for (iterator Cand = begin(), LastCand = end(); Cand != LastCand; ++Cand) { 6457 if (Cand->Viable) 6458 Cands.push_back(Cand); 6459 else if (OCD == OCD_AllCandidates) { 6460 CompleteNonViableCandidate(S, Cand, Args, NumArgs); 6461 if (Cand->Function || Cand->IsSurrogate) 6462 Cands.push_back(Cand); 6463 // Otherwise, this a non-viable builtin candidate. We do not, in general, 6464 // want to list every possible builtin candidate. 6465 } 6466 } 6467 6468 std::sort(Cands.begin(), Cands.end(), 6469 CompareOverloadCandidatesForDisplay(S)); 6470 6471 bool ReportedAmbiguousConversions = false; 6472 6473 llvm::SmallVectorImpl<OverloadCandidate*>::iterator I, E; 6474 const Diagnostic::OverloadsShown ShowOverloads = S.Diags.getShowOverloads(); 6475 unsigned CandsShown = 0; 6476 for (I = Cands.begin(), E = Cands.end(); I != E; ++I) { 6477 OverloadCandidate *Cand = *I; 6478 6479 // Set an arbitrary limit on the number of candidate functions we'll spam 6480 // the user with. FIXME: This limit should depend on details of the 6481 // candidate list. 6482 if (CandsShown >= 4 && ShowOverloads == Diagnostic::Ovl_Best) { 6483 break; 6484 } 6485 ++CandsShown; 6486 6487 if (Cand->Function) 6488 NoteFunctionCandidate(S, Cand, Args, NumArgs); 6489 else if (Cand->IsSurrogate) 6490 NoteSurrogateCandidate(S, Cand); 6491 else { 6492 assert(Cand->Viable && 6493 "Non-viable built-in candidates are not added to Cands."); 6494 // Generally we only see ambiguities including viable builtin 6495 // operators if overload resolution got screwed up by an 6496 // ambiguous user-defined conversion. 6497 // 6498 // FIXME: It's quite possible for different conversions to see 6499 // different ambiguities, though. 6500 if (!ReportedAmbiguousConversions) { 6501 NoteAmbiguousUserConversions(S, OpLoc, Cand); 6502 ReportedAmbiguousConversions = true; 6503 } 6504 6505 // If this is a viable builtin, print it. 6506 NoteBuiltinOperatorCandidate(S, Opc, OpLoc, Cand); 6507 } 6508 } 6509 6510 if (I != E) 6511 S.Diag(OpLoc, diag::note_ovl_too_many_candidates) << int(E - I); 6512} 6513 6514static bool CheckUnresolvedAccess(Sema &S, OverloadExpr *E, DeclAccessPair D) { 6515 if (isa<UnresolvedLookupExpr>(E)) 6516 return S.CheckUnresolvedLookupAccess(cast<UnresolvedLookupExpr>(E), D); 6517 6518 return S.CheckUnresolvedMemberAccess(cast<UnresolvedMemberExpr>(E), D); 6519} 6520 6521/// ResolveAddressOfOverloadedFunction - Try to resolve the address of 6522/// an overloaded function (C++ [over.over]), where @p From is an 6523/// expression with overloaded function type and @p ToType is the type 6524/// we're trying to resolve to. For example: 6525/// 6526/// @code 6527/// int f(double); 6528/// int f(int); 6529/// 6530/// int (*pfd)(double) = f; // selects f(double) 6531/// @endcode 6532/// 6533/// This routine returns the resulting FunctionDecl if it could be 6534/// resolved, and NULL otherwise. When @p Complain is true, this 6535/// routine will emit diagnostics if there is an error. 6536FunctionDecl * 6537Sema::ResolveAddressOfOverloadedFunction(Expr *From, QualType ToType, 6538 bool Complain, 6539 DeclAccessPair &FoundResult) { 6540 QualType FunctionType = ToType; 6541 bool IsMember = false; 6542 if (const PointerType *ToTypePtr = ToType->getAs<PointerType>()) 6543 FunctionType = ToTypePtr->getPointeeType(); 6544 else if (const ReferenceType *ToTypeRef = ToType->getAs<ReferenceType>()) 6545 FunctionType = ToTypeRef->getPointeeType(); 6546 else if (const MemberPointerType *MemTypePtr = 6547 ToType->getAs<MemberPointerType>()) { 6548 FunctionType = MemTypePtr->getPointeeType(); 6549 IsMember = true; 6550 } 6551 6552 // C++ [over.over]p1: 6553 // [...] [Note: any redundant set of parentheses surrounding the 6554 // overloaded function name is ignored (5.1). ] 6555 // C++ [over.over]p1: 6556 // [...] The overloaded function name can be preceded by the & 6557 // operator. 6558 // However, remember whether the expression has member-pointer form: 6559 // C++ [expr.unary.op]p4: 6560 // A pointer to member is only formed when an explicit & is used 6561 // and its operand is a qualified-id not enclosed in 6562 // parentheses. 6563 OverloadExpr::FindResult Ovl = OverloadExpr::find(From); 6564 OverloadExpr *OvlExpr = Ovl.Expression; 6565 6566 // We expect a pointer or reference to function, or a function pointer. 6567 FunctionType = Context.getCanonicalType(FunctionType).getUnqualifiedType(); 6568 if (!FunctionType->isFunctionType()) { 6569 if (Complain) 6570 Diag(From->getLocStart(), diag::err_addr_ovl_not_func_ptrref) 6571 << OvlExpr->getName() << ToType; 6572 6573 return 0; 6574 } 6575 6576 // If the overload expression doesn't have the form of a pointer to 6577 // member, don't try to convert it to a pointer-to-member type. 6578 if (IsMember && !Ovl.HasFormOfMemberPointer) { 6579 if (!Complain) return 0; 6580 6581 // TODO: Should we condition this on whether any functions might 6582 // have matched, or is it more appropriate to do that in callers? 6583 // TODO: a fixit wouldn't hurt. 6584 Diag(OvlExpr->getNameLoc(), diag::err_addr_ovl_no_qualifier) 6585 << ToType << OvlExpr->getSourceRange(); 6586 return 0; 6587 } 6588 6589 TemplateArgumentListInfo ETABuffer, *ExplicitTemplateArgs = 0; 6590 if (OvlExpr->hasExplicitTemplateArgs()) { 6591 OvlExpr->getExplicitTemplateArgs().copyInto(ETABuffer); 6592 ExplicitTemplateArgs = &ETABuffer; 6593 } 6594 6595 assert(From->getType() == Context.OverloadTy); 6596 6597 // Look through all of the overloaded functions, searching for one 6598 // whose type matches exactly. 6599 llvm::SmallVector<std::pair<DeclAccessPair, FunctionDecl*>, 4> Matches; 6600 llvm::SmallVector<FunctionDecl *, 4> NonMatches; 6601 6602 bool FoundNonTemplateFunction = false; 6603 for (UnresolvedSetIterator I = OvlExpr->decls_begin(), 6604 E = OvlExpr->decls_end(); I != E; ++I) { 6605 // Look through any using declarations to find the underlying function. 6606 NamedDecl *Fn = (*I)->getUnderlyingDecl(); 6607 6608 // C++ [over.over]p3: 6609 // Non-member functions and static member functions match 6610 // targets of type "pointer-to-function" or "reference-to-function." 6611 // Nonstatic member functions match targets of 6612 // type "pointer-to-member-function." 6613 // Note that according to DR 247, the containing class does not matter. 6614 6615 if (FunctionTemplateDecl *FunctionTemplate 6616 = dyn_cast<FunctionTemplateDecl>(Fn)) { 6617 if (CXXMethodDecl *Method 6618 = dyn_cast<CXXMethodDecl>(FunctionTemplate->getTemplatedDecl())) { 6619 // Skip non-static function templates when converting to pointer, and 6620 // static when converting to member pointer. 6621 if (Method->isStatic() == IsMember) 6622 continue; 6623 } else if (IsMember) 6624 continue; 6625 6626 // C++ [over.over]p2: 6627 // If the name is a function template, template argument deduction is 6628 // done (14.8.2.2), and if the argument deduction succeeds, the 6629 // resulting template argument list is used to generate a single 6630 // function template specialization, which is added to the set of 6631 // overloaded functions considered. 6632 FunctionDecl *Specialization = 0; 6633 TemplateDeductionInfo Info(Context, OvlExpr->getNameLoc()); 6634 if (TemplateDeductionResult Result 6635 = DeduceTemplateArguments(FunctionTemplate, ExplicitTemplateArgs, 6636 FunctionType, Specialization, Info)) { 6637 // FIXME: make a note of the failed deduction for diagnostics. 6638 (void)Result; 6639 } else { 6640 // Template argument deduction ensures that we have an exact match. 6641 // This function template specicalization works. 6642 Specialization = cast<FunctionDecl>(Specialization->getCanonicalDecl()); 6643 assert(FunctionType 6644 == Context.getCanonicalType(Specialization->getType())); 6645 Matches.push_back(std::make_pair(I.getPair(), Specialization)); 6646 } 6647 6648 continue; 6649 } 6650 6651 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) { 6652 // Skip non-static functions when converting to pointer, and static 6653 // when converting to member pointer. 6654 if (Method->isStatic() == IsMember) 6655 continue; 6656 6657 // If we have explicit template arguments, skip non-templates. 6658 if (OvlExpr->hasExplicitTemplateArgs()) 6659 continue; 6660 } else if (IsMember) 6661 continue; 6662 6663 if (FunctionDecl *FunDecl = dyn_cast<FunctionDecl>(Fn)) { 6664 QualType ResultTy; 6665 if (Context.hasSameUnqualifiedType(FunctionType, FunDecl->getType()) || 6666 IsNoReturnConversion(Context, FunDecl->getType(), FunctionType, 6667 ResultTy)) { 6668 Matches.push_back(std::make_pair(I.getPair(), 6669 cast<FunctionDecl>(FunDecl->getCanonicalDecl()))); 6670 FoundNonTemplateFunction = true; 6671 } 6672 } 6673 } 6674 6675 // If there were 0 or 1 matches, we're done. 6676 if (Matches.empty()) { 6677 if (Complain) { 6678 Diag(From->getLocStart(), diag::err_addr_ovl_no_viable) 6679 << OvlExpr->getName() << FunctionType; 6680 for (UnresolvedSetIterator I = OvlExpr->decls_begin(), 6681 E = OvlExpr->decls_end(); 6682 I != E; ++I) 6683 if (FunctionDecl *F = dyn_cast<FunctionDecl>((*I)->getUnderlyingDecl())) 6684 NoteOverloadCandidate(F); 6685 } 6686 6687 return 0; 6688 } else if (Matches.size() == 1) { 6689 FunctionDecl *Result = Matches[0].second; 6690 FoundResult = Matches[0].first; 6691 MarkDeclarationReferenced(From->getLocStart(), Result); 6692 if (Complain) { 6693 CheckAddressOfMemberAccess(OvlExpr, Matches[0].first); 6694 } 6695 return Result; 6696 } 6697 6698 // C++ [over.over]p4: 6699 // If more than one function is selected, [...] 6700 if (!FoundNonTemplateFunction) { 6701 // [...] and any given function template specialization F1 is 6702 // eliminated if the set contains a second function template 6703 // specialization whose function template is more specialized 6704 // than the function template of F1 according to the partial 6705 // ordering rules of 14.5.5.2. 6706 6707 // The algorithm specified above is quadratic. We instead use a 6708 // two-pass algorithm (similar to the one used to identify the 6709 // best viable function in an overload set) that identifies the 6710 // best function template (if it exists). 6711 6712 UnresolvedSet<4> MatchesCopy; // TODO: avoid! 6713 for (unsigned I = 0, E = Matches.size(); I != E; ++I) 6714 MatchesCopy.addDecl(Matches[I].second, Matches[I].first.getAccess()); 6715 6716 UnresolvedSetIterator Result = 6717 getMostSpecialized(MatchesCopy.begin(), MatchesCopy.end(), 6718 TPOC_Other, From->getLocStart(), 6719 PDiag(), 6720 PDiag(diag::err_addr_ovl_ambiguous) 6721 << Matches[0].second->getDeclName(), 6722 PDiag(diag::note_ovl_candidate) 6723 << (unsigned) oc_function_template); 6724 if (Result == MatchesCopy.end()) 6725 return 0; 6726 6727 MarkDeclarationReferenced(From->getLocStart(), *Result); 6728 FoundResult = Matches[Result - MatchesCopy.begin()].first; 6729 if (Complain) 6730 CheckUnresolvedAccess(*this, OvlExpr, FoundResult); 6731 return cast<FunctionDecl>(*Result); 6732 } 6733 6734 // [...] any function template specializations in the set are 6735 // eliminated if the set also contains a non-template function, [...] 6736 for (unsigned I = 0, N = Matches.size(); I != N; ) { 6737 if (Matches[I].second->getPrimaryTemplate() == 0) 6738 ++I; 6739 else { 6740 Matches[I] = Matches[--N]; 6741 Matches.set_size(N); 6742 } 6743 } 6744 6745 // [...] After such eliminations, if any, there shall remain exactly one 6746 // selected function. 6747 if (Matches.size() == 1) { 6748 MarkDeclarationReferenced(From->getLocStart(), Matches[0].second); 6749 FoundResult = Matches[0].first; 6750 if (Complain) 6751 CheckUnresolvedAccess(*this, OvlExpr, Matches[0].first); 6752 return cast<FunctionDecl>(Matches[0].second); 6753 } 6754 6755 // FIXME: We should probably return the same thing that BestViableFunction 6756 // returns (even if we issue the diagnostics here). 6757 if (Complain) { 6758 Diag(From->getLocStart(), diag::err_addr_ovl_ambiguous) 6759 << Matches[0].second->getDeclName(); 6760 for (unsigned I = 0, E = Matches.size(); I != E; ++I) 6761 NoteOverloadCandidate(Matches[I].second); 6762 } 6763 6764 return 0; 6765} 6766 6767/// \brief Given an expression that refers to an overloaded function, try to 6768/// resolve that overloaded function expression down to a single function. 6769/// 6770/// This routine can only resolve template-ids that refer to a single function 6771/// template, where that template-id refers to a single template whose template 6772/// arguments are either provided by the template-id or have defaults, 6773/// as described in C++0x [temp.arg.explicit]p3. 6774FunctionDecl *Sema::ResolveSingleFunctionTemplateSpecialization(Expr *From) { 6775 // C++ [over.over]p1: 6776 // [...] [Note: any redundant set of parentheses surrounding the 6777 // overloaded function name is ignored (5.1). ] 6778 // C++ [over.over]p1: 6779 // [...] The overloaded function name can be preceded by the & 6780 // operator. 6781 6782 if (From->getType() != Context.OverloadTy) 6783 return 0; 6784 6785 OverloadExpr *OvlExpr = OverloadExpr::find(From).Expression; 6786 6787 // If we didn't actually find any template-ids, we're done. 6788 if (!OvlExpr->hasExplicitTemplateArgs()) 6789 return 0; 6790 6791 TemplateArgumentListInfo ExplicitTemplateArgs; 6792 OvlExpr->getExplicitTemplateArgs().copyInto(ExplicitTemplateArgs); 6793 6794 // Look through all of the overloaded functions, searching for one 6795 // whose type matches exactly. 6796 FunctionDecl *Matched = 0; 6797 for (UnresolvedSetIterator I = OvlExpr->decls_begin(), 6798 E = OvlExpr->decls_end(); I != E; ++I) { 6799 // C++0x [temp.arg.explicit]p3: 6800 // [...] In contexts where deduction is done and fails, or in contexts 6801 // where deduction is not done, if a template argument list is 6802 // specified and it, along with any default template arguments, 6803 // identifies a single function template specialization, then the 6804 // template-id is an lvalue for the function template specialization. 6805 FunctionTemplateDecl *FunctionTemplate 6806 = cast<FunctionTemplateDecl>((*I)->getUnderlyingDecl()); 6807 6808 // C++ [over.over]p2: 6809 // If the name is a function template, template argument deduction is 6810 // done (14.8.2.2), and if the argument deduction succeeds, the 6811 // resulting template argument list is used to generate a single 6812 // function template specialization, which is added to the set of 6813 // overloaded functions considered. 6814 FunctionDecl *Specialization = 0; 6815 TemplateDeductionInfo Info(Context, OvlExpr->getNameLoc()); 6816 if (TemplateDeductionResult Result 6817 = DeduceTemplateArguments(FunctionTemplate, &ExplicitTemplateArgs, 6818 Specialization, Info)) { 6819 // FIXME: make a note of the failed deduction for diagnostics. 6820 (void)Result; 6821 continue; 6822 } 6823 6824 // Multiple matches; we can't resolve to a single declaration. 6825 if (Matched) 6826 return 0; 6827 6828 Matched = Specialization; 6829 } 6830 6831 return Matched; 6832} 6833 6834/// \brief Add a single candidate to the overload set. 6835static void AddOverloadedCallCandidate(Sema &S, 6836 DeclAccessPair FoundDecl, 6837 const TemplateArgumentListInfo *ExplicitTemplateArgs, 6838 Expr **Args, unsigned NumArgs, 6839 OverloadCandidateSet &CandidateSet, 6840 bool PartialOverloading) { 6841 NamedDecl *Callee = FoundDecl.getDecl(); 6842 if (isa<UsingShadowDecl>(Callee)) 6843 Callee = cast<UsingShadowDecl>(Callee)->getTargetDecl(); 6844 6845 if (FunctionDecl *Func = dyn_cast<FunctionDecl>(Callee)) { 6846 assert(!ExplicitTemplateArgs && "Explicit template arguments?"); 6847 S.AddOverloadCandidate(Func, FoundDecl, Args, NumArgs, CandidateSet, 6848 false, PartialOverloading); 6849 return; 6850 } 6851 6852 if (FunctionTemplateDecl *FuncTemplate 6853 = dyn_cast<FunctionTemplateDecl>(Callee)) { 6854 S.AddTemplateOverloadCandidate(FuncTemplate, FoundDecl, 6855 ExplicitTemplateArgs, 6856 Args, NumArgs, CandidateSet); 6857 return; 6858 } 6859 6860 assert(false && "unhandled case in overloaded call candidate"); 6861 6862 // do nothing? 6863} 6864 6865/// \brief Add the overload candidates named by callee and/or found by argument 6866/// dependent lookup to the given overload set. 6867void Sema::AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE, 6868 Expr **Args, unsigned NumArgs, 6869 OverloadCandidateSet &CandidateSet, 6870 bool PartialOverloading) { 6871 6872#ifndef NDEBUG 6873 // Verify that ArgumentDependentLookup is consistent with the rules 6874 // in C++0x [basic.lookup.argdep]p3: 6875 // 6876 // Let X be the lookup set produced by unqualified lookup (3.4.1) 6877 // and let Y be the lookup set produced by argument dependent 6878 // lookup (defined as follows). If X contains 6879 // 6880 // -- a declaration of a class member, or 6881 // 6882 // -- a block-scope function declaration that is not a 6883 // using-declaration, or 6884 // 6885 // -- a declaration that is neither a function or a function 6886 // template 6887 // 6888 // then Y is empty. 6889 6890 if (ULE->requiresADL()) { 6891 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(), 6892 E = ULE->decls_end(); I != E; ++I) { 6893 assert(!(*I)->getDeclContext()->isRecord()); 6894 assert(isa<UsingShadowDecl>(*I) || 6895 !(*I)->getDeclContext()->isFunctionOrMethod()); 6896 assert((*I)->getUnderlyingDecl()->isFunctionOrFunctionTemplate()); 6897 } 6898 } 6899#endif 6900 6901 // It would be nice to avoid this copy. 6902 TemplateArgumentListInfo TABuffer; 6903 const TemplateArgumentListInfo *ExplicitTemplateArgs = 0; 6904 if (ULE->hasExplicitTemplateArgs()) { 6905 ULE->copyTemplateArgumentsInto(TABuffer); 6906 ExplicitTemplateArgs = &TABuffer; 6907 } 6908 6909 for (UnresolvedLookupExpr::decls_iterator I = ULE->decls_begin(), 6910 E = ULE->decls_end(); I != E; ++I) 6911 AddOverloadedCallCandidate(*this, I.getPair(), ExplicitTemplateArgs, 6912 Args, NumArgs, CandidateSet, 6913 PartialOverloading); 6914 6915 if (ULE->requiresADL()) 6916 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false, 6917 Args, NumArgs, 6918 ExplicitTemplateArgs, 6919 CandidateSet, 6920 PartialOverloading); 6921} 6922 6923/// Attempts to recover from a call where no functions were found. 6924/// 6925/// Returns true if new candidates were found. 6926static ExprResult 6927BuildRecoveryCallExpr(Sema &SemaRef, Scope *S, Expr *Fn, 6928 UnresolvedLookupExpr *ULE, 6929 SourceLocation LParenLoc, 6930 Expr **Args, unsigned NumArgs, 6931 SourceLocation RParenLoc) { 6932 6933 CXXScopeSpec SS; 6934 if (ULE->getQualifier()) { 6935 SS.setScopeRep(ULE->getQualifier()); 6936 SS.setRange(ULE->getQualifierRange()); 6937 } 6938 6939 TemplateArgumentListInfo TABuffer; 6940 const TemplateArgumentListInfo *ExplicitTemplateArgs = 0; 6941 if (ULE->hasExplicitTemplateArgs()) { 6942 ULE->copyTemplateArgumentsInto(TABuffer); 6943 ExplicitTemplateArgs = &TABuffer; 6944 } 6945 6946 LookupResult R(SemaRef, ULE->getName(), ULE->getNameLoc(), 6947 Sema::LookupOrdinaryName); 6948 if (SemaRef.DiagnoseEmptyLookup(S, SS, R, Sema::CTC_Expression)) 6949 return ExprError(); 6950 6951 assert(!R.empty() && "lookup results empty despite recovery"); 6952 6953 // Build an implicit member call if appropriate. Just drop the 6954 // casts and such from the call, we don't really care. 6955 ExprResult NewFn = ExprError(); 6956 if ((*R.begin())->isCXXClassMember()) 6957 NewFn = SemaRef.BuildPossibleImplicitMemberExpr(SS, R, ExplicitTemplateArgs); 6958 else if (ExplicitTemplateArgs) 6959 NewFn = SemaRef.BuildTemplateIdExpr(SS, R, false, *ExplicitTemplateArgs); 6960 else 6961 NewFn = SemaRef.BuildDeclarationNameExpr(SS, R, false); 6962 6963 if (NewFn.isInvalid()) 6964 return ExprError(); 6965 6966 // This shouldn't cause an infinite loop because we're giving it 6967 // an expression with non-empty lookup results, which should never 6968 // end up here. 6969 return SemaRef.ActOnCallExpr(/*Scope*/ 0, NewFn.take(), LParenLoc, 6970 MultiExprArg(Args, NumArgs), RParenLoc); 6971} 6972 6973/// ResolveOverloadedCallFn - Given the call expression that calls Fn 6974/// (which eventually refers to the declaration Func) and the call 6975/// arguments Args/NumArgs, attempt to resolve the function call down 6976/// to a specific function. If overload resolution succeeds, returns 6977/// the function declaration produced by overload 6978/// resolution. Otherwise, emits diagnostics, deletes all of the 6979/// arguments and Fn, and returns NULL. 6980ExprResult 6981Sema::BuildOverloadedCallExpr(Scope *S, Expr *Fn, UnresolvedLookupExpr *ULE, 6982 SourceLocation LParenLoc, 6983 Expr **Args, unsigned NumArgs, 6984 SourceLocation RParenLoc) { 6985#ifndef NDEBUG 6986 if (ULE->requiresADL()) { 6987 // To do ADL, we must have found an unqualified name. 6988 assert(!ULE->getQualifier() && "qualified name with ADL"); 6989 6990 // We don't perform ADL for implicit declarations of builtins. 6991 // Verify that this was correctly set up. 6992 FunctionDecl *F; 6993 if (ULE->decls_begin() + 1 == ULE->decls_end() && 6994 (F = dyn_cast<FunctionDecl>(*ULE->decls_begin())) && 6995 F->getBuiltinID() && F->isImplicit()) 6996 assert(0 && "performing ADL for builtin"); 6997 6998 // We don't perform ADL in C. 6999 assert(getLangOptions().CPlusPlus && "ADL enabled in C"); 7000 } 7001#endif 7002 7003 OverloadCandidateSet CandidateSet(Fn->getExprLoc()); 7004 7005 // Add the functions denoted by the callee to the set of candidate 7006 // functions, including those from argument-dependent lookup. 7007 AddOverloadedCallCandidates(ULE, Args, NumArgs, CandidateSet); 7008 7009 // If we found nothing, try to recover. 7010 // AddRecoveryCallCandidates diagnoses the error itself, so we just 7011 // bailout out if it fails. 7012 if (CandidateSet.empty()) 7013 return BuildRecoveryCallExpr(*this, S, Fn, ULE, LParenLoc, Args, NumArgs, 7014 RParenLoc); 7015 7016 OverloadCandidateSet::iterator Best; 7017 switch (CandidateSet.BestViableFunction(*this, Fn->getLocStart(), Best)) { 7018 case OR_Success: { 7019 FunctionDecl *FDecl = Best->Function; 7020 CheckUnresolvedLookupAccess(ULE, Best->FoundDecl); 7021 DiagnoseUseOfDecl(FDecl? FDecl : Best->FoundDecl.getDecl(), ULE->getNameLoc()); 7022 Fn = FixOverloadedFunctionReference(Fn, Best->FoundDecl, FDecl); 7023 return BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, NumArgs, RParenLoc); 7024 } 7025 7026 case OR_No_Viable_Function: 7027 Diag(Fn->getSourceRange().getBegin(), 7028 diag::err_ovl_no_viable_function_in_call) 7029 << ULE->getName() << Fn->getSourceRange(); 7030 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7031 break; 7032 7033 case OR_Ambiguous: 7034 Diag(Fn->getSourceRange().getBegin(), diag::err_ovl_ambiguous_call) 7035 << ULE->getName() << Fn->getSourceRange(); 7036 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args, NumArgs); 7037 break; 7038 7039 case OR_Deleted: 7040 Diag(Fn->getSourceRange().getBegin(), diag::err_ovl_deleted_call) 7041 << Best->Function->isDeleted() 7042 << ULE->getName() 7043 << Fn->getSourceRange(); 7044 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7045 break; 7046 } 7047 7048 // Overload resolution failed. 7049 return ExprError(); 7050} 7051 7052static bool IsOverloaded(const UnresolvedSetImpl &Functions) { 7053 return Functions.size() > 1 || 7054 (Functions.size() == 1 && isa<FunctionTemplateDecl>(*Functions.begin())); 7055} 7056 7057/// \brief Create a unary operation that may resolve to an overloaded 7058/// operator. 7059/// 7060/// \param OpLoc The location of the operator itself (e.g., '*'). 7061/// 7062/// \param OpcIn The UnaryOperator::Opcode that describes this 7063/// operator. 7064/// 7065/// \param Functions The set of non-member functions that will be 7066/// considered by overload resolution. The caller needs to build this 7067/// set based on the context using, e.g., 7068/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This 7069/// set should not contain any member functions; those will be added 7070/// by CreateOverloadedUnaryOp(). 7071/// 7072/// \param input The input argument. 7073ExprResult 7074Sema::CreateOverloadedUnaryOp(SourceLocation OpLoc, unsigned OpcIn, 7075 const UnresolvedSetImpl &Fns, 7076 Expr *Input) { 7077 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn); 7078 7079 OverloadedOperatorKind Op = UnaryOperator::getOverloadedOperator(Opc); 7080 assert(Op != OO_None && "Invalid opcode for overloaded unary operator"); 7081 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 7082 // TODO: provide better source location info. 7083 DeclarationNameInfo OpNameInfo(OpName, OpLoc); 7084 7085 if (Input->getObjectKind() == OK_ObjCProperty) 7086 ConvertPropertyForRValue(Input); 7087 7088 Expr *Args[2] = { Input, 0 }; 7089 unsigned NumArgs = 1; 7090 7091 // For post-increment and post-decrement, add the implicit '0' as 7092 // the second argument, so that we know this is a post-increment or 7093 // post-decrement. 7094 if (Opc == UO_PostInc || Opc == UO_PostDec) { 7095 llvm::APSInt Zero(Context.getTypeSize(Context.IntTy), false); 7096 Args[1] = IntegerLiteral::Create(Context, Zero, Context.IntTy, 7097 SourceLocation()); 7098 NumArgs = 2; 7099 } 7100 7101 if (Input->isTypeDependent()) { 7102 if (Fns.empty()) 7103 return Owned(new (Context) UnaryOperator(Input, 7104 Opc, 7105 Context.DependentTy, 7106 VK_RValue, OK_Ordinary, 7107 OpLoc)); 7108 7109 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators 7110 UnresolvedLookupExpr *Fn 7111 = UnresolvedLookupExpr::Create(Context, /*Dependent*/ true, NamingClass, 7112 0, SourceRange(), OpNameInfo, 7113 /*ADL*/ true, IsOverloaded(Fns), 7114 Fns.begin(), Fns.end()); 7115 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, 7116 &Args[0], NumArgs, 7117 Context.DependentTy, 7118 VK_RValue, 7119 OpLoc)); 7120 } 7121 7122 // Build an empty overload set. 7123 OverloadCandidateSet CandidateSet(OpLoc); 7124 7125 // Add the candidates from the given function set. 7126 AddFunctionCandidates(Fns, &Args[0], NumArgs, CandidateSet, false); 7127 7128 // Add operator candidates that are member functions. 7129 AddMemberOperatorCandidates(Op, OpLoc, &Args[0], NumArgs, CandidateSet); 7130 7131 // Add candidates from ADL. 7132 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true, 7133 Args, NumArgs, 7134 /*ExplicitTemplateArgs*/ 0, 7135 CandidateSet); 7136 7137 // Add builtin operator candidates. 7138 AddBuiltinOperatorCandidates(Op, OpLoc, &Args[0], NumArgs, CandidateSet); 7139 7140 // Perform overload resolution. 7141 OverloadCandidateSet::iterator Best; 7142 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) { 7143 case OR_Success: { 7144 // We found a built-in operator or an overloaded operator. 7145 FunctionDecl *FnDecl = Best->Function; 7146 7147 if (FnDecl) { 7148 // We matched an overloaded operator. Build a call to that 7149 // operator. 7150 7151 // Convert the arguments. 7152 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) { 7153 CheckMemberOperatorAccess(OpLoc, Args[0], 0, Best->FoundDecl); 7154 7155 if (PerformObjectArgumentInitialization(Input, /*Qualifier=*/0, 7156 Best->FoundDecl, Method)) 7157 return ExprError(); 7158 } else { 7159 // Convert the arguments. 7160 ExprResult InputInit 7161 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 7162 Context, 7163 FnDecl->getParamDecl(0)), 7164 SourceLocation(), 7165 Input); 7166 if (InputInit.isInvalid()) 7167 return ExprError(); 7168 Input = InputInit.take(); 7169 } 7170 7171 DiagnoseUseOfDecl(Best->FoundDecl, OpLoc); 7172 7173 // Determine the result type. 7174 QualType ResultTy = FnDecl->getResultType(); 7175 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 7176 ResultTy = ResultTy.getNonLValueExprType(Context); 7177 7178 // Build the actual expression node. 7179 Expr *FnExpr = CreateFunctionRefExpr(*this, FnDecl); 7180 7181 Args[0] = Input; 7182 CallExpr *TheCall = 7183 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr, 7184 Args, NumArgs, ResultTy, VK, OpLoc); 7185 7186 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall, 7187 FnDecl)) 7188 return ExprError(); 7189 7190 return MaybeBindToTemporary(TheCall); 7191 } else { 7192 // We matched a built-in operator. Convert the arguments, then 7193 // break out so that we will build the appropriate built-in 7194 // operator node. 7195 if (PerformImplicitConversion(Input, Best->BuiltinTypes.ParamTypes[0], 7196 Best->Conversions[0], AA_Passing)) 7197 return ExprError(); 7198 7199 break; 7200 } 7201 } 7202 7203 case OR_No_Viable_Function: 7204 // No viable function; fall through to handling this as a 7205 // built-in operator, which will produce an error message for us. 7206 break; 7207 7208 case OR_Ambiguous: 7209 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary) 7210 << UnaryOperator::getOpcodeStr(Opc) 7211 << Input->getType() 7212 << Input->getSourceRange(); 7213 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, 7214 Args, NumArgs, 7215 UnaryOperator::getOpcodeStr(Opc), OpLoc); 7216 return ExprError(); 7217 7218 case OR_Deleted: 7219 Diag(OpLoc, diag::err_ovl_deleted_oper) 7220 << Best->Function->isDeleted() 7221 << UnaryOperator::getOpcodeStr(Opc) 7222 << Input->getSourceRange(); 7223 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7224 return ExprError(); 7225 } 7226 7227 // Either we found no viable overloaded operator or we matched a 7228 // built-in operator. In either case, fall through to trying to 7229 // build a built-in operation. 7230 return CreateBuiltinUnaryOp(OpLoc, Opc, Input); 7231} 7232 7233/// \brief Create a binary operation that may resolve to an overloaded 7234/// operator. 7235/// 7236/// \param OpLoc The location of the operator itself (e.g., '+'). 7237/// 7238/// \param OpcIn The BinaryOperator::Opcode that describes this 7239/// operator. 7240/// 7241/// \param Functions The set of non-member functions that will be 7242/// considered by overload resolution. The caller needs to build this 7243/// set based on the context using, e.g., 7244/// LookupOverloadedOperatorName() and ArgumentDependentLookup(). This 7245/// set should not contain any member functions; those will be added 7246/// by CreateOverloadedBinOp(). 7247/// 7248/// \param LHS Left-hand argument. 7249/// \param RHS Right-hand argument. 7250ExprResult 7251Sema::CreateOverloadedBinOp(SourceLocation OpLoc, 7252 unsigned OpcIn, 7253 const UnresolvedSetImpl &Fns, 7254 Expr *LHS, Expr *RHS) { 7255 Expr *Args[2] = { LHS, RHS }; 7256 LHS=RHS=0; //Please use only Args instead of LHS/RHS couple 7257 7258 BinaryOperator::Opcode Opc = static_cast<BinaryOperator::Opcode>(OpcIn); 7259 OverloadedOperatorKind Op = BinaryOperator::getOverloadedOperator(Opc); 7260 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(Op); 7261 7262 // If either side is type-dependent, create an appropriate dependent 7263 // expression. 7264 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) { 7265 if (Fns.empty()) { 7266 // If there are no functions to store, just build a dependent 7267 // BinaryOperator or CompoundAssignment. 7268 if (Opc <= BO_Assign || Opc > BO_OrAssign) 7269 return Owned(new (Context) BinaryOperator(Args[0], Args[1], Opc, 7270 Context.DependentTy, 7271 VK_RValue, OK_Ordinary, 7272 OpLoc)); 7273 7274 return Owned(new (Context) CompoundAssignOperator(Args[0], Args[1], Opc, 7275 Context.DependentTy, 7276 VK_LValue, 7277 OK_Ordinary, 7278 Context.DependentTy, 7279 Context.DependentTy, 7280 OpLoc)); 7281 } 7282 7283 // FIXME: save results of ADL from here? 7284 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators 7285 // TODO: provide better source location info in DNLoc component. 7286 DeclarationNameInfo OpNameInfo(OpName, OpLoc); 7287 UnresolvedLookupExpr *Fn 7288 = UnresolvedLookupExpr::Create(Context, /*Dependent*/ true, NamingClass, 7289 0, SourceRange(), OpNameInfo, 7290 /*ADL*/ true, IsOverloaded(Fns), 7291 Fns.begin(), Fns.end()); 7292 return Owned(new (Context) CXXOperatorCallExpr(Context, Op, Fn, 7293 Args, 2, 7294 Context.DependentTy, 7295 VK_RValue, 7296 OpLoc)); 7297 } 7298 7299 // Always do property rvalue conversions on the RHS. 7300 if (Args[1]->getObjectKind() == OK_ObjCProperty) 7301 ConvertPropertyForRValue(Args[1]); 7302 7303 // The LHS is more complicated. 7304 if (Args[0]->getObjectKind() == OK_ObjCProperty) { 7305 7306 // There's a tension for assignment operators between primitive 7307 // property assignment and the overloaded operators. 7308 if (BinaryOperator::isAssignmentOp(Opc)) { 7309 const ObjCPropertyRefExpr *PRE = LHS->getObjCProperty(); 7310 7311 // Is the property "logically" settable? 7312 bool Settable = (PRE->isExplicitProperty() || 7313 PRE->getImplicitPropertySetter()); 7314 7315 // To avoid gratuitously inventing semantics, use the primitive 7316 // unless it isn't. Thoughts in case we ever really care: 7317 // - If the property isn't logically settable, we have to 7318 // load and hope. 7319 // - If the property is settable and this is simple assignment, 7320 // we really should use the primitive. 7321 // - If the property is settable, then we could try overloading 7322 // on a generic lvalue of the appropriate type; if it works 7323 // out to a builtin candidate, we would do that same operation 7324 // on the property, and otherwise just error. 7325 if (Settable) 7326 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 7327 } 7328 7329 ConvertPropertyForRValue(Args[0]); 7330 } 7331 7332 // If this is the assignment operator, we only perform overload resolution 7333 // if the left-hand side is a class or enumeration type. This is actually 7334 // a hack. The standard requires that we do overload resolution between the 7335 // various built-in candidates, but as DR507 points out, this can lead to 7336 // problems. So we do it this way, which pretty much follows what GCC does. 7337 // Note that we go the traditional code path for compound assignment forms. 7338 if (Opc == BO_Assign && !Args[0]->getType()->isOverloadableType()) 7339 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 7340 7341 // If this is the .* operator, which is not overloadable, just 7342 // create a built-in binary operator. 7343 if (Opc == BO_PtrMemD) 7344 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 7345 7346 // Build an empty overload set. 7347 OverloadCandidateSet CandidateSet(OpLoc); 7348 7349 // Add the candidates from the given function set. 7350 AddFunctionCandidates(Fns, Args, 2, CandidateSet, false); 7351 7352 // Add operator candidates that are member functions. 7353 AddMemberOperatorCandidates(Op, OpLoc, Args, 2, CandidateSet); 7354 7355 // Add candidates from ADL. 7356 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true, 7357 Args, 2, 7358 /*ExplicitTemplateArgs*/ 0, 7359 CandidateSet); 7360 7361 // Add builtin operator candidates. 7362 AddBuiltinOperatorCandidates(Op, OpLoc, Args, 2, CandidateSet); 7363 7364 // Perform overload resolution. 7365 OverloadCandidateSet::iterator Best; 7366 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) { 7367 case OR_Success: { 7368 // We found a built-in operator or an overloaded operator. 7369 FunctionDecl *FnDecl = Best->Function; 7370 7371 if (FnDecl) { 7372 // We matched an overloaded operator. Build a call to that 7373 // operator. 7374 7375 // Convert the arguments. 7376 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) { 7377 // Best->Access is only meaningful for class members. 7378 CheckMemberOperatorAccess(OpLoc, Args[0], Args[1], Best->FoundDecl); 7379 7380 ExprResult Arg1 7381 = PerformCopyInitialization( 7382 InitializedEntity::InitializeParameter( 7383 Context, 7384 FnDecl->getParamDecl(0)), 7385 SourceLocation(), 7386 Owned(Args[1])); 7387 if (Arg1.isInvalid()) 7388 return ExprError(); 7389 7390 if (PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0, 7391 Best->FoundDecl, Method)) 7392 return ExprError(); 7393 7394 Args[1] = RHS = Arg1.takeAs<Expr>(); 7395 } else { 7396 // Convert the arguments. 7397 ExprResult Arg0 7398 = PerformCopyInitialization( 7399 InitializedEntity::InitializeParameter( 7400 Context, 7401 FnDecl->getParamDecl(0)), 7402 SourceLocation(), 7403 Owned(Args[0])); 7404 if (Arg0.isInvalid()) 7405 return ExprError(); 7406 7407 ExprResult Arg1 7408 = PerformCopyInitialization( 7409 InitializedEntity::InitializeParameter( 7410 Context, 7411 FnDecl->getParamDecl(1)), 7412 SourceLocation(), 7413 Owned(Args[1])); 7414 if (Arg1.isInvalid()) 7415 return ExprError(); 7416 Args[0] = LHS = Arg0.takeAs<Expr>(); 7417 Args[1] = RHS = Arg1.takeAs<Expr>(); 7418 } 7419 7420 DiagnoseUseOfDecl(Best->FoundDecl, OpLoc); 7421 7422 // Determine the result type. 7423 QualType ResultTy = FnDecl->getResultType(); 7424 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 7425 ResultTy = ResultTy.getNonLValueExprType(Context); 7426 7427 // Build the actual expression node. 7428 Expr *FnExpr = CreateFunctionRefExpr(*this, FnDecl, OpLoc); 7429 7430 CXXOperatorCallExpr *TheCall = 7431 new (Context) CXXOperatorCallExpr(Context, Op, FnExpr, 7432 Args, 2, ResultTy, VK, OpLoc); 7433 7434 if (CheckCallReturnType(FnDecl->getResultType(), OpLoc, TheCall, 7435 FnDecl)) 7436 return ExprError(); 7437 7438 return MaybeBindToTemporary(TheCall); 7439 } else { 7440 // We matched a built-in operator. Convert the arguments, then 7441 // break out so that we will build the appropriate built-in 7442 // operator node. 7443 if (PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0], 7444 Best->Conversions[0], AA_Passing) || 7445 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1], 7446 Best->Conversions[1], AA_Passing)) 7447 return ExprError(); 7448 7449 break; 7450 } 7451 } 7452 7453 case OR_No_Viable_Function: { 7454 // C++ [over.match.oper]p9: 7455 // If the operator is the operator , [...] and there are no 7456 // viable functions, then the operator is assumed to be the 7457 // built-in operator and interpreted according to clause 5. 7458 if (Opc == BO_Comma) 7459 break; 7460 7461 // For class as left operand for assignment or compound assigment operator 7462 // do not fall through to handling in built-in, but report that no overloaded 7463 // assignment operator found 7464 ExprResult Result = ExprError(); 7465 if (Args[0]->getType()->isRecordType() && 7466 Opc >= BO_Assign && Opc <= BO_OrAssign) { 7467 Diag(OpLoc, diag::err_ovl_no_viable_oper) 7468 << BinaryOperator::getOpcodeStr(Opc) 7469 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7470 } else { 7471 // No viable function; try to create a built-in operation, which will 7472 // produce an error. Then, show the non-viable candidates. 7473 Result = CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 7474 } 7475 assert(Result.isInvalid() && 7476 "C++ binary operator overloading is missing candidates!"); 7477 if (Result.isInvalid()) 7478 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 2, 7479 BinaryOperator::getOpcodeStr(Opc), OpLoc); 7480 return move(Result); 7481 } 7482 7483 case OR_Ambiguous: 7484 Diag(OpLoc, diag::err_ovl_ambiguous_oper_binary) 7485 << BinaryOperator::getOpcodeStr(Opc) 7486 << Args[0]->getType() << Args[1]->getType() 7487 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7488 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args, 2, 7489 BinaryOperator::getOpcodeStr(Opc), OpLoc); 7490 return ExprError(); 7491 7492 case OR_Deleted: 7493 Diag(OpLoc, diag::err_ovl_deleted_oper) 7494 << Best->Function->isDeleted() 7495 << BinaryOperator::getOpcodeStr(Opc) 7496 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7497 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 2); 7498 return ExprError(); 7499 } 7500 7501 // We matched a built-in operator; build it. 7502 return CreateBuiltinBinOp(OpLoc, Opc, Args[0], Args[1]); 7503} 7504 7505ExprResult 7506Sema::CreateOverloadedArraySubscriptExpr(SourceLocation LLoc, 7507 SourceLocation RLoc, 7508 Expr *Base, Expr *Idx) { 7509 Expr *Args[2] = { Base, Idx }; 7510 DeclarationName OpName = 7511 Context.DeclarationNames.getCXXOperatorName(OO_Subscript); 7512 7513 // If either side is type-dependent, create an appropriate dependent 7514 // expression. 7515 if (Args[0]->isTypeDependent() || Args[1]->isTypeDependent()) { 7516 7517 CXXRecordDecl *NamingClass = 0; // because lookup ignores member operators 7518 // CHECKME: no 'operator' keyword? 7519 DeclarationNameInfo OpNameInfo(OpName, LLoc); 7520 OpNameInfo.setCXXOperatorNameRange(SourceRange(LLoc, RLoc)); 7521 UnresolvedLookupExpr *Fn 7522 = UnresolvedLookupExpr::Create(Context, /*Dependent*/ true, NamingClass, 7523 0, SourceRange(), OpNameInfo, 7524 /*ADL*/ true, /*Overloaded*/ false, 7525 UnresolvedSetIterator(), 7526 UnresolvedSetIterator()); 7527 // Can't add any actual overloads yet 7528 7529 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript, Fn, 7530 Args, 2, 7531 Context.DependentTy, 7532 VK_RValue, 7533 RLoc)); 7534 } 7535 7536 if (Args[0]->getObjectKind() == OK_ObjCProperty) 7537 ConvertPropertyForRValue(Args[0]); 7538 if (Args[1]->getObjectKind() == OK_ObjCProperty) 7539 ConvertPropertyForRValue(Args[1]); 7540 7541 // Build an empty overload set. 7542 OverloadCandidateSet CandidateSet(LLoc); 7543 7544 // Subscript can only be overloaded as a member function. 7545 7546 // Add operator candidates that are member functions. 7547 AddMemberOperatorCandidates(OO_Subscript, LLoc, Args, 2, CandidateSet); 7548 7549 // Add builtin operator candidates. 7550 AddBuiltinOperatorCandidates(OO_Subscript, LLoc, Args, 2, CandidateSet); 7551 7552 // Perform overload resolution. 7553 OverloadCandidateSet::iterator Best; 7554 switch (CandidateSet.BestViableFunction(*this, LLoc, Best)) { 7555 case OR_Success: { 7556 // We found a built-in operator or an overloaded operator. 7557 FunctionDecl *FnDecl = Best->Function; 7558 7559 if (FnDecl) { 7560 // We matched an overloaded operator. Build a call to that 7561 // operator. 7562 7563 CheckMemberOperatorAccess(LLoc, Args[0], Args[1], Best->FoundDecl); 7564 DiagnoseUseOfDecl(Best->FoundDecl, LLoc); 7565 7566 // Convert the arguments. 7567 CXXMethodDecl *Method = cast<CXXMethodDecl>(FnDecl); 7568 if (PerformObjectArgumentInitialization(Args[0], /*Qualifier=*/0, 7569 Best->FoundDecl, Method)) 7570 return ExprError(); 7571 7572 // Convert the arguments. 7573 ExprResult InputInit 7574 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 7575 Context, 7576 FnDecl->getParamDecl(0)), 7577 SourceLocation(), 7578 Owned(Args[1])); 7579 if (InputInit.isInvalid()) 7580 return ExprError(); 7581 7582 Args[1] = InputInit.takeAs<Expr>(); 7583 7584 // Determine the result type 7585 QualType ResultTy = FnDecl->getResultType(); 7586 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 7587 ResultTy = ResultTy.getNonLValueExprType(Context); 7588 7589 // Build the actual expression node. 7590 Expr *FnExpr = CreateFunctionRefExpr(*this, FnDecl, LLoc); 7591 7592 CXXOperatorCallExpr *TheCall = 7593 new (Context) CXXOperatorCallExpr(Context, OO_Subscript, 7594 FnExpr, Args, 2, 7595 ResultTy, VK, RLoc); 7596 7597 if (CheckCallReturnType(FnDecl->getResultType(), LLoc, TheCall, 7598 FnDecl)) 7599 return ExprError(); 7600 7601 return MaybeBindToTemporary(TheCall); 7602 } else { 7603 // We matched a built-in operator. Convert the arguments, then 7604 // break out so that we will build the appropriate built-in 7605 // operator node. 7606 if (PerformImplicitConversion(Args[0], Best->BuiltinTypes.ParamTypes[0], 7607 Best->Conversions[0], AA_Passing) || 7608 PerformImplicitConversion(Args[1], Best->BuiltinTypes.ParamTypes[1], 7609 Best->Conversions[1], AA_Passing)) 7610 return ExprError(); 7611 7612 break; 7613 } 7614 } 7615 7616 case OR_No_Viable_Function: { 7617 if (CandidateSet.empty()) 7618 Diag(LLoc, diag::err_ovl_no_oper) 7619 << Args[0]->getType() << /*subscript*/ 0 7620 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7621 else 7622 Diag(LLoc, diag::err_ovl_no_viable_subscript) 7623 << Args[0]->getType() 7624 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7625 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 2, 7626 "[]", LLoc); 7627 return ExprError(); 7628 } 7629 7630 case OR_Ambiguous: 7631 Diag(LLoc, diag::err_ovl_ambiguous_oper_binary) 7632 << "[]" 7633 << Args[0]->getType() << Args[1]->getType() 7634 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7635 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args, 2, 7636 "[]", LLoc); 7637 return ExprError(); 7638 7639 case OR_Deleted: 7640 Diag(LLoc, diag::err_ovl_deleted_oper) 7641 << Best->Function->isDeleted() << "[]" 7642 << Args[0]->getSourceRange() << Args[1]->getSourceRange(); 7643 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, 2, 7644 "[]", LLoc); 7645 return ExprError(); 7646 } 7647 7648 // We matched a built-in operator; build it. 7649 return CreateBuiltinArraySubscriptExpr(Args[0], LLoc, Args[1], RLoc); 7650} 7651 7652/// BuildCallToMemberFunction - Build a call to a member 7653/// function. MemExpr is the expression that refers to the member 7654/// function (and includes the object parameter), Args/NumArgs are the 7655/// arguments to the function call (not including the object 7656/// parameter). The caller needs to validate that the member 7657/// expression refers to a member function or an overloaded member 7658/// function. 7659ExprResult 7660Sema::BuildCallToMemberFunction(Scope *S, Expr *MemExprE, 7661 SourceLocation LParenLoc, Expr **Args, 7662 unsigned NumArgs, SourceLocation RParenLoc) { 7663 // Dig out the member expression. This holds both the object 7664 // argument and the member function we're referring to. 7665 Expr *NakedMemExpr = MemExprE->IgnoreParens(); 7666 7667 MemberExpr *MemExpr; 7668 CXXMethodDecl *Method = 0; 7669 DeclAccessPair FoundDecl = DeclAccessPair::make(0, AS_public); 7670 NestedNameSpecifier *Qualifier = 0; 7671 if (isa<MemberExpr>(NakedMemExpr)) { 7672 MemExpr = cast<MemberExpr>(NakedMemExpr); 7673 Method = cast<CXXMethodDecl>(MemExpr->getMemberDecl()); 7674 FoundDecl = MemExpr->getFoundDecl(); 7675 Qualifier = MemExpr->getQualifier(); 7676 } else { 7677 UnresolvedMemberExpr *UnresExpr = cast<UnresolvedMemberExpr>(NakedMemExpr); 7678 Qualifier = UnresExpr->getQualifier(); 7679 7680 QualType ObjectType = UnresExpr->getBaseType(); 7681 7682 // Add overload candidates 7683 OverloadCandidateSet CandidateSet(UnresExpr->getMemberLoc()); 7684 7685 // FIXME: avoid copy. 7686 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0; 7687 if (UnresExpr->hasExplicitTemplateArgs()) { 7688 UnresExpr->copyTemplateArgumentsInto(TemplateArgsBuffer); 7689 TemplateArgs = &TemplateArgsBuffer; 7690 } 7691 7692 for (UnresolvedMemberExpr::decls_iterator I = UnresExpr->decls_begin(), 7693 E = UnresExpr->decls_end(); I != E; ++I) { 7694 7695 NamedDecl *Func = *I; 7696 CXXRecordDecl *ActingDC = cast<CXXRecordDecl>(Func->getDeclContext()); 7697 if (isa<UsingShadowDecl>(Func)) 7698 Func = cast<UsingShadowDecl>(Func)->getTargetDecl(); 7699 7700 if ((Method = dyn_cast<CXXMethodDecl>(Func))) { 7701 // If explicit template arguments were provided, we can't call a 7702 // non-template member function. 7703 if (TemplateArgs) 7704 continue; 7705 7706 AddMethodCandidate(Method, I.getPair(), ActingDC, ObjectType, 7707 Args, NumArgs, 7708 CandidateSet, /*SuppressUserConversions=*/false); 7709 } else { 7710 AddMethodTemplateCandidate(cast<FunctionTemplateDecl>(Func), 7711 I.getPair(), ActingDC, TemplateArgs, 7712 ObjectType, Args, NumArgs, 7713 CandidateSet, 7714 /*SuppressUsedConversions=*/false); 7715 } 7716 } 7717 7718 DeclarationName DeclName = UnresExpr->getMemberName(); 7719 7720 OverloadCandidateSet::iterator Best; 7721 switch (CandidateSet.BestViableFunction(*this, UnresExpr->getLocStart(), 7722 Best)) { 7723 case OR_Success: 7724 Method = cast<CXXMethodDecl>(Best->Function); 7725 FoundDecl = Best->FoundDecl; 7726 CheckUnresolvedMemberAccess(UnresExpr, Best->FoundDecl); 7727 DiagnoseUseOfDecl(Best->FoundDecl, UnresExpr->getNameLoc()); 7728 break; 7729 7730 case OR_No_Viable_Function: 7731 Diag(UnresExpr->getMemberLoc(), 7732 diag::err_ovl_no_viable_member_function_in_call) 7733 << DeclName << MemExprE->getSourceRange(); 7734 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7735 // FIXME: Leaking incoming expressions! 7736 return ExprError(); 7737 7738 case OR_Ambiguous: 7739 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_ambiguous_member_call) 7740 << DeclName << MemExprE->getSourceRange(); 7741 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7742 // FIXME: Leaking incoming expressions! 7743 return ExprError(); 7744 7745 case OR_Deleted: 7746 Diag(UnresExpr->getMemberLoc(), diag::err_ovl_deleted_member_call) 7747 << Best->Function->isDeleted() 7748 << DeclName << MemExprE->getSourceRange(); 7749 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7750 // FIXME: Leaking incoming expressions! 7751 return ExprError(); 7752 } 7753 7754 MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method); 7755 7756 // If overload resolution picked a static member, build a 7757 // non-member call based on that function. 7758 if (Method->isStatic()) { 7759 return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, 7760 Args, NumArgs, RParenLoc); 7761 } 7762 7763 MemExpr = cast<MemberExpr>(MemExprE->IgnoreParens()); 7764 } 7765 7766 QualType ResultType = Method->getResultType(); 7767 ExprValueKind VK = Expr::getValueKindForType(ResultType); 7768 ResultType = ResultType.getNonLValueExprType(Context); 7769 7770 assert(Method && "Member call to something that isn't a method?"); 7771 CXXMemberCallExpr *TheCall = 7772 new (Context) CXXMemberCallExpr(Context, MemExprE, Args, NumArgs, 7773 ResultType, VK, RParenLoc); 7774 7775 // Check for a valid return type. 7776 if (CheckCallReturnType(Method->getResultType(), MemExpr->getMemberLoc(), 7777 TheCall, Method)) 7778 return ExprError(); 7779 7780 // Convert the object argument (for a non-static member function call). 7781 // We only need to do this if there was actually an overload; otherwise 7782 // it was done at lookup. 7783 Expr *ObjectArg = MemExpr->getBase(); 7784 if (!Method->isStatic() && 7785 PerformObjectArgumentInitialization(ObjectArg, Qualifier, 7786 FoundDecl, Method)) 7787 return ExprError(); 7788 MemExpr->setBase(ObjectArg); 7789 7790 // Convert the rest of the arguments 7791 const FunctionProtoType *Proto = Method->getType()->getAs<FunctionProtoType>(); 7792 if (ConvertArgumentsForCall(TheCall, MemExpr, Method, Proto, Args, NumArgs, 7793 RParenLoc)) 7794 return ExprError(); 7795 7796 if (CheckFunctionCall(Method, TheCall)) 7797 return ExprError(); 7798 7799 return MaybeBindToTemporary(TheCall); 7800} 7801 7802/// BuildCallToObjectOfClassType - Build a call to an object of class 7803/// type (C++ [over.call.object]), which can end up invoking an 7804/// overloaded function call operator (@c operator()) or performing a 7805/// user-defined conversion on the object argument. 7806ExprResult 7807Sema::BuildCallToObjectOfClassType(Scope *S, Expr *Object, 7808 SourceLocation LParenLoc, 7809 Expr **Args, unsigned NumArgs, 7810 SourceLocation RParenLoc) { 7811 if (Object->getObjectKind() == OK_ObjCProperty) 7812 ConvertPropertyForRValue(Object); 7813 7814 assert(Object->getType()->isRecordType() && "Requires object type argument"); 7815 const RecordType *Record = Object->getType()->getAs<RecordType>(); 7816 7817 // C++ [over.call.object]p1: 7818 // If the primary-expression E in the function call syntax 7819 // evaluates to a class object of type "cv T", then the set of 7820 // candidate functions includes at least the function call 7821 // operators of T. The function call operators of T are obtained by 7822 // ordinary lookup of the name operator() in the context of 7823 // (E).operator(). 7824 OverloadCandidateSet CandidateSet(LParenLoc); 7825 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Call); 7826 7827 if (RequireCompleteType(LParenLoc, Object->getType(), 7828 PDiag(diag::err_incomplete_object_call) 7829 << Object->getSourceRange())) 7830 return true; 7831 7832 LookupResult R(*this, OpName, LParenLoc, LookupOrdinaryName); 7833 LookupQualifiedName(R, Record->getDecl()); 7834 R.suppressDiagnostics(); 7835 7836 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end(); 7837 Oper != OperEnd; ++Oper) { 7838 AddMethodCandidate(Oper.getPair(), Object->getType(), 7839 Args, NumArgs, CandidateSet, 7840 /*SuppressUserConversions=*/ false); 7841 } 7842 7843 // C++ [over.call.object]p2: 7844 // In addition, for each conversion function declared in T of the 7845 // form 7846 // 7847 // operator conversion-type-id () cv-qualifier; 7848 // 7849 // where cv-qualifier is the same cv-qualification as, or a 7850 // greater cv-qualification than, cv, and where conversion-type-id 7851 // denotes the type "pointer to function of (P1,...,Pn) returning 7852 // R", or the type "reference to pointer to function of 7853 // (P1,...,Pn) returning R", or the type "reference to function 7854 // of (P1,...,Pn) returning R", a surrogate call function [...] 7855 // is also considered as a candidate function. Similarly, 7856 // surrogate call functions are added to the set of candidate 7857 // functions for each conversion function declared in an 7858 // accessible base class provided the function is not hidden 7859 // within T by another intervening declaration. 7860 const UnresolvedSetImpl *Conversions 7861 = cast<CXXRecordDecl>(Record->getDecl())->getVisibleConversionFunctions(); 7862 for (UnresolvedSetImpl::iterator I = Conversions->begin(), 7863 E = Conversions->end(); I != E; ++I) { 7864 NamedDecl *D = *I; 7865 CXXRecordDecl *ActingContext = cast<CXXRecordDecl>(D->getDeclContext()); 7866 if (isa<UsingShadowDecl>(D)) 7867 D = cast<UsingShadowDecl>(D)->getTargetDecl(); 7868 7869 // Skip over templated conversion functions; they aren't 7870 // surrogates. 7871 if (isa<FunctionTemplateDecl>(D)) 7872 continue; 7873 7874 CXXConversionDecl *Conv = cast<CXXConversionDecl>(D); 7875 7876 // Strip the reference type (if any) and then the pointer type (if 7877 // any) to get down to what might be a function type. 7878 QualType ConvType = Conv->getConversionType().getNonReferenceType(); 7879 if (const PointerType *ConvPtrType = ConvType->getAs<PointerType>()) 7880 ConvType = ConvPtrType->getPointeeType(); 7881 7882 if (const FunctionProtoType *Proto = ConvType->getAs<FunctionProtoType>()) 7883 AddSurrogateCandidate(Conv, I.getPair(), ActingContext, Proto, 7884 Object->getType(), Args, NumArgs, 7885 CandidateSet); 7886 } 7887 7888 // Perform overload resolution. 7889 OverloadCandidateSet::iterator Best; 7890 switch (CandidateSet.BestViableFunction(*this, Object->getLocStart(), 7891 Best)) { 7892 case OR_Success: 7893 // Overload resolution succeeded; we'll build the appropriate call 7894 // below. 7895 break; 7896 7897 case OR_No_Viable_Function: 7898 if (CandidateSet.empty()) 7899 Diag(Object->getSourceRange().getBegin(), diag::err_ovl_no_oper) 7900 << Object->getType() << /*call*/ 1 7901 << Object->getSourceRange(); 7902 else 7903 Diag(Object->getSourceRange().getBegin(), 7904 diag::err_ovl_no_viable_object_call) 7905 << Object->getType() << Object->getSourceRange(); 7906 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7907 break; 7908 7909 case OR_Ambiguous: 7910 Diag(Object->getSourceRange().getBegin(), 7911 diag::err_ovl_ambiguous_object_call) 7912 << Object->getType() << Object->getSourceRange(); 7913 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, Args, NumArgs); 7914 break; 7915 7916 case OR_Deleted: 7917 Diag(Object->getSourceRange().getBegin(), 7918 diag::err_ovl_deleted_object_call) 7919 << Best->Function->isDeleted() 7920 << Object->getType() << Object->getSourceRange(); 7921 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, Args, NumArgs); 7922 break; 7923 } 7924 7925 if (Best == CandidateSet.end()) 7926 return true; 7927 7928 if (Best->Function == 0) { 7929 // Since there is no function declaration, this is one of the 7930 // surrogate candidates. Dig out the conversion function. 7931 CXXConversionDecl *Conv 7932 = cast<CXXConversionDecl>( 7933 Best->Conversions[0].UserDefined.ConversionFunction); 7934 7935 CheckMemberOperatorAccess(LParenLoc, Object, 0, Best->FoundDecl); 7936 DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc); 7937 7938 // We selected one of the surrogate functions that converts the 7939 // object parameter to a function pointer. Perform the conversion 7940 // on the object argument, then let ActOnCallExpr finish the job. 7941 7942 // Create an implicit member expr to refer to the conversion operator. 7943 // and then call it. 7944 CXXMemberCallExpr *CE = BuildCXXMemberCallExpr(Object, Best->FoundDecl, 7945 Conv); 7946 7947 return ActOnCallExpr(S, CE, LParenLoc, MultiExprArg(Args, NumArgs), 7948 RParenLoc); 7949 } 7950 7951 CheckMemberOperatorAccess(LParenLoc, Object, 0, Best->FoundDecl); 7952 DiagnoseUseOfDecl(Best->FoundDecl, LParenLoc); 7953 7954 // We found an overloaded operator(). Build a CXXOperatorCallExpr 7955 // that calls this method, using Object for the implicit object 7956 // parameter and passing along the remaining arguments. 7957 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function); 7958 const FunctionProtoType *Proto = Method->getType()->getAs<FunctionProtoType>(); 7959 7960 unsigned NumArgsInProto = Proto->getNumArgs(); 7961 unsigned NumArgsToCheck = NumArgs; 7962 7963 // Build the full argument list for the method call (the 7964 // implicit object parameter is placed at the beginning of the 7965 // list). 7966 Expr **MethodArgs; 7967 if (NumArgs < NumArgsInProto) { 7968 NumArgsToCheck = NumArgsInProto; 7969 MethodArgs = new Expr*[NumArgsInProto + 1]; 7970 } else { 7971 MethodArgs = new Expr*[NumArgs + 1]; 7972 } 7973 MethodArgs[0] = Object; 7974 for (unsigned ArgIdx = 0; ArgIdx < NumArgs; ++ArgIdx) 7975 MethodArgs[ArgIdx + 1] = Args[ArgIdx]; 7976 7977 Expr *NewFn = CreateFunctionRefExpr(*this, Method); 7978 7979 // Once we've built TheCall, all of the expressions are properly 7980 // owned. 7981 QualType ResultTy = Method->getResultType(); 7982 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 7983 ResultTy = ResultTy.getNonLValueExprType(Context); 7984 7985 CXXOperatorCallExpr *TheCall = 7986 new (Context) CXXOperatorCallExpr(Context, OO_Call, NewFn, 7987 MethodArgs, NumArgs + 1, 7988 ResultTy, VK, RParenLoc); 7989 delete [] MethodArgs; 7990 7991 if (CheckCallReturnType(Method->getResultType(), LParenLoc, TheCall, 7992 Method)) 7993 return true; 7994 7995 // We may have default arguments. If so, we need to allocate more 7996 // slots in the call for them. 7997 if (NumArgs < NumArgsInProto) 7998 TheCall->setNumArgs(Context, NumArgsInProto + 1); 7999 else if (NumArgs > NumArgsInProto) 8000 NumArgsToCheck = NumArgsInProto; 8001 8002 bool IsError = false; 8003 8004 // Initialize the implicit object parameter. 8005 IsError |= PerformObjectArgumentInitialization(Object, /*Qualifier=*/0, 8006 Best->FoundDecl, Method); 8007 TheCall->setArg(0, Object); 8008 8009 8010 // Check the argument types. 8011 for (unsigned i = 0; i != NumArgsToCheck; i++) { 8012 Expr *Arg; 8013 if (i < NumArgs) { 8014 Arg = Args[i]; 8015 8016 // Pass the argument. 8017 8018 ExprResult InputInit 8019 = PerformCopyInitialization(InitializedEntity::InitializeParameter( 8020 Context, 8021 Method->getParamDecl(i)), 8022 SourceLocation(), Arg); 8023 8024 IsError |= InputInit.isInvalid(); 8025 Arg = InputInit.takeAs<Expr>(); 8026 } else { 8027 ExprResult DefArg 8028 = BuildCXXDefaultArgExpr(LParenLoc, Method, Method->getParamDecl(i)); 8029 if (DefArg.isInvalid()) { 8030 IsError = true; 8031 break; 8032 } 8033 8034 Arg = DefArg.takeAs<Expr>(); 8035 } 8036 8037 TheCall->setArg(i + 1, Arg); 8038 } 8039 8040 // If this is a variadic call, handle args passed through "...". 8041 if (Proto->isVariadic()) { 8042 // Promote the arguments (C99 6.5.2.2p7). 8043 for (unsigned i = NumArgsInProto; i != NumArgs; i++) { 8044 Expr *Arg = Args[i]; 8045 IsError |= DefaultVariadicArgumentPromotion(Arg, VariadicMethod, 0); 8046 TheCall->setArg(i + 1, Arg); 8047 } 8048 } 8049 8050 if (IsError) return true; 8051 8052 if (CheckFunctionCall(Method, TheCall)) 8053 return true; 8054 8055 return MaybeBindToTemporary(TheCall); 8056} 8057 8058/// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator-> 8059/// (if one exists), where @c Base is an expression of class type and 8060/// @c Member is the name of the member we're trying to find. 8061ExprResult 8062Sema::BuildOverloadedArrowExpr(Scope *S, Expr *Base, SourceLocation OpLoc) { 8063 assert(Base->getType()->isRecordType() && "left-hand side must have class type"); 8064 8065 if (Base->getObjectKind() == OK_ObjCProperty) 8066 ConvertPropertyForRValue(Base); 8067 8068 SourceLocation Loc = Base->getExprLoc(); 8069 8070 // C++ [over.ref]p1: 8071 // 8072 // [...] An expression x->m is interpreted as (x.operator->())->m 8073 // for a class object x of type T if T::operator->() exists and if 8074 // the operator is selected as the best match function by the 8075 // overload resolution mechanism (13.3). 8076 DeclarationName OpName = Context.DeclarationNames.getCXXOperatorName(OO_Arrow); 8077 OverloadCandidateSet CandidateSet(Loc); 8078 const RecordType *BaseRecord = Base->getType()->getAs<RecordType>(); 8079 8080 if (RequireCompleteType(Loc, Base->getType(), 8081 PDiag(diag::err_typecheck_incomplete_tag) 8082 << Base->getSourceRange())) 8083 return ExprError(); 8084 8085 LookupResult R(*this, OpName, OpLoc, LookupOrdinaryName); 8086 LookupQualifiedName(R, BaseRecord->getDecl()); 8087 R.suppressDiagnostics(); 8088 8089 for (LookupResult::iterator Oper = R.begin(), OperEnd = R.end(); 8090 Oper != OperEnd; ++Oper) { 8091 AddMethodCandidate(Oper.getPair(), Base->getType(), 0, 0, CandidateSet, 8092 /*SuppressUserConversions=*/false); 8093 } 8094 8095 // Perform overload resolution. 8096 OverloadCandidateSet::iterator Best; 8097 switch (CandidateSet.BestViableFunction(*this, OpLoc, Best)) { 8098 case OR_Success: 8099 // Overload resolution succeeded; we'll build the call below. 8100 break; 8101 8102 case OR_No_Viable_Function: 8103 if (CandidateSet.empty()) 8104 Diag(OpLoc, diag::err_typecheck_member_reference_arrow) 8105 << Base->getType() << Base->getSourceRange(); 8106 else 8107 Diag(OpLoc, diag::err_ovl_no_viable_oper) 8108 << "operator->" << Base->getSourceRange(); 8109 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, &Base, 1); 8110 return ExprError(); 8111 8112 case OR_Ambiguous: 8113 Diag(OpLoc, diag::err_ovl_ambiguous_oper_unary) 8114 << "->" << Base->getType() << Base->getSourceRange(); 8115 CandidateSet.NoteCandidates(*this, OCD_ViableCandidates, &Base, 1); 8116 return ExprError(); 8117 8118 case OR_Deleted: 8119 Diag(OpLoc, diag::err_ovl_deleted_oper) 8120 << Best->Function->isDeleted() 8121 << "->" << Base->getSourceRange(); 8122 CandidateSet.NoteCandidates(*this, OCD_AllCandidates, &Base, 1); 8123 return ExprError(); 8124 } 8125 8126 CheckMemberOperatorAccess(OpLoc, Base, 0, Best->FoundDecl); 8127 DiagnoseUseOfDecl(Best->FoundDecl, OpLoc); 8128 8129 // Convert the object parameter. 8130 CXXMethodDecl *Method = cast<CXXMethodDecl>(Best->Function); 8131 if (PerformObjectArgumentInitialization(Base, /*Qualifier=*/0, 8132 Best->FoundDecl, Method)) 8133 return ExprError(); 8134 8135 // Build the operator call. 8136 Expr *FnExpr = CreateFunctionRefExpr(*this, Method); 8137 8138 QualType ResultTy = Method->getResultType(); 8139 ExprValueKind VK = Expr::getValueKindForType(ResultTy); 8140 ResultTy = ResultTy.getNonLValueExprType(Context); 8141 CXXOperatorCallExpr *TheCall = 8142 new (Context) CXXOperatorCallExpr(Context, OO_Arrow, FnExpr, 8143 &Base, 1, ResultTy, VK, OpLoc); 8144 8145 if (CheckCallReturnType(Method->getResultType(), OpLoc, TheCall, 8146 Method)) 8147 return ExprError(); 8148 return Owned(TheCall); 8149} 8150 8151/// FixOverloadedFunctionReference - E is an expression that refers to 8152/// a C++ overloaded function (possibly with some parentheses and 8153/// perhaps a '&' around it). We have resolved the overloaded function 8154/// to the function declaration Fn, so patch up the expression E to 8155/// refer (possibly indirectly) to Fn. Returns the new expr. 8156Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found, 8157 FunctionDecl *Fn) { 8158 if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 8159 Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(), 8160 Found, Fn); 8161 if (SubExpr == PE->getSubExpr()) 8162 return PE; 8163 8164 return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr); 8165 } 8166 8167 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) { 8168 Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(), 8169 Found, Fn); 8170 assert(Context.hasSameType(ICE->getSubExpr()->getType(), 8171 SubExpr->getType()) && 8172 "Implicit cast type cannot be determined from overload"); 8173 assert(ICE->path_empty() && "fixing up hierarchy conversion?"); 8174 if (SubExpr == ICE->getSubExpr()) 8175 return ICE; 8176 8177 return ImplicitCastExpr::Create(Context, ICE->getType(), 8178 ICE->getCastKind(), 8179 SubExpr, 0, 8180 ICE->getValueKind()); 8181 } 8182 8183 if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) { 8184 assert(UnOp->getOpcode() == UO_AddrOf && 8185 "Can only take the address of an overloaded function"); 8186 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) { 8187 if (Method->isStatic()) { 8188 // Do nothing: static member functions aren't any different 8189 // from non-member functions. 8190 } else { 8191 // Fix the sub expression, which really has to be an 8192 // UnresolvedLookupExpr holding an overloaded member function 8193 // or template. 8194 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(), 8195 Found, Fn); 8196 if (SubExpr == UnOp->getSubExpr()) 8197 return UnOp; 8198 8199 assert(isa<DeclRefExpr>(SubExpr) 8200 && "fixed to something other than a decl ref"); 8201 assert(cast<DeclRefExpr>(SubExpr)->getQualifier() 8202 && "fixed to a member ref with no nested name qualifier"); 8203 8204 // We have taken the address of a pointer to member 8205 // function. Perform the computation here so that we get the 8206 // appropriate pointer to member type. 8207 QualType ClassType 8208 = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext())); 8209 QualType MemPtrType 8210 = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr()); 8211 8212 return new (Context) UnaryOperator(SubExpr, UO_AddrOf, MemPtrType, 8213 VK_RValue, OK_Ordinary, 8214 UnOp->getOperatorLoc()); 8215 } 8216 } 8217 Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(), 8218 Found, Fn); 8219 if (SubExpr == UnOp->getSubExpr()) 8220 return UnOp; 8221 8222 return new (Context) UnaryOperator(SubExpr, UO_AddrOf, 8223 Context.getPointerType(SubExpr->getType()), 8224 VK_RValue, OK_Ordinary, 8225 UnOp->getOperatorLoc()); 8226 } 8227 8228 if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 8229 // FIXME: avoid copy. 8230 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0; 8231 if (ULE->hasExplicitTemplateArgs()) { 8232 ULE->copyTemplateArgumentsInto(TemplateArgsBuffer); 8233 TemplateArgs = &TemplateArgsBuffer; 8234 } 8235 8236 return DeclRefExpr::Create(Context, 8237 ULE->getQualifier(), 8238 ULE->getQualifierRange(), 8239 Fn, 8240 ULE->getNameLoc(), 8241 Fn->getType(), 8242 VK_LValue, 8243 TemplateArgs); 8244 } 8245 8246 if (UnresolvedMemberExpr *MemExpr = dyn_cast<UnresolvedMemberExpr>(E)) { 8247 // FIXME: avoid copy. 8248 TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = 0; 8249 if (MemExpr->hasExplicitTemplateArgs()) { 8250 MemExpr->copyTemplateArgumentsInto(TemplateArgsBuffer); 8251 TemplateArgs = &TemplateArgsBuffer; 8252 } 8253 8254 Expr *Base; 8255 8256 // If we're filling in a static method where we used to have an 8257 // implicit member access, rewrite to a simple decl ref. 8258 if (MemExpr->isImplicitAccess()) { 8259 if (cast<CXXMethodDecl>(Fn)->isStatic()) { 8260 return DeclRefExpr::Create(Context, 8261 MemExpr->getQualifier(), 8262 MemExpr->getQualifierRange(), 8263 Fn, 8264 MemExpr->getMemberLoc(), 8265 Fn->getType(), 8266 VK_LValue, 8267 TemplateArgs); 8268 } else { 8269 SourceLocation Loc = MemExpr->getMemberLoc(); 8270 if (MemExpr->getQualifier()) 8271 Loc = MemExpr->getQualifierRange().getBegin(); 8272 Base = new (Context) CXXThisExpr(Loc, 8273 MemExpr->getBaseType(), 8274 /*isImplicit=*/true); 8275 } 8276 } else 8277 Base = MemExpr->getBase(); 8278 8279 return MemberExpr::Create(Context, Base, 8280 MemExpr->isArrow(), 8281 MemExpr->getQualifier(), 8282 MemExpr->getQualifierRange(), 8283 Fn, 8284 Found, 8285 MemExpr->getMemberNameInfo(), 8286 TemplateArgs, 8287 Fn->getType(), 8288 cast<CXXMethodDecl>(Fn)->isStatic() 8289 ? VK_LValue : VK_RValue, 8290 OK_Ordinary); 8291 } 8292 8293 llvm_unreachable("Invalid reference to overloaded function"); 8294 return E; 8295} 8296 8297ExprResult Sema::FixOverloadedFunctionReference(ExprResult E, 8298 DeclAccessPair Found, 8299 FunctionDecl *Fn) { 8300 return Owned(FixOverloadedFunctionReference((Expr *)E.get(), Found, Fn)); 8301} 8302 8303} // end namespace clang 8304