Lines Matching defs:IT
59 // If the function has a deduced return type, and we can't deduce it,
60 // then we can't use it either.
170 // FIXME: An explanation of why exactly it can't be inherited
198 /// in many cases it will not behave correctly. This is not enabled in C++ mode
206 // contexts where the warning is a false positive, or where it is technically
229 // This last can give us false negatives, but it's better than warning on
263 /// it might warn if a deprecated or unavailable declaration is being
305 // If the function has a deduced return type, and we can't deduce it,
306 // then we can't use it either.
333 /// if so, it checks that the requirements of the sentinel are
404 // 'nil' for ObjC methods, where it's much more likely that the
436 // Handle any placeholder expressions which made it here.
471 // optimizer will delete, so warn about it. People sometimes try to use this
544 // Handle any placeholder expressions which made it here.
568 // DR106 tells us what the result should be but not why. It's
661 // Half FP have to be promoted to float unless it is natively supported
678 // value is converted to an int; otherwise, it is converted to an
991 // floating-point type, the less precise type is converted, within it's
1005 // If only one operand is complex, promote it if necessary and convert the
1434 /// location of the token and the offset of the ud-suffix within it.
1442 /// the corresponding cooked (non-raw) literal operator, and build a call to it.
1472 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1623 /// If this produces template arguments, it is permitted to call
1672 // original lookup would not have found something because it was a
1835 // correction, but don't make it a fix-it since we're not going
1845 // Don't try to recover; it won't work.
1849 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
1901 // An id-expression is type-dependent if it contains:
1934 // which it was found. This is really unfortunate as we already did the
1935 // lookup to determine that it was a template name in the first place. If
1937 // results until we get here but it's likely not worth it.
2017 // lookup fails and no expression will be built to reference it.
2040 // expression is ill-formed if it actually works out to be a
2048 // There are other safeguards against such uses, but it's important
2074 // In C++1y, if this is a variable template id, then check it
2155 // this name, if the lookup sucedes, we replace it our current decl.
2279 /// when we found the member; it's the qualifier type if a
2280 /// qualifier was provided, and otherwise it's the base type.
2284 /// a using declaration, this is that class; otherwise it's
2371 // type of the object type, in which case we just ignore it.
2497 /// were not overloaded, and it doesn't promise that the declaration
2612 // These shouldn't make it here.
2675 // captured in an unevaluated context, it seems that the answer is no.
2761 PredefinedExpr::IdentType IT;
2765 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
2766 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
2767 case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break;
2768 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
2792 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
2795 if (IT == PredefinedExpr::LFunction)
2801 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
2906 // returns a StringRef to the memory buffer, it should have a null char at
2907 // the EOF, so it is also safe.
3062 // If this value fits into a ULL, try to figure out what else it fits into
3075 // Does it fit in a unsigned int?
3077 // Does it fit in a signed int?
3090 // Does it fit in a unsigned long?
3092 // Does it fit in a signed long?
3105 // Does it fit in a unsigned long long?
3107 // Does it fit in a signed long long?
3119 // If it doesn't fit in unsigned long long, and we're using Microsoft
3202 // runtime doesn't allow it.
3214 /// pointer type is equal to T) and emit a warning if it is.
3236 /// the expression as it completes the type for that expression through template
3257 // Completing the expression's type may have changed it.
3300 it is the operand of the sizeof operator ...
3361 // If it's a field, require the containing struct to have a
3367 // field, it must be an id-expression or a member-expression, but
3376 // context that lacks a 'this' value, it's ill-formed --- except,
3391 // definition if we can find a member of it.
3398 // Otherwise, if it's a field, and the field doesn't have
3399 // reference type, then it must have a complete type (or be a
3704 // DefaultFunctionArrayLvalueConversion, it must be an array that
3850 // We already type-checked the argument, so we know it works.
4206 /// array parameter, check that it is non-null, and that if it is formed by
4252 /// Given a function expression of unknown-any type, try to rebuild it
4563 // We know the result type of the call, set it.
4734 // CheckInitializer() - it requires knowledge of the object being intialized.
5038 // then handle it as such.
5042 // If the Expr being casted is a ParenListExpr, handle it specially.
5086 // If a single value is specified in the initializer then it will be
5090 // vector. If a single value is specified in the initializer then it will
5111 // it will be replicated to all components of the vector.
5611 // It could return the composite type.
5734 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
5755 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
5873 // routine is it effectively iqnores the qualifiers on the top level pointee.
5907 // It's okay to add or remove GC or lifetime qualifiers when converting to
5972 // If we are a multi-level pointer, it's possible that our issue is simply
5997 /// are compatible. It is more restrict than comparing two function pointer
6392 // It's compatible if the expression matches any of the fields.
6393 for (RecordDecl::field_iterator it = UD->field_begin(),
6395 it != itend; ++it) {
6396 if (it->getType()->isPointerType()) {
6402 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast);
6403 InitField = *it;
6409 RHS = ImpCastExprToType(RHS.take(), it->getType(),
6411 InitField = *it;
6417 if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
6419 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind);
6420 InitField = *it;
6486 // This check seems unnatural, however it is necessary to ensure the proper
6488 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
6747 // We only show the second type if it differs from the first.
6810 /// like \see checkArithmeticOpPointerOperand. However, it has special logic
7115 // bugs -- if the result is cast back to an unsigned type, it will have the
7407 // LK_String should always be after the other literals, since it has its own
7527 // what is it always going to eval to?
7971 // If the RHS can be constant folded, and if it constant folds to something
8119 // Use the normal diagnostic if it's pseudo-__strong but the
8283 // It is safe to assign a weak reference into a strong variable.
8313 // it is the unqualified version of the type of the left operand.
8378 // Increment of bool sets it to true, but is deprecated.
8500 /// designator or an lvalue designating an object. If it is an lvalue, the
8577 // If it's an instance method, make a member pointer.
8633 // in C++ it is not error to take address of a register
8672 // allow it in cases which are otherwise valid.
8703 // is an incomplete type or void. It would be possible to warn about
8704 // dereferencing a void pointer, but it's completely well-defined, and such a
8796 /// This warning is only emitted for builtin assignment operations. It is also
9087 /// \brief It accepts a '&' expr that is inside a '|' one.
9102 /// \brief It accepts a '&&' expr that is inside a '||' one.
9136 // If it's "a && b || 0" don't warn since the precedence doesn't matter.
9139 // If it's "1 && a || b" don't warn since the precedence doesn't matter.
9144 // If it's "a || b && 1 || c" we didn't warn earlier for
9158 // If it's "0 || a && b" don't warn since the precedence doesn't matter.
9161 // If it's "a || b && 1" don't warn since the precedence doesn't matter.
9308 // that an overload set can be dependently-typed, but it never
9491 // In C++, it's bool. C++ 5.3.1p8
9505 // In C, a volatile scalar is read by __imag. In C++, it is not.
9635 /// ns_returns_retained function) and, if so, rebuild it to hoist the
9685 // example, it is not possible to goto into a stmt expression apparently.
9711 // the consume out and bind it later. In the alternate case
10033 // literal signature. Furthermore, it is always a FunctionProtoType
10122 // If this has an identifier, add it to the scope stack.
10243 // If the block isn't obviously global, i.e. it captures anything at
10250 // It also gets a branch-protected scope if any of the captured
10283 // va_list is an array, but it's supposed to decay to
10303 // it is modified by va_arg.
10514 // it can give a more specific diagnostic.
10709 // Try to evaluate the expression, and produce diagnostics explaining why it's
10774 // FIXME: This is a bit ugly; is it really the best way to handle this
10927 /// \brief Mark a function referenced, and check whether it is odr-used
10936 // odr-used if it is the unique lookup result or the selected member of a
11027 // used: CodeGen will need it.
11065 // expression evaluator needing to call back into Sema if it sees a
11099 // that once a decl is used, all decls after it are also used.
11120 // right now; it
11123 // For C++, things get a bit more nasty... it would be nice to suppress this
11339 // Check whether we've already captured it.
11475 // The capture logic needs the destructor, so make sure we mark it.
11478 // an exception because it's technically only the call site that
11557 // An entity is captured by reference if it is implicitly or
11558 // explicitly captured but not captured by copy. It is
11563 // FIXME: It is not clear whether we want to build an lvalue reference
11566 // clarify, but for now we follow GCC because it's a more permissive and
11668 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
11681 // deciding whether it is an odr-use, just assume we will apply the
11780 // Per C++11 [basic.def.odr], a variable is odr-used "unless it satisfies
11782 // it is an object, the lvalue-to-rvalue conversion (4.1)
11798 /// \brief Mark a variable referenced, and check whether it is odr-used
11836 // if it's a qualified reference.
11850 // expression, is odr-used, unless it is a pure virtual function and its
11863 /// \brief Perform marking for a reference to an arbitrary declaration. It
12017 /// expressions (C++ typeid), queue the diagnostic to potentially emit it
12237 /// expression which it shares the type and value kind of.
12294 /// Given a function expression of unknown-any type, try to rebuild it
12332 /// expression which it shares the type and value kind of.
12363 // Build the sub-expression as if it were an object of the pointee type.
12430 // it has no idea what a function's signature is.
12438 // However, it turns out that in practice it is generally safe to
12445 // This is a hack, but it is far superior to moving the
12540 // The sub-expression has to be a lvalue reference, so rebuild it as such.
