Home | History | Annotate | Download | only in Sema

Lines Matching refs:Function

497     //       non-volatile automatic object (other than a function or catch-
550 // the type from "array of T" or "function returning T" to "pointer to T"
551 // or "pointer to function returning T", [...]
590 // non-volatile automatic object (other than a function or catch-clause
681 /// C++ 9.3.2: In the body of a non-static member function, the keyword this
683 /// which the function is called.
708 /// Can be interpreted either as function-style casting ("int(x)")
799 // A template instance is never a usual deallocation function,
808 // parameter] but does declare a member deallocation function
810 // second of which has type std::size_t, then this function
811 // is a usual deallocation function.
1047 // deallocation function for the type has a size_t parameter.
1214 /// \brief Determine whether the given function is a non-placement
1215 /// deallocation function.
1236 // --- Choosing an allocation function ---
1258 // function's name is operator new and the deallocation function's
1260 // type, the allocation function's name is operator new[] and the
1261 // deallocation function's name is operator delete[].
1302 // deallocation function's name is looked up in the global
1304 // array thereof, the deallocation function's name is looked up in
1307 // deallocation function's name is looked up in the global scope.
1335 // A declaration of a placement deallocation function matches the
1336 // declaration of a placement allocation function if it has the
1341 // To perform this comparison, we compute the function type that
1342 // the deallocation function should have, and use that type both
1371 // expected function type.
1383 // [...] Any non-placement deallocation function matches a
1384 // non-placement allocation function. [...]
1396 // function, that function will be called; otherwise, no
1397 // deallocation function will be called.
1403 // deallocation function (3.7.4.2) and that function, considered
1404 // as a placement deallocation function, would have been
1405 // selected as a match for the allocation function, the program
1424 /// function in the specified scope.
1469 FunctionDecl *FnDecl = Best->Function;
1474 // Watch out for variadic allocator function.
1515 << Best->Function->isDeleted()
1517 << getDeletedOrUnavailableSuffix(Best->Function)
1565 // These implicit declarations introduce only the function names operator
1606 /// allocation function if it doesn't already exist.
1612 // Check if this function is already declared.
1618 // non-templated allocation function we are trying to declare here.
1695 // deallocation function.
1760 assert(Operator && "Did not find a deallocation function!");
1773 // conversion function to a pointer type. The result has type void.
1899 // function we just found.
1981 // The declarator shall not specify a function or an array.
2019 /// Helper function to determine whether this is the (deprecated) C++
2135 // If the user-defined conversion is specified by a conversion function,
2137 // the implicit object parameter of the conversion function.
2241 // Resolve overloaded function references.
2986 // function call.
3070 // Given the following function prototype:
3079 // type of the function:
3373 // The result is an object or a function of the type specified by the
3382 // ill-formed if the second operand is a pointer to member function with
3385 // is a pointer to member function with ref-qualifier &&.
3410 // operand is a pointer to a member function is a prvalue. The
3429 /// converted to each other. This function does the conversion in one direction.
3502 // to the array-to-pointer or function-to-pointer conversions.
3545 if (Best->Function)
3546 Self.MarkDeclarationReferenced(QuestionLoc, Best->Function);
3728 // LValue-to-rvalue, array-to-pointer, and function-to-pointer standard
3838 assert(getLangOptions().CPlusPlus && "This function assumes C++");
4075 assert(FTy && "call to value not of function type?");
4600 // In C, function designators (i.e. expressions of function type)
4601 // are r-values, but we still want to do function-to-pointer decay