Lines Matching full:operator
1178 "Non-unary operator on non-static member address");
1181 "Non-address-of operator on non-static member address");
1188 "Non-address-of operator for overloaded function expression");
5038 /// Add the overloaded operator candidates that are member functions
5039 /// for the operator Op that was used in an operator expression such
5040 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
5051 // For a unary operator @ with an operand of a type whose
5052 // cv-unqualified version is T1, and for a binary operator @ with
5061 // result of the qualified lookup of T1::operator@
5085 /// operator. ResultTy and ParamTys are the result and parameter types
5089 /// operator. NumContextualBoolArguments is the number of arguments
5151 /// candidate operator functions for built-in operators (C++
5344 /// take member pointer types, for the conditional operator.
5437 // T& operator=(T&, T)
5444 // volatile T& operator=(volatile T&, T)
5511 /// \brief Helper class to manage the addition of builtin operator overload
5514 /// operator overloads from the standard to a candidate set.
5683 // is either volatile or empty, there exist candidate operator
5686 // VQ T& operator++(VQ T&);
5687 // T operator++(VQ T&, int);
5693 // candidate operator functions of the form
5695 // VQ T& operator--(VQ T&);
5696 // T operator--(VQ T&, int);
5713 // empty, there exist candidate operator functions of the form
5715 // T*VQ& operator++(T*VQ&);
5716 // T*VQ& operator--(T*VQ&);
5717 // T* operator++(T*VQ&, int);
5718 // T* operator--(T*VQ&, int);
5736 // exist candidate operator functions of the form
5738 // T& operator*(T*);
5742 // ref-qualifier, there exist candidate operator functions of the form
5743 // T& operator*(T*);
5765 // operator functions of the form
5767 // T operator+(T);
5768 // T operator-(T);
5790 // For every type T, there exist candidate operator functions of
5793 // T* operator+(T*);
5806 // operator functions of the form
5808 // T operator~(T);
5819 // Extension: We also add this operator for vector types.
5830 // For every pointer to member type T, there exist candidate operator
5833 // bool operator==(T,T);
5834 // bool operator!=(T,T);
5859 // std::nullptr_t, there exist candidate operator functions of the form
5861 // bool operator<(T, T);
5862 // bool operator>(T, T);
5863 // bool operator<=(T, T);
5864 // bool operator>=(T, T);
5865 // bool operator==(T, T);
5866 // bool operator!=(T, T);
5870 // types as a built-in candidate operator function, the built-in operator
5875 // up with ambiguities when the user provides an overloaded operator for
5878 // only other overloaded operator with enumeration argumenst, operator=,
5903 // Add this operator to the set of known user-defined operators.
5961 // there exist candidate operator functions of the form
5963 // T* operator+(T*, ptrdiff_t);
5964 // T& operator[](T*, ptrdiff_t); [BELOW]
5965 // T* operator-(T*, ptrdiff_t);
5966 // T* operator+(ptrdiff_t, T*);
5967 // T& operator[](ptrdiff_t, T*); [BELOW]
5972 // exist candidate operator functions of the form
5974 // ptrdiff_t operator-(T, T);
5994 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
5995 // T* operator+(ptrdiff_t, T*);
6000 // ptrdiff_t operator-(T, T);
6015 // exist candidate operator functions of the form
6017 // LR operator*(L, R);
6018 // LR operator/(L, R);
6019 // LR operator+(L, R);
6020 // LR operator-(L, R);
6021 // bool operator<(L, R);
6022 // bool operator>(L, R);
6023 // bool operator<=(L, R);
6024 // bool operator>=(L, R);
6025 // bool operator==(L, R);
6026 // bool operator!=(L, R);
6034 // candidate operator functions of the form
6036 // LR operator?(bool, L, R);
6059 // conditional operator for vector types.
6085 // exist candidate operator functions of the form
6087 // LR operator%(L, R);
6088 // LR operator&(L, R);
6089 // LR operator^(L, R);
6090 // LR operator|(L, R);
6091 // L operator<<(L, R);
6092 // L operator>>(L, R);
6118 // empty, there exist candidate operator functions of the form
6120 // VQ T& operator=(VQ T&, T);
6153 // volatile or empty, there exist candidate operator functions
6156 // T*VQ& operator=(T*VQ&, T*);
6162 // empty, there exist candidate operator functions of the form
6164 // T*VQ& operator+=(T*VQ&, ptrdiff_t);
6165 // T*VQ& operator-=(T*VQ&, ptrdiff_t);
6174 // If this is operator=, keep track of the builtin candidates we added.
6232 // arithmetic type, there exist candidate operator functions of
6235 // VQ L& operator=(VQ L&, R);
6236 // VQ L& operator*=(VQ L&, R);
6237 // VQ L& operator/=(VQ L&, R);
6238 // VQ L& operator+=(VQ L&, R);
6239 // VQ L& operator-=(VQ L&, R);
6250 // Add this built-in operator as a candidate (VQ is empty).
6256 // Add this built-in operator as a candidate (VQ is 'volatile').
6279 // Add this built-in operator as a candidate (VQ is empty).
6284 // Add this built-in operator as a candidate (VQ is 'volatile').
6300 // type, there exist candidate operator functions of the form
6302 // VQ L& operator%=(VQ L&, R);
6303 // VQ L& operator<<=(VQ L&, R);
6304 // VQ L& operator>>=(VQ L&, R);
6305 // VQ L& operator&=(VQ L&, R);
6306 // VQ L& operator^=(VQ L&, R);
6307 // VQ L& operator|=(VQ L&, R);
6318 // Add this built-in operator as a candidate (VQ is empty).
6323 // Add this built-in operator as a candidate (VQ is 'volatile').
6334 // C++ [over.operator]p23:
6336 // There also exist candidate operator functions of the form
6338 // bool operator!(bool);
6339 // bool operator&&(bool, bool);
6340 // bool operator||(bool, bool);
6357 // exist candidate operator functions of the form
6359 // T* operator+(T*, ptrdiff_t); [ABOVE]
6360 // T& operator[](T*, ptrdiff_t);
6361 // T* operator-(T*, ptrdiff_t); [ABOVE]
6362 // T* operator+(ptrdiff_t, T*); [ABOVE]
6363 // T& operator[](ptrdiff_t, T*);
6376 // T& operator[](T*, ptrdiff_t)
6391 // T& operator[](ptrdiff_t, T*)
6400 // there exist candidate operator functions of the form
6402 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
6454 // enumeration type, there exist candidate operator functions of the form
6456 // T operator?(bool, T, T);
6507 /// operator overloads to the candidate set (C++ [over.built]), based
6508 /// on the operator @p Op and the arguments given. For example, if the
6509 /// operator is a binary '+', this routine might add "int
6510 /// operator+(int, int)" to cover integer addition.
6517 // if the operator we're looking at has built-in operator candidates
6545 // for any of the arguments to the operator.
6563 llvm_unreachable("Expected an overloaded operator");
6576 // -- For the operator ',', the unary operator '&', or the
6577 // operator '->', the built-in candidates set is empty.
6635 // -- For the operator ',', the unary operator '&', or the
6636 // operator '->', the built-in candidates set is empty.
6697 /// given function name (which may also be an operator name) and adds
6702 bool Operator,
6718 ArgumentDependentLookup(Name, Operator, Args, NumArgs, Fns,
6860 /// \param Loc the location of the function name (or operator symbol) for
6961 && "implicit method is not copy assignment operator?");
7527 assert(Cand->Conversions.size() <= 2 && "builtin operator is not binary");
7528 std::string TypeStr("operator");
7599 bool operator()(const OverloadCandidate *L,
7752 // Builtin binary operator with a bad first conversion.
8230 // operator.
8458 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false,
8557 /// Attempt to recover from ill-formed use of a non-dependent operator in a
8558 /// template, where the non-dependent operator was declared after the template
8747 /// operator.
8749 /// \param OpLoc The location of the operator itself (e.g., '*').
8752 /// operator.
8769 assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
8817 // Add operator candidates that are member functions.
8821 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
8826 // Add builtin operator candidates.
8835 // We found a built-in operator or an overloaded operator.
8839 // We matched an overloaded operator. Build a call to that
8840 // operator.
8891 // We matched a built-in operator. Convert the arguments, then
8893 // operator node.
8905 // This is an erroneous use of an operator which can be overloaded by
8913 // built-in operator, which will produce an error message for us.
8936 // Either we found no viable overloaded operator or we matched a
8937 // built-in operator. In either case, fall through to trying to
8943 /// operator.
8945 /// \param OpLoc The location of the operator itself (e.g., '+').
8948 /// operator.
9048 // If this is the assignment operator, we only perform overload resolution
9057 // If this is the .* operator, which is not overloadable, just
9058 // create a built-in binary operator.
9068 // Add operator candidates that are member functions.
9072 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
9077 // Add builtin operator candidates.
9086 // We found a built-in operator or an overloaded operator.
9090 // We matched an overloaded operator. Build a call to that
9091 // operator.
9158 // We matched a built-in operator. Convert the arguments, then
9160 // operator node.
9180 // If the operator is the operator , [...] and there are no
9181 // viable functions, then the operator is assumed to be the
9182 // built-in operator and interpreted according to clause 5.
9187 // operator do not fall through to handling in built-in, but report that
9188 // no overloaded assignment operator found
9196 // This is an erroneous use of an operator which can be overloaded by
9208 "C++ binary operator overloading is missing candidates!");
9235 // We matched a built-in operator; build it.
9252 // CHECKME: no 'operator' keyword?
9281 // Add operator candidates that are member functions.
9284 // Add builtin operator candidates.
9293 // We found a built-in operator or an overloaded operator.
9297 // We matched an overloaded operator. Build a call to that
9298 // operator.
9352 // We matched a built-in operator. Convert the arguments, then
9354 // operator node.
9406 // We matched a built-in operator; build it.
9648 /// overloaded function call operator (@c operator()) or performing a
9671 // ordinary lookup of the name operator() in the context of
9672 // (E).operator().
9696 // operator conversion-type-id () cv-qualifier;
9799 // Create an implicit member expr to refer to the conversion operator.
9814 // We found an overloaded operator(). Build a CXXOperatorCallExpr
9926 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
9941 // [...] An expression x->m is interpreted as (x.operator->())->m
9942 // for a class object x of type T if T::operator->() exists and if
9943 // the operator is selected as the best match function by the
9980 << "operator->" << Base->getSourceRange();
10013 // Build the operator call.
