Lines Matching refs:If
162 // If we have an MSAny spec already, don't bother.
174 // If we have a throw-all spec at this point, ignore the function.
187 // If this function can throw any exceptions, make a note of that.
199 // FIXME: If the call to this decl is using any of its default arguments, we
201 // If this function has a basic noexcept, it doesn't affect the outcome.
206 // If we're still at noexcept(true) and there's a throw() callee,
305 /// provided for a function parameter is well-formed. If so, attach it
400 // parameter pack. If it is specified in a
482 // If only one of these is a local function declaration, then they are
484 // they're in the same scope. (If both are local, the scope check is
543 // FIXME: If we knew where the '=' was, we could easily provide a fix-it
636 // DR1344: If a default argument is added outside a class definition and that
653 // C++11 [dcl.constexpr]p1: If any declaration of a function or function
663 // If a friend function is inlined but does not have 'inline'
669 // If the definition of a function appears in a translation unit before its
686 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
738 // If decl-specifier-seq contains any decl-specifier other than static,
1055 // If there's no tuple_size specialization or the lookup of 'value' is empty,
1061 // If we get this far, we've committed to the tuple interpretation, but
1290 // If no classes have fields, just decompose RD itself. (This will work
1413 // If the type of the member is T, the referenced type is cv T, where cv is
1433 // If the type of the decomposition is dependent, then so is the type of
1445 // If E is an array type [...]
1639 /// Check whether a function's parameter types are all literal types. If so,
1640 /// return true. If not, produce a suitable diagnostic and return false.
1660 /// Check whether a function's return type is a literal type. If so, return
1661 /// true. If not, produce a suitable diagnostic and return false.
1690 // constexpr function definition or a constexpr constructor definition. If so,
1691 // return true. If not, produce appropriate diagnostics (unless asked not to by
1738 // If it's not obvious why this function is virtual, find an overridden
1966 // If an anonymous union contains an anonymous struct of which any member
2035 IfStmt *If = cast<IfStmt>(S);
2036 if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
2039 if (If->getElse() &&
2040 !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
2172 // If this is only valid as an extension, report that we don't satisfy the
2332 /// If the scope specifier denotes a class, this will be that class.
2333 /// If the scope specifier is empty, this will be the class whose
2361 /// the class type currently being defined. If so, update it to the identifier
2507 // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
2516 // "If a base-class has a code_seg attribute, derived classes must have the
2530 // - If the layout determines that a base comes before another base,
2532 // - If the layout determines that base comes before the derived class,
2541 // If a class is marked final and it appears as a base-type-specifier in
2631 // If we've not already seen it, recurse.
2768 // If either the base or the derived type is invalid, don't try to
2836 /// If either InaccessibleBaseID or AmbiguousBaseConvID are 0, then the
2997 // If we have a non-virtual method, check if if hides a virtual method.
3039 // If a function is marked with the virt-specifier override and
3414 // If we have declared a member function template or static data member
3494 // If non-null, add a note to the warning pointing back to the constructor.
3780 // If a field assignment is detected, remove the field from the
4200 // If no results were found, try to correct typos.
4384 // If we are in a dependent context, template instantiation will
4452 // If the class has any dependent bases, then it's possible that
4476 // If a mem-initializer-id is ambiguous because it designates both
4514 // If we are in a dependent context, template instantiation will
4856 // If there's no explicit initialization, the field is active only if it
5072 // If a given [...] base class is not named by a mem-initializer-id
5120 // If we're not generating the implicit copy/move constructor, then we'll
5252 // If we didn't find this initializer, it must be because we
5468 // If the destructor exists and has already been marked used in the MS ABI,
5492 // If our base class is invalid, we probably can't get its dtor anyway.
5529 // If our base class is invalid, we probably can't get its dtor anyway.
5577 // definition. If it's currently being defined, we'll walk back
5603 // If the diagnostic is suppressed, don't emit the notes. We're only
5733 // If there's no inner type and we're in a permissive context,
5906 // If the class is non-dependent, mark the default arguments as ODR-used so
6225 // If the base class template has a DLL attribute, don't try to change it.
6240 // If this was an import, mark that we propagated it from a derived class to
6245 // If the template is already instantiated, checkDLLAttributeRedeclaration()
6280 /// If the function is both a default constructor and a copy / move constructor
6387 // If a class has at least one non-deleted, trivial copy constructor, it
6420 // If the copy ctor and dtor are both trivial-for-calls, pass direct.
6424 // If a class has a destructor, we'd really like to pass it indirectly
6521 // If this is not an aggregate type and has no user-declared constructor,
6549 // If T is the name of a class, then each of the following shall have a
6772 // If this is a member function, we deferred checking it until now.
6811 // If canPassInRegisters returns true despite the record having a non-trivial
6821 // If we want to emit all the vtables, we need to mark it as used. This
6839 /// \param FieldQuals If the subobject is a field, its cv-qualifiers.
6900 // If the constructor was inherited from multiple base class subobjects
6953 // If we're inheriting a constructor, see if we need to call it for this base
7025 // If we squint, this is guaranteed, since exactly one non-static data member
7331 // If a function is explicitly defaulted on its first declaration, it is
7340 // If a declaration of a function does not have a noexcept-specifier
7388 /// identified, and some of them are checked. If any of the checked
7683 // If it's not constexpr, explain why not.
7698 // If any callee has an undeduced return type, deduce it now.
7783 // If there's no usable candidate, we're done unless we can rewrite a
7874 // index i where xi == yi yields [...] false. If no such index exists,
7916 // If no such index exists, V is true.
8331 // Let R be the declared return type [...]. If R is auto, [...]. Otherwise,
8355 // If we want to delete the function, then do so; there's nothing else to
8423 // If a constexpr-compatible function is explicitly defaulted on its first
8431 // If a declaration of a function does not have a noexcept-specifier
8719 /// If we're operating on a base class, the object type is the
8727 // If we're operating on a field, the object type is the type of the field.
8857 // If program is correct, BaseClass cannot be null, but if it is, the error
8861 // If we have an inheriting constructor, check whether we're calling an
9043 // If the class definition declares a move constructor or move assignment
9161 /// whether it is trivial. If the triviality can be determined without the
9166 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
9169 /// If \p ForCall is true, look at CXXRecord::HasTrivialSpecialMembersForCall to
9193 // If there's a default constructor which could have been trivial, dig it
9619 // If the method we are checking overrides a method from its base
9729 // If the type is dependent, then assume it might have
9870 // If the properties or semantics of the copy constructor couldn't be
9901 // If we have a dynamic class, then the copy assignment operator may be
9924 // If we have a dynamic class, then the destructor may be virtual, so we
9935 // If the member-specification does not explicitly declare any member or
10119 /// R. If there are any errors in the declarator, this routine will
10232 // If we have a virtual destructor, look up the deallocation function
10237 // If the notional 'delete this' expression requires a non-trivial
10272 /// R. If there are any errors in the declarator, this routine will
10394 /// type @p R. If there are any errors in the declarator, this routine
10506 // If we can provide a correct fix-it hint, do so.
10941 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
10958 // If this namespace contains an export-declaration, export it now.
11039 // before. If so, skip checking it again.
11050 // If lookup failed
11114 // the value of its first field as a ICE. If this fails, the STL
11152 if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
11413 // If the scope has an associated entity and the using directive is at
11585 // If the target happens to be one of the previous declarations, we
11603 // If T is the name of a class, then [every named member other than
11644 // If we're in a record, we want to hide the target, so we
11650 // If we're not in a record, this is an error.
11699 // If we resolved to another shadow declaration, just coalesce them.
11924 // If we found a local extern declaration that's not ordinarily visible,
12018 // Try to correct typos if possible. If constructor name lookup finds no
12045 // If we picked a correction with no attached Decl we can't do anything
12051 // If we corrected to an inheriting constructor, handle it as one.
12091 // If we asked for a typename and got a non-type decl, error out.
12100 // If we asked for a non-typename and we got a type, error out,
12270 /// scope. If an error is found, diagnoses it and returns true.
12283 // If we weren't able to compute a valid scope, it might validly be a
12284 // dependent class scope or a dependent enumeration unscoped scope. If
12297 // If we have a complete, non-dependent source type, try to suggest a
12363 // If the named context is dependent, we can't decide much.
12804 // FIXME: If this diagnostic fires, we're probably missing a check for
12913 // that can be called without an argument. If there is no
13193 // If a class has no user-declared destructor, a destructor is
13321 // If the context is an invalid C++ class, just suppress these checks.
13385 // FIXME: If the destructor has a body that could throw, and the newly created
13699 // If we built a call to a trivial 'operator=' while copying an array,
13810 // If we ended up picking a trivial assignment operator for an array of a
14251 // If the base has no non-trivial move assignment operators,
14256 // If there's nothing virtual here, skip it.
14260 // If we're not actually going to call a move assignment for this base,
14273 // assignment operator is not trivial. If this can happen for
14274 // multiple distinct direct bases of Class, diagnose it. (If it
14524 // If the class definition does not explicitly declare a copy
14864 // If we're not under ARC, make sure we still get the _Block_copy/autorelease
15018 // If we already have the in-class initializer nothing needs to be done.
15022 // If we might have already tried and failed to instantiate, don't try again.
15065 // If the brace-or-equal-initializer of a non-static data member
15090 // If initializing the variable failed, don't also diagnose problems with
15105 // If this is an array, we'll require the destructor during initialization, so
15118 // If the destructor is constexpr, check whether the variable has constant
15164 // If too few arguments are available, we'll fill in the rest with defaults.
15355 /// of this overloaded operator is well-formed. If so, returns false;
15469 // prefix and postfix ++ operator. If this function is a member
15472 // increment operator ++ for objects of that type. If the function
15535 /// of this literal operator function is well-formed. If so, returns
15741 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
15880 // If the constructor used was non-trivial, set this as the
16065 // If we evaluated the type to a record type, suggest putting
16108 // If the type specifier in a friend declaration designates a (possibly
16163 // If it's explicit specializations all the way down, just forget
16358 // If a declaration acquires a function type through a
16372 // - If a friend declaration in a non-local class first declares a
16379 // - If a friend function is called, its name may be found by the
16412 // If a friend declaration appears in a local class and the name
16453 // If the name in a friend declaration is neither qualified nor
16464 // Skip class contexts. If someone can cite chapter and verse
16598 // If we performed typo correction, we might have added a scope specifier
16632 // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
16638 // if we're in a dependent context. If the function is known to be a
16772 // If this definition appears within the record, do the checking when
16785 // If the method was defaulted on its first declaration, we will have
16848 // If the calling conventions match, everything is fine
16852 // If the calling conventions mismatch because the new function is static,
16907 // If the class type in the covariant return type of D::f differs from
17016 /// class X. If the declaration had a scope specifier, a scope will have
17019 // If there is no declaration, there was an error parsing it.
17030 // If we are parsing the initializer for a static data member, push a
17040 // If there is no declaration, there was an error parsing it.
17122 // If we already had an entry, check to see if we are promoting this vtable
17123 // to require a definition. If so, we need to reappend to the VTableUses
17140 // If this is an out-of-line declaration, marking it referenced will
17182 // If this class has a key function, but that key function is
17196 // If we have a class with no key function that is the subject
17387 // If we haven't diagnosed this cycle yet, do so now.
17466 // If the return type came after the cv-qualifier-seq, check it now.