Lines Matching defs:If
188 // If we have an MSAny spec already, don't bother.
200 // If we have a throw-all spec at this point, ignore the function.
213 // If this function can throw any exceptions, make a note of that.
225 // FIXME: If the call to this decl is using any of its default arguments, we
227 // If this function has a basic noexcept, it doesn't affect the outcome.
232 // If we're still at noexcept(true) and there's a throw() callee,
409 // parameter pack. If it is specified in a
487 // If only one of these is a local function declaration, then they are
489 // they're in the same scope. (If both are local, the scope check is
548 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
641 // DR1344: If a default argument is added outside a class definition and that
658 // C++11 [dcl.constexpr]p1: If any declaration of a function or function
669 // If a friend function is inlined but does not have 'inline'
675 // If the definition of a function appears in a translation unit before its
692 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
761 // If decl-specifier-seq contains any decl-specifier other than static,
1132 // If there's no tuple_size specialization or the lookup of 'value' is empty,
1138 // If we get this far, we've committed to the tuple interpretation, but
1372 // If no classes have fields, just decompose RD itself. (This will work
1506 // If the type of the member is T, the referenced type is cv T, where cv is
1526 // If the type of the decomposition is dependent, then so is the type of
1538 // If E is an array type [...]
1727 /// Check whether a function's parameter types are all literal types. If so,
1728 /// return true. If not, produce a suitable diagnostic and return false.
1751 /// Check whether a function's return type is a literal type. If so, return
1752 /// true. If not, produce a suitable diagnostic and return false.
1829 // If it's not obvious why this function is virtual, find an overridden
2072 // If an anonymous union contains an anonymous struct of which any member
2144 IfStmt *If = cast<IfStmt>(S);
2145 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
2148 if (If->getElse() &&
2149 !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
2295 // If this is only valid as an extension, report that we don't satisfy the
2686 // "If a base-class has a code_seg attribute, derived classes must have the
2701 // - If the layout determines that a base comes before another base,
2703 // - If the layout determines that base comes before the derived class,
2712 // If a class is marked final and it appears as a base-type-specifier in
2722 // If the base class is invalid the derived class is as well.
2729 // constexpr evaluator). If this case happens (in errory-recovery mode), we
2824 // If we've not already seen it, recurse.
2956 // If either the base or the derived type is invalid, don't try to
3157 // If we have a non-virtual method, check if it hides a virtual method.
3199 // If a function is marked with the virt-specifier override and
3546 // If we have declared a member function template or static data member
3636 // If non-null, add a note to the warning pointing back to the constructor.
3923 // If a field assignment is detected, remove the field from the
4410 // If no results were found, try to correct typos.
4603 // If we are in a dependent context, template instantiation will
4676 // If the class has any dependent bases, then it's possible that
4700 // If a mem-initializer-id is ambiguous because it designates both
4741 // If we are in a dependent context, template instantiation will
5084 // If there's no explicit initialization, the field is active only if it
5300 // If a given [...] base class is not named by a mem-initializer-id
5348 // If we're not generating the implicit copy/move constructor, then we'll
5499 // If we didn't find this initializer, it must be because we
5544 // If there is only 1 item out of order, the warning expects the name and
5749 // If the destructor exists and has already been marked used in the MS ABI,
5774 // If our base class is invalid, we probably can't get its dtor anyway.
5813 // If our base class is invalid, we probably can't get its dtor anyway.
5867 // definition. If it's currently being defined, we'll walk back
5893 // If the diagnostic is suppressed, don't emit the notes. We're only
6023 // If there's no inner type and we're in a permissive context,
6176 // If this is an MS ABI dllexport default constructor, instantiate any
6231 // If the class is non-dependent, mark the default arguments as ODR-used so
6557 // If the base class template has a DLL attribute, don't try to change it.
6572 // If this was an import, mark that we propagated it from a derived class to
6577 // If the template is already instantiated, checkDLLAttributeRedeclaration()
6712 // If a class has at least one eligible, trivial copy constructor, it
6746 // If the copy ctor and dtor are both trivial-for-calls, pass direct.
6750 // If a class has a destructor, we'd really like to pass it indirectly
6840 // If this is not an aggregate type and has no user-declared constructor,
6868 // If T is the name of a class, then each of the following shall have a
7131 // If this is a member function, we deferred checking it until now.
7171 // If canPassInRegisters returns true despite the record having a non-trivial
7181 // If we want to emit all the vtables, we need to mark it as used. This
7199 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
7263 // If the constructor was inherited from multiple base class subobjects
7319 // If we're inheriting a constructor, see if we need to call it for this base
7391 // If we squint, this is guaranteed, since exactly one non-static data member
7728 // If the instantiated template specialization of a constexpr function
7758 // If a function is explicitly defaulted on its first declaration, it is
7768 // If a declaration of a function does not have a noexcept-specifier
7821 /// identified, and some of them are checked. If any of the checked
8135 // If it's not constexpr, explain why not.
8148 // If any callee has an undeduced return type, deduce it now.
8241 // If there's no usable candidate, we're done unless we can rewrite a
8333 // index i where xi == yi yields [...] false. If no such index exists,
8375 // If no such index exists, V is true.
8735 // If we're out-of-class, this is the class we're comparing.
8884 // Let R be the declared return type [...]. If R is auto, [...]. Otherwise,
8936 // If we want to delete the function, then do so; there's nothing else to
9003 // If a constexpr-compatible function is explicitly defaulted on its first
9011 // If a declaration of a function does not have a noexcept-specifier
9306 /// If we're operating on a base class, the object type is the
9314 // If we're operating on a field, the object type is the type of the field.
9457 // If program is correct, BaseClass cannot be null, but if it is, the error
9461 // If we have an inheriting constructor, check whether we're calling an
9647 // If the class definition declares a move constructor or move assignment
9767 /// whether it is trivial. If the triviality can be determined without the
9772 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
9775 /// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
9799 // If there's a default constructor which could have been trivial, dig it
10241 // If the method we are checking overrides a method from its base
10347 // If the type is dependent, then assume it might have
10518 // If the properties or semantics of the copy constructor couldn't be
10549 // If we have a dynamic class, then the copy assignment operator may be
10572 // If we have a dynamic class, then the destructor may be virtual, so we
10583 // If the member-specification does not explicitly declare any member or
10851 // If we have a virtual destructor, look up the deallocation function
10856 // If the notional 'delete this' expression requires a non-trivial
11123 // If we can provide a correct fix-it hint, do so.
11690 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
11705 // If this namespace contains an export-declaration, export it now.
11772 // before. If so, skip checking it again.
11783 // If lookup failed
11847 // the value of its first field as a ICE. If this fails, the STL
11886 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
12182 // If the scope has an associated entity and the using directive is at
12403 // If the target happens to be one of the previous declarations, we
12421 // If T is the name of a class, then [every named member other than
12476 // If we're in a record, we want to hide the target, so we
12482 // If we're not in a record, this is an error.
12529 // If we resolved to another shadow declaration, just coalesce them.
12697 // If we found a local extern declaration that's not ordinarily visible,
12841 // Try to correct typos if possible. If constructor name lookup finds no
12867 // If we picked a correction with no attached Decl we can't do anything
12873 // If we corrected to an inheriting constructor, handle it as one.
12913 // If we asked for a typename and got a non-type decl, error out.
12923 // If we asked for a non-typename and we got a type, error out,
13180 // If we weren't able to compute a valid scope, it might validly be a
13181 // dependent class or enumeration scope. If we have a 'typename' keyword,
13256 // If the named context is dependent, we can't decide much.
13710 // FIXME: If this diagnostic fires, we're probably missing a check for
13830 // that can be called without an argument. If there is no
14118 // If a class has no user-declared destructor, a destructor is
14245 // If the context is an invalid C++ class, just suppress these checks.
14310 // FIXME: If the destructor has a body that could throw, and the newly created
14624 // If we built a call to a trivial 'operator=' while copying an array,
14736 // If we ended up picking a trivial assignment operator for an array of a
15206 // If the base has no non-trivial move assignment operators,
15211 // If there's nothing virtual here, skip it.
15215 // If we're not actually going to call a move assignment for this base,
15228 // assignment operator is not trivial. If this can happen for
15229 // multiple distinct direct bases of Class, diagnose it. (If it
15494 // If the class definition does not explicitly declare a copy
15861 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
16006 // If initializing the variable failed, don't also diagnose problems with
16025 // If this is an array, we'll require the destructor during initialization, so
16038 // If the destructor is constexpr, check whether the variable has constant
16080 // If too few arguments are available, we'll fill in the rest with defaults.
16423 // prefix and postfix ++ operator. If this function is a member
16426 // increment operator ++ for objects of that type. If the function
16701 /// If the declaration is already in global module fragment, we don't
16721 // If the current module doesn't has Parent, it implies that the
16859 // If the constructor used was non-trivial, set this as the
17317 // If the static_assert passes, only verify that
17326 // [dcl.pre]/p10 If [...] the expression is evaluated in the context of a
17431 // If it's explicit specializations all the way down, just forget
17518 // If the friend keyword isn't first, or if the declarations has any type
17622 // If a declaration acquires a function type through a
17636 // - If a friend declaration in a non-local class first declares a
17643 // - If a friend function is called, its name may be found by the
17678 // If a friend declaration appears in a local class and the name
17711 // If the name in a friend declaration is neither qualified nor
17720 // Skip class contexts. If someone can cite chapter and verse
17824 // If we performed typo correction, we might have added a scope specifier
17890 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
17896 // if we're in a dependent context. If the function is known to be a
18028 // If this comparison's defaulting occurs within the definition of its
18035 // If this member fn was defaulted on its first declaration, we will have
18173 // If the calling conventions match, everything is fine
18177 // If the calling conventions mismatch because the new function is static,
18246 // If the class type in the covariant return type of D::f differs from
18341 /// class X. If the declaration had a scope specifier, a scope will have
18382 // constant expressions. If the initializer IS an immediate function context,
18460 // If we already had an entry, check to see if we are promoting this vtable
18461 // to require a definition. If so, we need to reappend to the VTableUses
18478 // If this is an out-of-line declaration, marking it referenced will
18526 // If this class has a key function, but that key function is
18538 // If we have a class with no key function that is the subject
18671 // If we haven't diagnosed this cycle yet, do so now.
18750 // If the return type came after the cv-qualifier-seq, check it now.