Lines Matching defs:Operator
865 /// operator delete[] for the given type has a size_t parameter.
872 // Try to find an operator delete[] in class scope.
882 // Very likely: there's no operator delete[].
885 // If it's ambiguous, it should be illegal to call operator delete[]
902 // If class T does not declare [an operator delete[] with one
904 // named operator delete[] with exactly two parameters, the
1301 // Warn if the type is over-aligned and is being allocated by global operator
1466 /// FindAllocationFunctions - Finds the overloads of operator new and delete
1478 // 2) If an array size is given, look for operator new[], else look for
1479 // operator new.
1496 // function's name is operator new and the deallocation function's
1497 // name is operator delete. If the allocated type is an array
1498 // type, the allocation function's name is operator new[] and the
1499 // deallocation function's name is operator delete[].
1525 // We don't need an operator delete if we're running under
1539 // If the new-expression begins with a unary :: operator, the
1564 // Whether we're looking for a placement operator delete is dictated
1565 // by whether we selected a placement operator new, not by whether
1567 // struct A { void *operator new(size_t, int = 0); ... };
1665 bool AllowMissing, FunctionDecl *&Operator,
1684 // Even member operator new/delete are implicitly treated as
1730 Operator = FnDecl;
1774 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
1778 /// void* operator new(std::size_t) throw(std::bad_alloc);
1779 /// void* operator new[](std::size_t) throw(std::bad_alloc);
1780 /// void operator delete(void *) throw();
1781 /// void operator delete[](void *) throw();
1783 /// void* operator new(std::size_t);
1784 /// void* operator new[](std::size_t);
1785 /// void operator delete(void *);
1786 /// void operator delete[](void *);
1788 /// C++0x operator delete is implicitly noexcept.
1801 // void* operator new(std::size_t) throw(std::bad_alloc);
1802 // void* operator new[](std::size_t) throw(std::bad_alloc);
1803 // void operator delete(void*) throw();
1804 // void operator delete[](void*) throw();
1806 // void* operator new(std::size_t);
1807 // void* operator new[](std::size_t);
1808 // void operator delete(void*);
1809 // void operator delete[](void*);
1811 // These implicit declarations introduce only the function names operator
1812 // new, operator new[], operator delete, operator delete[].
1818 // Note that the C++0x versions of operator delete are deallocation functions,
1925 FunctionDecl* &Operator, bool Diagnose) {
1927 // Try to find operator delete/operator delete[] in class scope.
1940 // Ignore template operator delete members from the check for a usual
1949 // There's exactly one suitable operator; pick it.
1951 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
1953 if (Operator->isDeleted()) {
1956 NoteDeletedFunction(Operator);
1981 // We did find operator delete/operator delete[] declarations, but
2005 Operator, Diagnose))
2008 assert(Operator && "Did not find a deallocation function!");
2141 // usual operator delete[] has a size_t parameter.
2149 // Otherwise, the usual operator delete[] should be the
2204 // Check access and ambiguity of operator delete and destructor.
3112 // from having a trivial copy assignment operator (but do cause
3113 // errors if the copy assignment operator is actually used, q.v.
3172 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
3173 if (Operator->isCopyAssignmentOperator()) {
3176 = Operator->getType()->getAs<FunctionProtoType>();
3809 // The binary operator .* [p3: ->*] binds its second operand, which shall
3932 /// This is part of the parameter validation for the ? operator. If either
4023 /// This is part of the parameter validation for the ? operator. If either
4077 llvm_unreachable("Conditional operator has only built-in overloads");
4315 // Extension: conditional operator involving vector types.
4376 /// \param Loc The location of the operator requiring these two expressions to
4806 // -- the right operand of a comma operator that is the operand of a
4908 // If we have a pointer to a dependent type and are using the -> operator,
4921 // [...] When operator->returns, the operator-> is applied to the value
5014 // The left-hand side of the dot operator shall be of scalar type. The
5015 // left-hand side of the arrow operator shall be of pointer to scalar type.
5018 // arrow operator.
