lib/Sema/SemaOverload.cpp

600   // information and the index of the problematic call argument.
1071 /// checkArgPlaceholdersForOverload - Check a set of call operands for
4276   // Here, MSVC will call f(int) instead of generating a compile error
4297   // report an ambiguous call error
6087     // If we aren't in a SFINAE context, build a call to the
6377 /// an acceptable non-member overloaded operator for a call whose
6416 /// candidate functions, using the given function call arguments.  If
6440       // implicitly. This can happen with a qualified call to a member
6442       // object argument (C++ [over.call.func]p3), and the acting context
7024 /// of candidate functions, using the given function call arguments
7025 /// and the object argument (@c Object). For example, in a call
7348 /// [temp.deduct.call]p10.
7372   // For a method call, check the 'this' conversion here too. DR1391 doesn't
7561   // convert to (ToType), we need to synthesize a call to the
7565   // call on the stack and we don't need its arguments to be
7710 /// conversion function @c Conversion, and then attempts to call it
7711 /// with the given arguments (C++ [over.call.object]p2-4). Proto is
8944   //   error: call is ambiguous for arguments 'A' and 'long'.
10257   // compilation mode only one call variant is viable. We need to
10260   // candidate call is WrongSide and the other is SameSide, we ignore
10545 // convention of the call operator, since that is guaranteed to exist.
11279     // call operator, and if so, emit a prettier and more informative
11313 /// CUDA: diagnose an invalid call across targets.
11415 /// already generated a primary error at the call site.
12953   assert(!KnownValid && "unhandled case in overloaded call candidate");
13012 /// Add the call candidates from the given set of lookup results to the given
13176 /// Attempts to recover from a call where no functions were found.
13190   // Do not try to recover if it is already building a recovery call.
13254   // Build an implicit member call if appropriate.  Just drop the
13255   // casts and such from the call, we don't really care.
13387 /// the completed call expression. If overload resolution fails, emits
13413     // have meant to call.
13460     // We emitted an error for the unavailable/deleted function call but keep
13461     // the call in the AST.
13488 /// BuildOverloadedCallExpr - Given the call expression that calls Fn
13489 /// (which eventually refers to the declaration Func) and the call
13490 /// arguments Args/NumArgs, attempt to resolve the function call down
13492 /// the call expression produced by overload resolution.
13629       // We matched an overloaded operator. Build a call to that
13909         // We matched an overloaded operator. Build a call to that
13935           // better conversion for either parameter. If so, this call is
14219         // The user probably meant to call this special member. Just
14340   // Build the full argument list for the method call (the implicit object
14434         // We matched an overloaded operator. Build a call to that
14557 /// BuildCallToMemberFunction - Build a call to a member
14560 /// arguments to the function call (not including the object
14577   // Determine whether this is a call to a pointer-to-member function.
14609     CXXMemberCallExpr *call = CXXMemberCallExpr::Create(
14614                             call, nullptr))
14617     if (ConvertArgumentsForCall(call, op, nullptr, proto, Args, RParenLoc))
14620     if (CheckOtherCall(call, proto))
14623     return MaybeBindToTemporary(call);
14690         // If explicit template arguments were provided, we can't call a
14762     // non-member call based on that function.
14775   assert(Method && "Member call to something that isn't a method?");
14786   // Convert the object argument (for a non-static member function call).
14808   // In the case the method to call was not selected by the overloading
14856 /// BuildCallToObjectOfClassType - Build a call to an object of class
14857 /// type (C++ [over.call.object]), which can end up invoking an
14858 /// overloaded function call operator (@c operator()) or performing a
14876   // C++ [over.call.object]p1:
14877   //  If the primary-expression E in the function call syntax
14879   //  candidate functions includes at least the function call
14880   //  operators of T. The function call operators of T are obtained by
14903   // C++ [over.call.object]p2:
14914   //   of (P1,...,Pn) returning R", a surrogate call function [...]
14916   //   surrogate call functions are added to the set of candidate
14956     // Overload resolution succeeded; we'll build the appropriate call
14964                << Object.get()->getType() << /*call*/ 1
15015     // and then call it.
15058   // Since C++2b, this could also be a call to a static call operator
15073   // If this is a variadic call, handle args passed through "...".
15112 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
15157     // Overload resolution succeeded; we'll build the call below.
15209   // Build the operator call.
15232 /// BuildLiteralOperatorCall - Build a UserDefinedLiteral by creating a call to
15309 /// Build a call to 'begin' or 'end' for a C++11 for-range statement. If the