Lines Matching refs:Function
54 // See if this is a deleted function.
60 // See if this function is unavailable.
137 /// \brief Emit a note explaining that this function is deleted or unavailable.
146 // Try to diagnose why this special member function was implicitly
171 /// \brief Check whether we're in an extern inline function and referring to a
172 /// variable or function with internal linkage (C11 6.7.4p3).
188 // Check if this is an inlined function or method.
202 // (1) the supposedly external inline function is in the main file,
204 // (2) the thing we're referencing is a pure function.
205 // (3) the thing we're referencing is another inline function.
217 // Suggest "static" on the inline function, if possible.
237 /// function is being used.
269 // See if this is a deleted function.
287 /// diagnostic complaining about the given function being deleted or
462 // A glvalue of a non-function, non-array type T can be
542 /// operators (C99 6.3). The conversions of array and function types are
591 /// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that
753 /// \brief Converts an integer to complex float type. Helper function of
779 /// Helper function of UsualArithmeticConversions()
800 /// necessary. Helper function of UsualArithmeticConversions()
840 function of
887 /// \brief Hande arithmetic conversion from integer to float. Helper function
919 /// function of UsualArithmeticConversions()
955 /// permit their use as function template parameters.
966 /// \brief Handle integer arithmetic conversions. Helper function of
1017 /// \brief Handle conversions with GCC complex int extension. Helper function
1545 // function parameter list, hence add an explicit check.
1604 // and the found name refers to an instance member function, otherwise
1605 // the function calling DiagnoseEmptyLookup will try to create an
1620 // function definition declared at class scope then we must set
1658 ND = Best->Function;
1762 // -- a conversion-function-id that specifies a dependent type,
1832 // Otherwise, this could be an implicitly declared function reference (legal
1839 // If this name wasn't predeclared and if this is not a function
1843 // In Microsoft mode, if we are inside a template class member function
1881 // body of a non-static member function of class X, if name lookup
1888 // resolved to a function or overloaded function set, because the
1890 // non-static member function:
1893 // Otherwise, if E1.E2 refers to a non-static member function. . .
1895 // member function call.
2305 // -- a block-scope function declaration that is not a
2307 // NOTE: we also trigger this for function templates (in fact, we
2316 // -- a declaration that is neither a function or a function
2368 // functions and function templates.
2395 "Cannot refer unambiguously to a function template");
2421 // on this function name, because this might not be the function
2522 case Decl::Function: {
2533 // If we're referring to a function with an __unknown_anytype
2547 // C99 DR 316 says that, if a function type comes from a
2548 // function definition (without a prototype), that type is only
2550 // the function, we pretend that we don't have the full function
2598 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
2995 // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in
3016 // alignof(function) is allowed as an extension.
3111 /// The UsualUnaryConversions() function is *not* called by this routine.
3116 /// The lvalue-to-rvalue, array-to-pointer, and function-to-pointer
3652 /// Args/NumArgs to the parameter types of the function FDecl with
3653 /// function prototype Proto. Call is the call expression itself, and
3654 /// Fn is the function expression. For a C++ member function, this
3678 : (IsExecConfig ? 3 /* kernel function (exec config) */
3679 : 0 /* function */);
3874 /// array type derivation, then for each call to the function, the value of the
3916 /// Given a function expression of unknown-any type, try to rebuild it
3917 /// to have a function type.
4006 // If we're directly calling a function, get the appropriate declaration.
4070 /// unary-convert to an expression of function-pointer or
4083 // Promote the function operand.
4084 // We special-case function promotion here because we only allow promoting
4085 // builtin functions to function pointers in the callee of a call.
4099 // of arguments and function on error.
4122 // C99 6.5.2.2p1 - "The expression that denotes the called function shall
4123 // have type pointer to function".
4152 // CUDA: Kernel function must have 'void' return type
4184 // on our knowledge of the function definition.
4193 // If the function we're calling isn't a function prototype, but we have
4194 // a function prototype from a prior declaratiom, use that prototype.
4673 } else { // isa<ParenExpr> by assertion at function entrance
5529 // As an extension, we allow cast to/from void* to function pointer.
5538 // As an extension, we allow cast to/from void* to function pointer.
5595 /// are compatible. It is more restrict than comparing two function pointer
5724 // e.g., as a parameter type in a built-in function. In this case,
6320 /// \brief Diagnose invalid arithmetic on two function pointers.
6336 /// \brief Diagnose invalid arithmetic on a function pointer.
7180 // Valid unless comparison between non-null pointer and function pointer
7205 // Valid unless a relational comparison of function pointers
7213 // Valid unless comparison between non-null pointer and function pointer
7680 // from an enclosing function or block.
7866 // paths through the function. This should be revisited if
8003 /// getPrimaryDecl - Helper function for CheckAddressOfOperand().
8006 /// handle cases when the expression references a function designator
8009 /// - &*****f => f for f a function designator.
8077 /// CheckAddressOfOperand - The operand of & must be either a function
8082 /// In C++, the operand might be an overloaded function name, in which case
8083 /// we allow the '&' but retain the overloaded-function type.
8180 // The operand must be either an l-value or a function designator
9109 /// ns_returns_retained function) and, if so, rebuild it to hoist the
9135 // Note that function is also called by TreeTransform when leaving a
9176 // Do function/array conversion on the last expression, but not
9493 // GetTypeForDeclarator always produces a function type for a block
9495 // unless the function was written with a typedef.
9497 "GetTypeForDeclarator made a non-function block signature");
9499 // Look for an explicit signature in that function type.
9657 // If the user wrote a function type in some form, try to use that.
9670 // Otherwise, if we don't need to change anything about the function type,
9676 // Otherwise, make the minimal modifications to the function type.
9689 // If we don't have a function type, just build one from nothing.
10093 // have a single non-explicit conversion function to an integral or
10443 /// \brief Mark a function referenced, and check whether it is odr-used
10446 assert(Func && "No function?");
10451 // A function whose name appears as a potentially-evaluated expression is
10456 // can just check that here. Skip the rest of this function if we've already
10457 // marked the function as used.
10460 // Unless a function template specialization has been explicitly
10461 // instantiated or explicitly specialized, the function template
10463 // referenced in a context that requires a function definition to exist.
10465 // We consider constexpr function templates to be referenced in a context
10470 // function template or overload resolution or other cases which we
10474 // we are not permitted to instantiate this constexpr function definition.
10538 // Recursive functions should be marked when used from another function.
10542 // Resolve the exception specification for any function which is
10548 // Implicit instantiation of function templates and member functions of
10581 // call to such a function.
10586 // Notify the consumer that a function was implicitly instantiated.
10612 // and, because of the two phase lookup, this function is called with at
10636 // function context, so we'll get other (more useful) diagnostics later.
11038 // captured entity is a reference to a function, the
11040 // function. - end note ]
11073 // function call operator [...]. This function call operator is
11132 // is immediately applied." This function handles the lvalue-to-rvalue
11272 // A non-overloaded function whose name appears as a potentially-evaluated
11275 // expression, is odr-used, unless it is a pure virtual function and its
11718 /// Given a function expression of unknown-any type, try to rebuild it
11719 /// to have a function type.
11834 // Verify that this is a legal result type of a function.
11850 // Rebuild the function type, replacing the result type with DestType.
11861 // Rebuild the appropriate pointer-to-function type.
11907 // The only case we should ever see here is a function-to-pointer decay.
11914 // Rebuild the sub-expression as the pointee (function) type.
11971 // Function references aren't l-values in C.
12094 // Try to resolve a single function template specialization.
