Lines Matching full:operator
770 /// operator delete[] for the given type has a size_t parameter.
777 // Try to find an operator delete[] in class scope.
787 // Very likely: there's no operator delete[].
790 // If it's ambiguous, it should be illegal to call operator delete[]
807 // If class T does not declare [an operator delete[] with one
809 // named operator delete[] with exactly two parameters, the
1228 /// FindAllocationFunctions - Finds the overloads of operator new and delete
1240 // 2) If an array size is given, look for operator new[], else look for
1241 // operator new.
1258 // function's name is operator new and the deallocation function's
1259 // name is operator delete. If the allocated type is an array
1260 // type, the allocation function's name is operator new[] and the
1261 // deallocation function's name is operator delete[].
1287 // We don't need an operator delete if we're running under
1301 // If the new-expression begins with a unary :: operator, the
1326 // Whether we're looking for a placement operator delete is dictated
1327 // by whether we selected a placement operator new, not by whether
1329 // struct A { void *operator new(size_t, int = 0); ... };
1428 bool AllowMissing, FunctionDecl *&Operator,
1447 // Even member operator new/delete are implicitly treated as
1490 Operator = FnDecl;
1528 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
1532 /// void* operator new(std::size_t) throw(std::bad_alloc);
1533 /// void* operator new[](std::size_t) throw(std::bad_alloc);
1534 /// void operator delete(void *) throw();
1535 /// void operator delete[](void *) throw();
1537 /// void* operator new(std::size_t);
1538 /// void* operator new[](std::size_t);
1539 /// void operator delete(void *);
1540 /// void operator delete[](void *);
1542 /// C++0x operator delete is implicitly noexcept.
1555 // void* operator new(std::size_t) throw(std::bad_alloc);
1556 // void* operator new[](std::size_t) throw(std::bad_alloc);
1557 // void operator delete(void*) throw();
1558 // void operator delete[](void*) throw();
1560 // void* operator new(std::size_t);
1561 // void* operator new[](std::size_t);
1562 // void operator delete(void*);
1563 // void operator delete[](void*);
1565 // These implicit declarations introduce only the function names operator
1566 // new, operator new[], operator delete, operator delete[].
1572 // Note that the C++0x versions of operator delete are deallocation functions,
1679 FunctionDecl* &Operator, bool Diagnose) {
1681 // Try to find operator delete/operator delete[] in class scope.
1694 // Ignore template operator delete members from the check for a usual
1703 // There's exactly one suitable operator; pick it.
1705 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
1707 if (Operator->isDeleted()) {
1710 Diag(Operator->getLocation(), diag::note_unavailable_here) << true;
1733 // We did find operator delete/operator delete[] declarations, but
1757 Operator, Diagnose))
1760 assert(Operator && "Did not find a deallocation function!");
1890 // usual operator delete[] has a size_t parameter.
1898 // Otherwise, the usual operator delete[] should be the
1957 // Check access and ambiguity of operator delete and destructor.
2820 // from having a trivial copy assignment operator (but do cause
2821 // errors if the copy assignment operator is actually used, q.v.
2881 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
2882 if (Operator->isCopyAssignmentOperator()) {
2885 = Operator->getType()->getAs<FunctionProtoType>();
3304 // The binary operator .* [p3: ->*] binds its second operand, which shall
3427 /// This is part of the parameter validation for the ? operator. If either
3518 /// This is part of the parameter validation for the ? operator. If either
3572 llvm_unreachable("Conditional operator has only built-in overloads");
3766 // Extension: conditional operator involving vector types.
3825 /// \param Loc The location of the operator requiring these two expressions to
4200 // If we have a pointer to a dependent type and are using the -> operator,
4213 // [...] When operator->returns, the operator-> is applied to the value
4299 // The left-hand side of the dot operator shall be of scalar type. The
4300 // left-hand side of the arrow operator shall be of pointer to scalar type.
4417 // The left-hand side of the dot operator shall be of scalar type. The
4418 // left-hand side of the arrow operator shall be of pointer to scalar type.
