lib/Sema/SemaDeclCXX.cpp

153   // If we have an MSAny spec already, don't bother.
165   // If this function can throw any exceptions, make a note of that.
172   // FIXME: If the call to this decl is using any of its default arguments, we
175   // If this function has a basic noexcept, it doesn't affect the outcome.
179   // If we have a throw-all spec at this point, ignore the function.
183   // If we're still at noexcept(true) and there's a nothrow() callee,
298 /// provided for a function parameter is well-formed. If so, attach it
369   //   parameter pack. If it is specified in a
487       // FIXME: If we knew where the '=' was, we could easily provide a fix-it
573   // DR1344: If a default argument is added outside a class definition and that
589   // C++11 [dcl.constexpr]p1: If any declaration of a function or function
599   // C++11 [dcl.fct.default]p4: If a friend declaration specifies a default
711 // are all literal types. If so, return true. If not, produce a suitable
747 // constructor definition. If so, return true. If not, produce appropriate
780       // If it's not obvious why this function is virtual, find an overridden
949       // If an anonymous union contains an anonymous struct of which any member
1015     IfStmt *If = cast<IfStmt>(S);
1016     if (!CheckConstexprFunctionStmt(SemaRef, Dcl, If->getThen(), ReturnStmts,
1019     if (If->getElse() &&
1020         !CheckConstexprFunctionStmt(SemaRef, Dcl, If->getElse(), ReturnStmts,
1231 /// the class type currently being defined. If so, update it to the identifier
1365   // If the base class is polymorphic or isn't empty, the new one is/isn't, too.
1375   //   - If the layout determines that a base comes before another base,
1377   //   - If the layout determines that base comes before the derived class,
1386   //   If a class is marked final and it appears as a base-type-specifier in
1554   // If either the base or the derived type is invalid, don't try to
1765     // If we have a non-virtual method, check if if hides a virtual method.
1807   //   If a virtual function is marked with the virt-specifier override and
2076     // If we have declared a member function template or static data member
2128     // If non-null, add a note to the warning pointing back to the constructor.
2254       // If a field assignment is detected, remove the field from the
2583       // If no results were found, try to correct typos.
2810   // If we are in a dependent context, template instantiation will
2878       // If the class has any dependent bases, then it's possible that
2902   //   If a mem-initializer-id is ambiguous because it designates both
2939   // If we are in a dependent context, template instantiation will
3538       //   If a given [...] base class is not named by a mem-initializer-id
3589       // If we're not generating the implicit copy/move constructor, then we'll
3727     // If we didn't find this initializer, it must be because we
3955     // If our base class is invalid, we probably can't get its dtor anyway.
3987     // If our base class is invalid, we probably can't get its dtor anyway.
4069   // definition.  If it's currently being defined, we'll walk back
4090   // If the diagnostic is suppressed, don't emit the notes. We're only
4220     // If there's no inner type and we're in a permissive context,
4314   // If this is not an aggregate type and has no user-declared constructor,
4347     //   If T is the name of a class, then each of the following shall have a
4415   // If the class has virtual bases, any constexpr members will already have
4431           // If a template instantiates to a non-literal type, but its members
4524   // If we squint, this is guaranteed, since exactly one non-static data member
4770       // If the exception specification needs to be instantiated, do so now,
4781   //   If a function is explicitly defaulted on its first declaration,
4948   /// If we're operating on a base class, the object type is the
4956   // If we're operating on a field, the object type is the type of the field.
5211   //   If the class definition declares a move constructor or move assignment
5306 /// whether it is trivial. If the triviality can be determined without the
5311 /// If \p Selected is not \c NULL, \c *Selected will be filled in with the
5333       // If there's a default constructor which could have been trivial, dig it
5765       // If the method we are checking overrides a method from its base
5892     // If the properties or semantics of the copy constructor couldn't be
5909     // If we have a dynamic class, then the copy assignment operator may be
5930     // If we have a dynamic class, then the destructor may be virtual, so we
6017   // If this parameter has an unparsed default argument, clear it out
6055 /// R. If there are any errors in the declarator, this routine will
6172     // If we have a virtual destructor, look up the deallocation function
6178     // If there's no class-specific operator delete, look up the global
6200 /// R. If there are any errors in the declarator, this routine will
6307 /// type @p R. If there are any errors in the declarator, this routine
6643 /// getNamespaceDecl - Returns the namespace a decl represents. If the decl
6696   if (!StdNamespace) // If we haven't seen namespace std yet, this can't be it.
6953   // If the scope has an associated entity and the using directive is at
7111   // If the target happens to be one of the previous declarations, we
7151       // If we're in a record, we want to hide the target, so we
7157       // If we're not in a record, this is an error.
7194   // If we resolved to another shadow declaration, just coalesce them.
7444     // If we asked for a typename and got a non-type decl, error out.
7454     // If we asked for a non-typename and we got a type, error out,
7580 /// scope.  If an error is found, diagnoses it and returns true.
7591     // If we weren't able to compute a valid scope, it must be a
7605   // If the named context is dependent, we can't decide much.
7935       // If this is a deleted function, add it anyway. This might be conformant
7949       // If this is a deleted function, add it anyway. This might be conformant
7965         //   If the brace-or-equal-initializer of a non-static data member
7983       // If this is a deleted function, add it anyway. This might be conformant
8101   //   that can be called without an argument. If there is no
8214     /// If \c true, a constructor with this signature is already declared
8364     //   If two using-declarations declare inheriting constructors with the
8447     // If this is a constructor template, build the template declaration.
8570   //   If a class has no user-declared destructor, a destructor is
8657   // If the context is an invalid C++ class, just suppress these checks.
8689   // FIXME: If the destructor has a body that could throw, and the newly created
9003     // If we built a call to a trivial 'operator=' while copying an array,
9113   // If we ended up picking a trivial assignment operator for an array of a
9665       // If the base has no non-trivial move assignment operators,
9670       // If there's nothing virtual here, skip it.
9674       // If we're not actually going to call a move assignment for this base,
9687         // assignment operator is not trivial. If this can happen for
9688         // multiple distinct direct bases of Class, diagnose it. (If it
10003   //   If the class definition does not explicitly declare a copy
10130       // If this is a deleted function, add it anyway. This might be conformant
10145       // If this is a deleted function, add it anyway. This might be conformant
10160       // If this is a deleted function, add it anyway. This might be conformant
10280   // If we are defining a specialization of a conversion to function-ptr
10374   // If we're not under ARC, make sure we still get the _Block_copy/autorelease
10530   // If too few arguments are available, we'll fill in the rest with defaults.
10678 /// of this overloaded operator is well-formed. If so, returns false;
10795   //   prefix and postfix ++ operator. If this function is a member
10798   //   increment operator ++ for objects of that type. If the function
10819 /// of this literal operator function is well-formed. If so, returns
10910     // If there is no second parameter, the first must be a const char *
10998 /// the C++ linkage specification LinkageSpec. If RBraceLoc is
11129         // If the constructor used was non-trivial, set this as the
11272       // If we evaluated the type to a record type, suggest putting
11314   //   If the type specifier in a friend declaration designates a (possibly
11369   // If it's explicit specializations all the way down, just forget
11541   //   If a declaration acquires a function type through a
11555   //  - If a friend declaration in a non-local class first declares a
11562   //  - If a friend function is called, its name may be found by the
11596     //   If a friend declaration appears in a local class and the name
11637     //   If the name in a friend declaration is neither qualified nor
11647     // Skip class contexts.  If someone can cite chapter and verse
11778   // If we performed typo correction, we might have added a scope specifier
11812     // C++11 [dcl.fct.default]p4: If a friend declaration specifies a
11849     // If the declaration wasn't the first, we delete the function anyway for
11897     // If this definition appears within the record, do the checking when
11905     // If the method was defaulted on its first declaration, we will have
11976   // If the calling conventions match, everything is fine
12025   //   If the return type of D::f differs from the return type of B::f, the
12120   // If there is no declaration, there was an error parsing it.
12128   // If we are parsing the initializer for a static data member, push a
12138   // If there is no declaration, there was an error parsing it.
12210     // If we already had an entry, check to see if we are promoting this vtable
12211     // to required a definition. If so, we need to reappend to the VTableUses
12249     // If this class has a key function, but that key function is
12263       // If we have a class with no key function that is the subject
12454     // If we haven't diagnosed this cycle yet, do so now.
12535   // If the return type came after the cv-qualifier-seq, check it now.
12677     // If an error occurred, there's no expression here.