Lines Matching refs:IT
138 /// it might warn if a deprecated or unavailable declaration is being
207 /// if so, it checks that the requirements of the sentinel are
278 // 'nil' for ObjC methods, where it's much more likely that the
310 // Handle any placeholder expressions which made it here.
345 // optimizer will delete, so warn about it. People sometimes try to use this
362 // Handle any placeholder expressions which made it here.
386 // DR106 tells us what the result should be but not why. It's
450 // Half FP is a bit different: it's a storage-only type, meaning that any
451 // "use" of it should be promoted to float.
468 // value is converted to an int; otherwise, it is converted to an
733 // floating-point type, the less precise type is converted, within it's
747 // If only one operand is complex, promote it if necessary and convert the
1153 /// location of the token and the offset of the ud-suffix within it.
1161 /// the corresponding cooked (non-raw) literal operator, and build a call to it.
1191 /// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from
1320 /// If this produces template arguments, it is permitted to call
1371 // original lookup would not have found something because it was a
1426 // FIXME: we should be able to handle this case too. It is correct
1523 // correction, but don't make it a fix-it since we're not going
1533 // Don't try to recover; it won't work.
1537 // FIXME: We found a keyword. Suggest it, but don't provide a fix-it
1589 // An id-expression is type-dependent if it contains:
1622 // which it was found. This is really unfortunate as we already did the
1623 // lookup to determine that it was a template name in the first place. If
1625 // results until we get here but it's likely not worth it.
1698 // lookup fails and no expression will be built to reference it.
1721 // expression is ill-formed if it actually works out to be a
1729 // There are other safeguards against such uses, but it's important
1806 // this name, if the lookup sucedes, we replace it our current decl.
1909 /// when we found the member; it's the qualifier type if a
1910 /// qualifier was provided, and otherwise it's the base type.
1914 /// a using declaration, this is that class; otherwise it's
2002 // type of the object type, in which case we just ignore it.
2128 /// were not overloaded, and it doesn't promise that the declaration
2244 // These shouldn't make it here.
2305 // captured in an unevaluated context, it seems that the answer is no.
2378 PredefinedExpr::IdentType IT;
2382 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2]
2383 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break;
2384 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break;
2402 unsigned Length = PredefinedExpr::ComputeName(IT, currentDecl).length();
2408 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT));
2659 // If this value fits into a ULL, try to figure out what else it fits into
2672 // Does it fit in a unsigned int?
2674 // Does it fit in a signed int?
2687 // Does it fit in a unsigned long?
2689 // Does it fit in a signed long?
2702 // Does it fit in a unsigned long long?
2704 // Does it fit in a signed long long?
2802 /// the expression as it completes the type for that expression through template
2830 // Completeing the expression's type may have changed it.
2864 /// Except when it is the operand of the sizeof operator ...
2922 // Alignment of a field access is always okay, so long as it isn't a
3175 // DefaultFunctionArrayLvalueConversion, it must be an array that
3326 // We already type-checked the argument, so we know it works.
3543 /// array parameter, check that it is non-null, and that if it is formed by
3589 /// Given a function expression of unknown-any type, try to rebuild it
3838 // We know the result type of the call, set it.
4012 // CheckInitializer() - it requires knowledge of the object being intialized.
4321 // then handle it as such.
4325 // If the Expr being casted is a ParenListExpr, handle it specially.
4364 // If a single value is specified in the initializer then it will be
4368 // vector. If a single value is specified in the initializer then it will
4389 // it will be replicated to all components of the vector.
4892 // It could return the composite type.
5015 // BinaryOperator::getOverloadedOpcode(), e.g. it's not a subscript op.
5035 /// ExprLooksBoolean - Returns true if E looks boolean, i.e. it has boolean type
5146 // routine is it effectively iqnores the qualifiers on the top level pointee.
5180 // It's okay to add or remove GC or lifetime qualifiers when converting to
5245 // If we are a multi-level pointer, it's possible that our issue is simply
5270 /// are compatible. It is more restrict than comparing two function pointer
5669 // It's compatible if the expression matches any of the fields.
5670 for (RecordDecl::field_iterator it = UD->field_begin(),
5672 it != itend; ++it) {
5673 if (it->getType()->isPointerType()) {
5679 RHS = ImpCastExprToType(RHS.take(), it->getType(), CK_BitCast);
5680 InitField = *it;
5686 RHS = ImpCastExprToType(RHS.take(), it->getType(),
5688 InitField = *it;
5694 if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
5696 RHS = ImpCastExprToType(RHS.take(), it->getType(), Kind);
5697 InitField = *it;
5762 // This check seems unnatural, however it is necessary to ensure the proper
5764 // DeclExpr's (created by ActOnIdExpression), it would mess up the unary
6015 // We only show the second type if it differs from the first.
6083 /// like \see checkArithmeticOpPointerOperand. However, it has special logic
6396 // bugs -- if the result is cast back to an unsigned type, it will have the
6610 // what is it always going to eval to?
7061 // If the RHS can be constant folded, and if it constant folds to something
7224 // Use the normal diagnostic if it's pseudo-__strong but the
7375 // it is the unqualified version of the type of the left operand.
7440 // Increment of bool sets it to true, but is deprecated.
7560 /// designator or an lvalue designating an object. If it is an lvalue, the
7625 // If it's an instance method, make a member pointer.
7674 // in C++ it is not error to take address of a register
7713 // allow it in cases which are otherwise valid.
7744 // is an incomplete type or void. It would be possible to warn about
7745 // dereferencing a void pointer, but it's completely well-defined, and such a
7837 /// This warning is only emitted for builtin assignment operations. It is also
8073 /// \brief It accepts a '&' expr that is inside a '|' one.
8087 /// \brief It accepts a '&&' expr that is inside a '||' one.
8120 // If it's "a && b || 0" don't warn since the precedence doesn't matter.
8123 // If it's "1 && a || b" don't warn since the precedence doesn't matter.
8128 // If it's "a || b && 1 || c" we didn't warn earlier for
8142 // If it's "0 || a && b" don't warn since the precedence doesn't matter.
8145 // If it's "a || b && 1" don't warn since the precedence doesn't matter.
8239 // that an overload set can be dependently-typed, but it never
8394 // In C++, it's bool. C++ 5.3.1p8
8408 // In C, a volatile scalar is read by __imag. In C++, it is not.
8538 /// ns_returns_retained function) and, if so, rebuild it to hoist the
8588 // example, it is not possible to goto into a stmt expression apparently.
8614 // the consume out and bind it later. In the alternate case
8904 // literal signature. Furthermore, it is always a FunctionProtoType
9005 // If this has an identifier, add it to the scope stack.
9120 // If the block isn't obviously global, i.e. it captures anything at
9127 // It also gets a branch-protected scope if any of the captured
9160 // va_list is an array, but it's supposed to decay to
9170 // it is modified by va_arg.
9366 // it can give a more specific diagnostic.
9468 // produce any diagnostics if it isn't.
9497 // Try to evaluate the expression, and produce diagnostics explaining why it's
9566 // FIXME: This is a bit ugly; is it really the best way to handle this
9710 /// \brief Mark a function referenced, and check whether it is odr-used
9717 // Don't mark this function as used multiple times, unless it's a constexpr
9778 // used: CodeGen will need it.
9815 // expression evaluator needing to call back into Sema if it sees a
9857 // right now; it's impossible to write a non-constant expression outside of
9860 // For C++, things get a bit more nasty... it would be nice to suppress this
10050 // Check whether we've already captured it.
10170 // The capture logic needs the destructor, so make sure we mark it.
10173 // an exception because it's technically only the call site that
10224 // An entity is captured by reference if it is implicitly or
10225 // explicitly captured but not captured by copy. It is
10230 // FIXME: It is not clear whether we want to build an lvalue reference
10233 // clarify, but for now we follow GCC because it's a more permissive and
10334 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
10347 // deciding whether it is an odr-use, just assume we will apply the
10410 // Per C++11 [basic.def.odr], a variable is odr-used "unless it is
10427 /// \brief Mark a variable referenced, and check whether it is odr-used
10454 /// \brief Perform marking for a reference to an arbitrary declaration. It
10603 /// expressions (C++ typeid), queue the diagnostic to potentially emit it
10808 /// expression which it shares the type and value kind of.
10865 /// Given a function expression of unknown-any type, try to rebuild it
10903 /// expression which it shares the type and value kind of.
10934 // Build the sub-expression as if it were an object of the pointee type.
11076 // The sub-expression has to be a lvalue reference, so rebuild it as such.
