Lines Matching refs:Operator
1366 "Non-unary operator on non-static member address");
1369 "Non-address-of operator on non-static member address");
1376 "Non-address-of operator for overloaded function expression");
5881 /// Add the overloaded operator candidates that are member functions
5882 /// for the operator Op that was used in an operator expression such
5883 /// as "x Op y". , Args/NumArgs provides the operator arguments, and
5894 // For a unary operator @ with an operand of a type whose
5895 // cv-unqualified version is T1, and for a binary operator @ with
5904 // result of the qualified lookup of T1::operator@
5928 /// operator. ResultTy and ParamTys are the result and parameter types
5932 /// operator. NumContextualBoolArguments is the number of arguments
5992 /// candidate operator functions for built-in operators (C++
6185 /// take member pointer types, for the conditional operator.
6278 // T& operator=(T&, T)
6285 // volatile T& operator=(volatile T&, T)
6352 /// \brief Helper class to manage the addition of builtin operator overload
6355 /// operator overloads from the standard to a candidate set.
6524 // is either volatile or empty, there exist candidate operator
6527 // VQ T& operator++(VQ T&);
6528 // T operator++(VQ T&, int);
6534 // candidate operator functions of the form
6536 // VQ T& operator--(VQ T&);
6537 // T operator--(VQ T&, int);
6554 // empty, there exist candidate operator functions of the form
6556 // T*VQ& operator++(T*VQ&);
6557 // T*VQ& operator--(T*VQ&);
6558 // T* operator++(T*VQ&, int);
6559 // T* operator--(T*VQ&, int);
6577 // exist candidate operator functions of the form
6579 // T& operator*(T*);
6583 // ref-qualifier, there exist candidate operator functions of the form
6584 // T& operator*(T*);
6606 // operator functions of the form
6608 // T operator+(T);
6609 // T operator-(T);
6631 // For every type T, there exist candidate operator functions of
6634 // T* operator+(T*);
6647 // operator functions of the form
6649 // T operator~(T);
6660 // Extension: We also add this operator for vector types.
6671 // For every pointer to member type T, there exist candidate operator
6674 // bool operator==(T,T);
6675 // bool operator!=(T,T);
6700 // std::nullptr_t, there exist candidate operator functions of the form
6702 // bool operator<(T, T);
6703 // bool operator>(T, T);
6704 // bool operator<=(T, T);
6705 // bool operator>=(T, T);
6706 // bool operator==(T, T);
6707 operator!=(T, T);
6711 // types as a built-in candidate operator function, the built-in operator
6716 // up with ambiguities when the user provides an overloaded operator for
6719 // only other overloaded operator with enumeration argumenst, operator=,
6744 // Add this operator to the set of known user-defined operators.
6802 // there exist candidate operator functions of the form
6804 // T* operator+(T*, ptrdiff_t);
6805 // T& operator[](T*, ptrdiff_t); [BELOW]
6806 // T* operator-(T*, ptrdiff_t);
6807 // T* operator+(ptrdiff_t, T*);
6808 // T& operator[](ptrdiff_t, T*); [BELOW]
6813 // exist candidate operator functions of the form
6815 // ptrdiff_t operator-(T, T);
6835 // operator+(T*, ptrdiff_t) or operator-(T*, ptrdiff_t)
6836 // T* operator+(ptrdiff_t, T*);
6841 // ptrdiff_t operator-(T, T);
6856 // exist candidate operator functions of the form
6858 // LR operator*(L, R);
6859 // LR operator/(L, R);
6860 // LR operator+(L, R);
6861 // LR operator-(L, R);
6862 // bool operator<(L, R);
6863 // bool operator>(L, R);
6864 // bool operator<=(L, R);
6865 // bool operator>=(L, R);
6866 // bool operator==(L, R);
6867 // bool operator!=(L, R);
6875 // candidate operator functions of the form
6877 // LR operator?(bool, L, R);
6900 // conditional operator for vector types.
6926 // exist candidate operator functions of the form
6928 // LR operator%(L, R);
6929 // LR operator&(L, R);
6930 // LR operator^(L, R);
6931 // LR operator|(L, R);
6932 // L operator<<(L, R);
6933 // L operator>>(L, R);
6959 // empty, there exist candidate operator functions of the form
6961 // VQ T& operator=(VQ T&, T);
6994 // volatile or empty, there exist candidate operator functions
6997 // T*VQ& operator=(T*VQ&, T*);
7003 // empty, there exist candidate operator functions of the form
7005 // T*VQ& operator+=(T*VQ&, ptrdiff_t);
7006 // T*VQ& operator-=(T*VQ&, ptrdiff_t);
7015 // If this is operator=, keep track of the builtin candidates we added.
7073 // arithmetic type, there exist candidate operator functions of
7076 // VQ L& operator=(VQ L&, R);
7077 // VQ L& operator*=(VQ L&, R);
7078 // VQ L& operator/=(VQ L&, R);
7079 // VQ L& operator+=(VQ L&, R);
7080 // VQ L& operator-=(VQ L&, R);
7091 // Add this built-in operator as a candidate (VQ is empty).
7097 // Add this built-in operator as a candidate (VQ is 'volatile').
7120 // Add this built-in operator as a candidate (VQ is empty).
7125 // Add this built-in operator as a candidate (VQ is 'volatile').
7141 // type, there exist candidate operator functions of the form
7143 // VQ L& operator%=(VQ L&, R);
7144 // VQ L& operator<<=(VQ L&, R);
7145 // VQ L& operator>>=(VQ L&, R);
7146 // VQ L& operator&=(VQ L&, R);
7147 // VQ L& operator^=(VQ L&, R);
7148 // VQ L& operator|=(VQ L&, R);
7159 // Add this built-in operator as a candidate (VQ is empty).
7164 // Add this built-in operator as a candidate (VQ is 'volatile').
7175 // C++ [over.operator]p23:
7177 // There also exist candidate operator functions of the form
7179 // bool operator!(bool);
7180 // bool operator&&(bool, bool);
7181 // bool operator||(bool, bool);
7198 // exist candidate operator functions of the form
7200 // T* operator+(T*, ptrdiff_t); [ABOVE]
7201 // T& operator[](T*, ptrdiff_t);
7202 // T* operator-(T*, ptrdiff_t); [ABOVE]
7203 // T* operator+(ptrdiff_t, T*); [ABOVE]
7204 // T& operator[](ptrdiff_t, T*);
7217 // T& operator[](T*, ptrdiff_t)
7232 // T& operator[](ptrdiff_t, T*)
7241 // there exist candidate operator functions of the form
7243 // CV12 T& operator->*(CV1 C1*, CV2 T C2::*);
7295 // enumeration type, there exist candidate operator functions of the form
7297 // T operator?(bool, T, T);
7348 /// operator overloads to the candidate set (C++ [over.built]), based
7349 /// on the operator @p Op and the arguments given. For example, if the
7350 /// operator is a binary '+', this routine might add "int
7351 /// operator+(int, int)" to cover integer addition.
7358 // if the operator we're looking at has built-in operator candidates
7386 // for any of the arguments to the operator.
7404 llvm_unreachable("Expected an overloaded operator");
7417 // -- For the operator ',', the unary operator '&', or the
7418 // operator '->', the built-in candidates set is empty.
7476 // -- For the operator ',', the unary operator '&', or the
7477 // operator '->', the built-in candidates set is empty.
7538 /// given function name (which may also be an operator name) and adds
7543 bool Operator, SourceLocation Loc,
7559 ArgumentDependentLookup(Name, Operator, Loc, Args, Fns,
7710 /// \param Loc the location of the function name (or operator symbol) for
8375 assert(Cand->NumConversions <= 2 && "builtin operator is not binary");
8376 std::string TypeStr("operator");
8447 bool operator()(const OverloadCandidate *L,
8600 // Builtin binary operator with a bad first conversion.
9084 // operator.
9311 AddArgumentDependentLookupCandidates(ULE->getName(), /*Operator*/ false,
9412 /// Attempt to recover from ill-formed use of a non-dependent operator in a
9413 /// template, where the non-dependent operator was declared after the template
9688 /// operator.
9690 /// \param OpLoc The location of the operator itself (e.g., '*').
9693 /// operator.
9710 assert(Op != OO_None && "Invalid opcode for overloaded unary operator");
9759 // Add operator candidates that are member functions.
9763 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
9768 // Add builtin operator candidates.
9777 // We found a built-in operator or an overloaded operator.
9781 // We matched an overloaded operator. Build a call to that
9782 // operator.
9833 // We matched a built-in operator. Convert the arguments, then
9835 // operator node.
9847 // This is an erroneous use of an operator which can be overloaded by
9856 // built-in operator, which will produce an error message for us.
9881 // Either we found no viable overloaded operator or we matched a
9882 // built-in operator. In either case, fall through to trying to
9888 /// operator.
9890 /// \param OpLoc The location of the operator itself (e.g., '+').
9893 /// operator.
9963 // If this is the assignment operator, we only perform overload resolution
9972 // If this is the .* operator, which is not overloadable, just
9973 // create a built-in binary operator.
9983 // Add operator candidates that are member functions.
9987 AddArgumentDependentLookupCandidates(OpName, /*Operator*/ true,
9992 // Add builtin operator candidates.
10001 // We found a built-in operator or an overloaded operator.
10005 // We matched an overloaded operator. Build a call to that
10006 // operator.
10073 // We matched a built-in operator. Convert the arguments, then
10075 // operator node.
10095 // If the operator is the operator , [...] and there are no
10096 // viable functions, then the operator is assumed to be the
10097 // built-in operator and interpreted according to clause 5.
10102 // operator do not fall through to handling in built-in, but report that
10103 // no overloaded assignment operator found
10111 // This is an erroneous use of an operator which can be overloaded by
10123 "C++ binary operator overloading is missing candidates!");
10165 // We matched a built-in operator; build it.
10182 // CHECKME: no 'operator' keyword?
10211 // Add operator candidates that are member functions.
10214 // Add builtin operator candidates.
10223 // We found a built-in operator or an overloaded operator.
10227 // We matched an overloaded operator. Build a call to that
10228 // operator.
10282 // We matched a built-in operator. Convert the arguments, then
10284 // operator node.
10336 // We matched a built-in operator; build it.
10584 /// overloaded function call operator (@c operator()) or performing a
10607 // ordinary lookup of the name operator() in the context of
10608 // (E).operator().
10632 // operator conversion-type-id () cv-qualifier;
10739 // Create an implicit member expr to refer to the conversion operator.
10758 // We found an overloaded operator(). Build a CXXOperatorCallExpr
10877 /// BuildOverloadedArrowExpr - Build a call to an overloaded @c operator->
10892 // [...] An expression x->m is interpreted as (x.operator->())->m
10893 // for a class object x of type T if T::operator->() exists and if
10894 // the operator is selected as the best match function by the
10931 << "operator->" << Base->getSourceRange();
10964 // Build the operator call.
10985 /// a literal operator described by the provided lookup results.
11000 // to perform substitutions for a literal operator template.
