Lines Matching defs:IT
62 // If the function has a deduced return type, and we can't deduce it,
63 // then we can't use it either.
111 // to the underlying type to see if it is more restrictive.
227 // FIXME: An explanation of why exactly it can't be inherited
253 /// in many cases it will not behave correctly. This is not enabled in C++ mode
261 // contexts where the warning is a false positive, or where it is technically
284 // This last can give us false negatives, but it's better than warning on
317 /// it might warn if a deprecated or unavailable declaration is being
365 // If the function has a deduced return type, and we can't deduce it,
366 // then we can't use it either.
394 /// if so, it checks that the requirements of the sentinel are
465 // 'nil' for ObjC methods, where it's much more likely that the
498 // Handle any placeholder expressions which made it here.
546 // optimizer will delete, so warn about it. People sometimes try to use this
619 // Handle any placeholder expressions which made it here.
643 // DR106 tells us what the result should be but not why. It's
759 // Half FP have to be promoted to float unless it is natively supported
776 // value is converted to an int; otherwise, it is converted to an
1036 // floating-point type, the less precise type is converted, within it's
1127 // Half FP has to be promoted to float unless it is natively supported
1498 /// location of the token and the offset of the ud-suffix within it.
1506 /// the corresponding cooked (non-raw) literal operator, and build a call to it.
1537 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1730 /// If this produces template arguments, it is permitted to call
1814 // original lookup would not have found something because it was a
1952 // correction, but don't make it a fix-it since we're not going
1957 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
2001 /// instantiation model, but it's close enough.
2066 // An id-expression is type-dependent if it contains:
2099 // which it was found. This is really unfortunate as we already did the
2100 // lookup to determine that it was a template name in the first place. If
2102 // results until we get here but it's likely not worth it.
2186 // Clean up the state associated with the TypoExpr, since it has
2208 // lookup fails and no expression will be built to reference it.
2230 // expression is ill-formed if it actually works out to be a
2238 // There are other safeguards against such uses, but it's important
2264 // In C++1y, if this is a variable template id, then check it
2379 // this name, if the lookup sucedes, we replace it our current decl.
2500 /// when we found the member; it's the qualifier type if a
2501 /// qualifier was provided, and otherwise it's the base type.
2505 /// a using declaration, this is that class; otherwise it's
2592 // type of the object type, in which case we just ignore it.
2716 /// were not overloaded, and it doesn't promise that the declaration
2832 // These shouldn't make it here.
2895 // captured in an unevaluated context, it seems that the answer is no.
2992 PredefinedExpr::IdentType IT) {
3016 auto Str = PredefinedExpr::ComputeName(IT, currentDecl);
3020 if (IT == PredefinedExpr::LFunction) {
3038 return new (Context) PredefinedExpr(Loc, ResTy, IT, SL);
3042 PredefinedExpr::IdentType IT;
3046 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
3047 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
3048 case tok::kw___FUNCDNAME__: IT = PredefinedExpr::FuncDName; break; // [MS]
3049 case tok::kw___FUNCSIG__: IT = PredefinedExpr::FuncSig; break; // [MS]
3050 case tok::kw_L__FUNCTION__: IT = PredefinedExpr::LFunction; break;
3051 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
3054 return BuildPredefinedExpr(Loc, IT);
3187 // returns a StringRef to the memory buffer, it should have a null char at
3188 // the EOF, so it is also safe.
3342 // If this value fits into a ULL, try to figure out what else it fits into
3368 // Does it fit in a unsigned int?
3370 // Does it fit in a signed int?
3383 // Does it fit in a unsigned long?
3385 // Does it fit in a signed long?
3414 // Does it fit in a unsigned long long?
3416 // Does it fit in a signed long long?
3507 // runtime doesn't allow it.
3519 /// pointer type is equal to T) and emit a warning if it is.
3541 /// the expression as it completes the type for that expression through template
3559 // be complete (and will attempt to complete it if it's an array of unknown
3573 // Completing the expression's type may have changed it.
3628 /// Except when it is the operand of the sizeof operator ...
3703 // If it's a field, require the containing struct to have a
3722 // definition if we can find a member of it.
3729 // Otherwise, if it's a field, and the field doesn't have
3730 // reference type, then it must have a complete type (or be a
4196 // DefaultFunctionArrayLvalueConversion, it must be an array that
4342 // We already type-checked the argument, so we know it works.
4664 /// array parameter, check that it is non-null, and that if it is formed by
4710 /// Given a function expression of unknown-any type, try to rebuild it
4776 /// space, than it should be able to accept a pointer to any address
4782 /// it does not contain any pointer arguments without
5135 // We know the result type of the call, set it.
5305 // CheckInitializer() - it requires knowledge of the object being intialized.
5681 // then handle it as such.
5685 // If the Expr being casted is a ParenListExpr, handle it specially.
5737 // If a single value is specified in the initializer then it will be
5741 // vector. If a single value is specified in the initializer then it will
5762 // it will be replicated to all components of the vector.
6067 /// UsualArithmeticConversions() for this purpose, since it always
6139 // Since VectorTy is created internally, it does not pretty print
6423 // It could return the composite type.
6548 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
6565 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
6624 // C cannot handle TypoExpr nodes in the condition because it
6695 // routine is it effectively iqnores the qualifiers on the top level pointee.
6730 // It's okay to add or remove GC or lifetime qualifiers when converting to
6795 // If we are a multi-level pointer, it's possible that our issue is simply
6820 /// are compatible. It is more restrict than comparing two function pointer
7218 // It's compatible if the expression matches any of the fields.
7219 for (auto *it : UD->fields()) {
7220 if (it->getType()->isPointerType()) {
7226 RHS = ImpCastExprToType(RHS.get(), it->getType(), CK_BitCast);
7227 InitField = it;
7233 RHS = ImpCastExprToType(RHS.get(), it->getType(),
7235 InitField = it;
7241 if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
7243 RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind);
7244 InitField = it;
7329 // This check seems unnatural, however it is necessary to ensure the proper
7331 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
7401 // The conversion to apply to the scalar before splatting it,
7684 // We only show the second type if it differs from the first.
7754 /// like \see checkArithmeticOpPointerOperand. However, it has special logic
8133 // then, the behavior is undefined. Warn about it.
8154 // bugs -- if the result is cast back to an unsigned type, it will have the
8522 // LK_String should always be after the other literals, since it has its own
8653 // what is it always going to eval to?
9130 // If the RHS can be constant folded, and if it constant folds to something
9411 // Use the normal diagnostic if it's pseudo-__strong but the
9585 // It is safe to assign a weak reference into a strong variable.
9613 // it is the unqualified version of the type of the left operand.
9679 // Increment of bool sets it to true, but is deprecated.
9815 /// designator or an lvalue designating an object. If it is an lvalue, the
9904 // If it's an instance method, make a member pointer.
9968 // in C++ it is not error to take address of a register
10015 // allow it in cases which are otherwise valid.
10082 // is an incomplete type or void. It would be possible to warn about
10083 // dereferencing a void pointer, but it's completely well-defined, and such a
10165 /// This warning is only emitted for builtin assignment operations. It is also
10286 // C cannot handle TypoExpr nodes on either side of a binop because it
10500 /// \brief It accepts a '&&' expr that is inside a '||' one.
10536 // If it's "a && b || 0" don't warn since the precedence doesn't matter.
10539 // If it's "1 && a || b" don't warn since the precedence doesn't matter.
10544 // If it's "a || b && 1 || c" we didn't warn earlier for
10558 // If it's "0 || a && b" don't warn since the precedence doesn't matter.
10561 // If it's "a || b && 1" don't warn since the precedence doesn't matter.
10718 // that an overload set can be dependently-typed, but it never
10913 // In C++, it's bool. C++ 5.3.1p8
10927 // In C, a volatile scalar is read by __imag. In C++, it is not.
11056 /// ns_returns_retained function) and, if so, rebuild it to hoist the
11101 // example, it is not possible to goto into a stmt expression apparently.
11127 // the consume out and bind it later. In the alternate case
11449 // literal signature. Furthermore, it is always a FunctionProtoType
11534 // If this has an identifier, add it to the scope stack.
11652 // If the block isn't obviously global, i.e. it captures anything at
11659 // It also gets a branch-protected scope if any of the captured
11687 // It might be a __builtin_ms_va_list. (But don't ever mark a va_arg()
11705 // va_list is an array, but it's supposed to decay to
11724 // it is modified by va_arg.
12176 // Try to evaluate the expression, and produce diagnostics explaining why it's
12241 // FIXME: This is a bit ugly; is it really the best way to handle this
12402 /// \brief Mark a function referenced, and check whether it is odr-used
12412 // odr-used if it is the unique lookup result or the selected member of a
12503 // used: CodeGen will need it.
12543 // expression evaluator needing to call back into Sema if it sees a
12576 // that once a decl is used, all decls after it are also used.
12597 // right now; it's impossible to write a non-constant expression outside of
12600 // For C++, things get a bit more nasty... it would be nice to suppress this
12635 // Check whether we've already captured it.
12780 it.
12783 // an exception because it's technically only the call site that
12924 // An entity is captured by reference if it is implicitly or
12925 // explicitly captured but not captured by copy. It is
12930 // FIXME: It is not clear whether we want to build an lvalue reference
12933 // clarify, but for now we follow GCC because it's a more permissive and
13028 // capture it.
13031 // Capture global variables if it is required to use private copy of this
13059 // private-captured a global variable, we need to recursively capture it in
13073 // Check whether we've already captured it.
13160 // Otherwise, evaluate and record it.
13257 // it makes for cleaner diagnostics later. This would purely be done
13259 // can not be captured by a lambda implicitly even though it is captured
13362 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
13370 // to a variable that is a constant expression, and if so, identify it as
13393 // deciding whether it is an odr-use, just assume we will apply the
13448 // If a variable could potentially be odr-used, defer marking it so
13452 // Add it to the list of potential captures that will be analyzed
13488 // Don't bother trying to instantiate it again, unless we might need
13520 // Per C++11 [basic.def.odr], a variable is odr-used "unless it satisfies
13522 // it is an object, the lvalue-to-rvalue conversion (4.1)
13530 // odr-used, so simply ignore it.
13538 /// \brief Mark a variable referenced, and check whether it is odr-used
13581 // if it's a qualified reference.
13595 // expression, is odr-used, unless it is a pure virtual function and its
13608 /// \brief Perform marking for a reference to an arbitrary declaration. It
13762 /// expressions (C++ typeid), queue the diagnostic to potentially emit it
13982 /// expression which it shares the type and value kind of.
14039 /// Given a function expression of unknown-any type, try to rebuild it
14077 /// expression which it shares the type and value kind of.
14108 // Build the sub-expression as if it were an object of the pointee type.
14175 // it has no idea what a function's signature is.
14183 // However, it turns out that in practice it is generally safe to
14190 // This is a hack, but it is far superior to moving the
14285 // The sub-expression has to be a lvalue reference, so rebuild it as such.
14478 // C cannot handle TypoExpr nodes on either side of a binop because it
14512 // Try to give a nicer diagnostic if it is a bound member that we recognize.
14541 // Accept __noop without parens by implicitly converting it to a call expr.
