Lines Matching refs:Operator
890 // capturing lamdbda's call operator.
895 // since a generic lambda's call operator can be instantiated anywhere (even
971 // This is a generic lambda call operator that is being instantiated
981 // call operator. And we should accumulate the constness of *this on the
992 // If we are within a lambda's call operator, the cv-qualifiers of 'this'
1327 /// operator delete[] for the given type has a size_t parameter.
1334 // Try to find an operator delete[] in class scope.
1344 // Very likely: there's no operator delete[].
1347 // If it's ambiguous, it should be illegal to call operator delete[]
1364 // If class T does not declare [an operator delete[] with one
1366 // named operator delete[] with exactly two parameters, the
1783 // Warn if the type is over-aligned and is being allocated by global operator
1955 /// FindAllocationFunctions - Finds the overloads of operator new and delete
1966 // 2) If an array size is given, look for operator new[], else look for
1967 // operator new.
1984 // function's name is operator new and the deallocation function's
1985 // name is operator delete. If the allocated type is an array
1986 // type, the allocation function's name is operator new[] and the
1987 // deallocation function's name is operator delete[].
2014 // MSVC will fall back on trying to find a matching global operator new
2015 // if operator new[] cannot be found. Also, MSVC will leak by not
2016 // generating a call to operator delete or operator delete[], but we
2026 // We don't need an operator delete if we're running under
2035 // If the new-expression begins with a unary :: operator, the
2060 // Whether we're looking for a placement operator delete is dictated
2061 // by whether we selected a placement operator new, not by whether
2063 // struct A { void *operator new(size_t, int = 0); ... };
2182 /// \param Name The name of the function ('operator new' or 'operator new[]').
2188 /// Operator.
2189 /// \param Operator Filled in with the found allocation function. Unchanged if
2196 bool AllowMissing, FunctionDecl *&Operator,
2215 // Even member operator new/delete are implicitly treated as
2242 Operator = FnDecl;
2278 /// DeclareGlobalNewDelete - Declare the global forms of operator new and
2282 /// void* operator new(std::size_t) throw(std::bad_alloc);
2283 /// void* operator new[](std::size_t) throw(std::bad_alloc);
2284 /// void operator delete(void *) throw();
2285 /// void operator delete[](void *) throw();
2287 /// void* operator new(std::size_t);
2288 /// void* operator new[](std::size_t);
2289 /// void operator delete(void *) noexcept;
2290 /// void operator delete[](void *) noexcept;
2292 /// void* operator new(std::size_t);
2293 /// void* operator new[](std::size_t);
2294 /// void operator delete(void *) noexcept;
2295 /// void operator delete[](void *) noexcept;
2296 /// void operator delete(void *, std::size_t) noexcept;
2297 /// void operator delete[](void *, std::size_t) noexcept;
2311 // void* operator new(std::size_t) throw(std::bad_alloc);
2312 // void* operator new[](std::size_t) throw(std::bad_alloc);
2313 // void operator delete(void*) throw();
2314 // void operator delete[](void*) throw();
2316 // void* operator new(std::size_t);
2317 // void* operator new[](std::size_t);
2318 // void operator delete(void*) noexcept;
2319 // void operator delete[](void*) noexcept;
2321 // void* operator new(std::size_t);
2322 // void* operator new[](std::size_t);
2323 // void operator delete(void*) noexcept;
2324 // void operator delete[](void*) noexcept;
2325 // void operator delete(void*, std::size_t) noexcept;
2326 // void operator delete[](void*, std::size_t) noexcept;
2328 // These implicit declarations introduce only the function names operator
2329 // new, operator new[], operator delete, operator delete[].
2503 FunctionDecl* &Operator, bool Diagnose) {
2505 // Try to find operator delete/operator delete[] in class scope.
2518 // Ignore template operator delete members from the check for a usual
2530 // There's exactly one suitable operator; pick it.
2532 Operator = cast<CXXMethodDecl>(Matches[0]->getUnderlyingDecl());
2534 if (Operator->isDeleted()) {
2537 NoteDeletedFunction(Operator);
2562 // We did find operator delete/operator delete[] declarations, but
2577 Operator = nullptr;
2869 // FIXME: If we have an operator T* and an operator void*, we must pick
2870 // the operator T*.
2971 // usual operator delete[] has a size_t parameter.
2979 // Otherwise, the usual operator delete[] should be the
3009 // Check access and ambiguity of operator delete and destructor.
3910 CXXMethodDecl *Operator = cast<CXXMethodDecl>(*Op);
3911 if((Operator->*IsDesiredOp)()) {
3914 Operator->getType()->getAs<FunctionProtoType>();
4103 // from having a trivial copy assignment operator (but do cause
4104 // errors if the copy assignment operator is actually used, q.v.
4804 // The binary operator .* [p3: ->*] binds its second operand, which shall
4928 /// This is part of the parameter validation for the ? operator. If either
5023 /// This is part of the parameter validation for the ? operator. If either
5078 llvm_unreachable("Conditional operator has only built-in overloads");
5294 // Extension: conditional operator involving vector types.
5368 /// \param Loc The location of the operator requiring these two expressions to
5800 // -- the right operand of a comma operator that is the operand of a
5887 /// Note a set of 'operator->' functions that were used for a member access.
5930 // If we have a pointer to a dependent type and are using the -> operator,
5943 // [...] When operator->returns, the operator-> is applied to the value
6066 // The left-hand side of the dot operator shall be of scalar type. The
6067 // left-hand side of the arrow operator shall be of pointer to scalar type.
6070 // arrow operator.
6594 "The current call operator must be synchronized with Sema's CurContext");
7062 // even if CurContext is not a lambda call operator. Refer to that Bug Report
7064 // By ensuring we are in the context of a lambda's call operator
