Lines Matching refs:Operator
879 /// operator delete[] for the given type has a size_t parameter.
886 // Try to find an operator delete[] in class scope.
896 // Very likely: there's no operator delete[].
899 // If it's ambiguous, it should be illegal to call operator delete[]
916 // If class T does not declare [an operator delete[] with one
918 // named operator delete[] with exactly two parameters, the
1283 // Warn if the type is over-aligned and is being allocated by global operator
1444 /// FindAllocationFunctions - Finds the overloads of operator new and delete
1456 // 2) If an array size is given, look for operator new[], else look for
1457 // operator new.
1474 // function's name is operator new and the deallocation function's
1475 // name is operator delete. If the allocated type is an array
1476 // type, the allocation function's name is operator new[] and the
1477 // deallocation function's name is operator delete[].
1503 // We don't need an operator delete if we're running under
1517 // If the new-expression begins with a unary :: operator, the
1542 // Whether we're looking for a placement operator delete is dictated
1543 // by whether we selected a placement operator new, not by whether
1545 // struct A { void *operator new(size_t, int = 0); ... };
1644 bool AllowMissing, FunctionDecl *&Operator,
1663 // Even member operator new/delete are implicitly treated as
1709 Operator = FnDecl;
1753 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
1757 /// void* operator new(std::size_t) throw(std::bad_alloc);
1758 /// void* operator new[](std::size_t) throw(std::bad_alloc);
1759 /// void operator delete(void *) throw();
1760 /// void operator delete[](void *) throw();
1762 /// void* operator new(std::size_t);
1763 /// void* operator new[](std::size_t);
1764 /// void operator delete(void *);
1765 /// void operator delete[](void *);
1767 /// C++0x operator delete is implicitly noexcept.
1780 // void* operator new(std::size_t) throw(std::bad_alloc);
1781 // void* operator new[](std::size_t) throw(std::bad_alloc);
1782 // void operator delete(void*) throw();
1783 // void operator delete[](void*) throw();
1785 // void* operator new(std::size_t);
1786 // void* operator new[](std::size_t);
1787 // void operator delete(void*);
1788 // void operator delete[](void*);
1790 // These implicit declarations introduce only the function names operator
1791 // new, operator new[], operator delete, operator delete[].
1797 // Note that the C++0x versions of operator delete are deallocation functions,
1904 FunctionDecl* &Operator, bool Diagnose) {
1906 // Try to find operator delete/operator delete[] in class scope.
1919 // Ignore template operator delete members from the check for a usual
1928 // There's exactly one suitable operator; pick it.
1930 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
1932 if (Operator->isDeleted()) {
1935 NoteDeletedFunction(Operator);
1960 // We did find operator delete/operator delete[] declarations, but
1984 Operator, Diagnose))
1987 assert(Operator && "Did not find a deallocation function!");
2120 // usual operator delete[] has a size_t parameter.
2128 // Otherwise, the usual operator delete[] should be the
2187 // Check access and ambiguity of operator delete and destructor.
3072 // from having a trivial copy assignment operator (but do cause
3073 // errors if the copy assignment operator is actually used, q.v.
3133 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
3134 if (Operator->isCopyAssignmentOperator()) {
3137 = Operator->getType()->getAs<FunctionProtoType>();
3733 // The binary operator .* [p3: ->*] binds its second operand, which shall
3856 /// This is part of the parameter validation for the ? operator. If either
3947 /// This is part of the parameter validation for the ? operator. If either
4001 llvm_unreachable("Conditional operator has only built-in overloads");
4195 // Extension: conditional operator involving vector types.
4254 /// \param Loc The location of the operator requiring these two expressions to
4673 // -- the right operand of a comma operator that is the operand of a
4766 // If we have a pointer to a dependent type and are using the -> operator,
4779 // [...] When operator->returns, the operator-> is applied to the value
4873 // The left-hand side of the dot operator shall be of scalar type. The
4874 // left-hand side of the arrow operator shall be of pointer to scalar type.
4877 // arrow operator.
