Lines Matching defs:Result
83 AvailabilityResult Result = D->getAvailability(&Message);
85 if (Result == AR_Available) {
88 Result = TheEnumDecl->getAvailability(&Message);
91 switch (Result) {
117 return Result;
393 ExprResult result = CheckPlaceholderExpr(E);
394 if (result.isInvalid()) return ExprError();
395 E = result.take();
445 ExprResult result = CheckPlaceholderExpr(E);
446 if (result.isInvalid()) return ExprError();
447 E = result.take();
467 // DR106 tells us what the result should be but not why. It's
590 // of type T from the glvalue and the result of the conversion
796 QualType result = (order == 0 ? ComplexTy :
801 OtherExpr = S.ImpCastExprToType(OtherExpr.take(), result,
806 ComplexExpr = S.ImpCastExprToType(ComplexExpr.take(), result,
809 return result;
818 // if we have an integer operand, the result is the complex type.
828 // type of the longer, and that is the type of the result. This corresponds
875 QualType result = S.Context.getComplexType(FloatTy);
879 IntExpr = S.ImpCastExprToType(IntExpr.take(), result,
884 FloatExpr = S.ImpCastExprToType(FloatExpr.take(), result,
887 return result;
899 // to the bigger result.
1010 QualType result =
1012 RHS = S.ImpCastExprToType(RHS.take(), result, CK_IntegralCast);
1014 LHS = S.ImpCastExprToType(LHS.take(), result, CK_IntegralCast);
1015 return result;
1190 // If we determined that the generic selection is result-dependent, don't
1191 // try to compute the result expression.
1243 // then the result expression of the generic selection is the expression
1244 // in that generic association. Otherwise, the result expression of the
1295 /// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string
1744 // If the result might be in a dependent base class, this is a dependent
2263 // If this is a single, fully-resolved result and we don't need ADL,
2270 // result, because in the overloaded case the results can only be
2437 // result type, make the entire expression __unknown_anytype.
2467 // result type, make the entire expression __unknown_anytype.
2600 APFloat::opStatus result = Literal.GetFloatValue(Val);
2604 if ((result & APFloat::opOverflow) ||
2605 ((result & APFloat::opUnderflow) && Val.isZero())) {
2608 if (result & APFloat::opOverflow) {
2621 bool isExact = (result == APFloat::opOK);
2736 llvm_unreachable("unexpected literal operator lookup result");
2947 // the result is the size of the referenced type."
2949 // result shall be the alignment of the referenced type."
3016 // the result is the size of the referenced type."
3018 // result shall be the alignment of the referenced type."
3157 ExprResult Result = CreateUnaryExprOrTypeTraitExpr(ArgEx, OpLoc, ExprKind);
3158 return Result;
3208 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Input);
3209 if (Result.isInvalid()) return ExprError();
3210 Input = Result.take();
3235 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Base);
3236 if (Result.isInvalid()) return ExprError();
3237 Base = Result.take();
3269 ExprResult Result = DefaultFunctionArrayLvalueConversion(LHSExp);
3270 if (Result.isInvalid())
3272 LHSExp = Result.take();
3274 ExprResult Result = DefaultFunctionArrayLvalueConversion(RHSExp);
3275 if (Result.isInvalid())
3277 RHSExp = Result.take();
3285 // in the subscript position. As a result, we need to derive the array base
3438 ExprResult Result;
3446 Result = SubstExpr(UninstExpr, ArgList);
3448 if (Result.isInvalid())
3457 Expr *ResultE = Result.takeAs<Expr>();
3460 Result = InitSeq.Perform(*this, Entity, Kind, ResultE);
3461 if (Result.isInvalid())
3464 Expr *Arg = Result.takeAs<Expr>();
3794 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, Fn);
3795 if (Result.isInvalid()) return ExprError();
3796 Fn = Result.take();
3843 ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
3844 if (result.isInvalid()) return ExprError();
3845 Fn = result.take();
3874 ExprResult result = rebuildUnknownAnyFunction(*this, Fn);
3875 if (result.isInvalid()) return ExprError();
3876 Fn = result.take();
3952 ExprResult Result;
3955 Result = ImpCastExprToType(Fn, Context.getPointerType(FDecl->getType()),
3958 Result = UsualUnaryConversions(Fn);
3960 if (Result.isInvalid())
3962 Fn = Result.take();
4036 // We know the result type of the call, set it.
4166 ExprResult Result = InitSeq.Perform(*this, Entity, Kind, LiteralExpr,
4168 if (Result.isInvalid())
4170 LiteralExpr = Result.get();
4193 ExprResult result = CheckPlaceholderExpr(InitArgList[I]);
4197 if (result.isInvalid()) continue;
4199 InitArgList[I] = result.take();
4516 ExprResult Result = MaybeConvertParenListExprToParenExpr(S, CastExpr);
4517 if (Result.isInvalid()) return ExprError();
4518 CastExpr = Result.take();
4607 ExprResult Result(E->getExpr(0));
4609 for (unsigned i = 1, e = E->getNumExprs(); i != e && !Result.isInvalid(); ++i)
4610 Result = ActOnBinOp(S, E->getExprLoc(), tok::comma, Result.get(),
4613 if (Result.isInvalid()) return ExprError();
4615 return ActOnParenExpr(E->getLParenLoc(), E->getRParenLoc(), Result.get());
4764 // differently qualified versions of compatible types, the result type is
4951 // If both operands are the same structure or union type, the result is that
4956 // "If both the operands have structure or union type, the result has
4962 // C99 6.5.15p5: "If both operands have void type, the result has void type."
4968 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has
5021 // Handle things like Class and struct objc_class*. Here we case the result
5076 // type so the result is acceptable for sending messages to.
5311 QualType result = CheckConditionalOperands(Cond, LHS, RHS,
5313 if (result.isNull() || Cond.isInvalid() || LHS.isInvalid() ||
5323 RHS.take(), result, VK, OK));
5327 RHS.take(), QuestionLoc, ColonLoc, result, VK,
5550 /// As a result, the code for dealing with pointers is more complex than the
5553 /// Sets 'Kind' for any result kind except Incompatible.
5575 Sema::AssignConvertType result =
5577 if (result != Compatible)
5578 return result;
5630 // no bits are changed but the result type is different.
5728 Sema::AssignConvertType result =
5731 result == Compatible &&
5733 result = IncompatibleObjCWeakRef;
5734 return result;
5920 Sema::AssignConvertType result = Compatible;
5924 result = IncompatibleObjCWeakRef;
5926 return result;
5959 Sema::AssignConvertType result =
5968 if (result != Incompatible && RHS.get()->getType() != LHSType)
5971 return result;
6021 // bitcast; no bits are changed but the result type is different.
6083 // Avoid analyzing cases where the result will either be invalid (and
6456 // The result type of a pointer-int computation is the pointer type.
6536 // representable in the result type, so never warn for those.
6546 llvm::APSInt Result = Left.extend(ResultBits.getLimitedValue());
6547 Result = Result.shl(Right);
6552 Result.toString(HexResult, 16, /*Signed =*/false, /*Literal =*/true);
6554 // If we are only missing a sign bit, this is less likely to result in actual
6555 // bugs -- if the result is cast back to an unsigned type, it will have the
6566 << HexResult.str() << Result.getMinSignedBits() << LHSType
6614 // "The type of the result is that of the promoted left operand."
6913 // result.
7008 // The result of comparisons is 'bool' in C++, 'int' in C.
7282 /// operates on extended vector types. Instead of producing an IntTy result,
7383 llvm::APSInt Result;
7384 if (RHS.get()->EvaluateAsInt(Result, Context))
7386 (Result != 0 && Result != 1)) {
7443 // The result is a bool.
7877 // If the result of an implicit cast is an l-value, we care about
7878 // the sub-expression; otherwise, the result here doesn't matter.
7906 /// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue.
7947 // Per C99 6.5.3.2, the address of a deref always returns a valid result
7952 // expressions here, but the result of one is always an lvalue anyway.
8061 // If the operand has type "type", the result has type "pointer to type".
8078 QualType Result;
8091 Result = PT->getPointeeType();
8094 Result = OPT->getPointeeType();
8102 if (Result.isNull()) {
8112 if (!S.getLangOpts().CPlusPlus && Result.isCForbiddenLValueType())
8115 return Result;
8238 QualType ResultTy; // Result type of the binary operator.
8241 QualType CompResultTy; // Type of computation result
8840 ExprResult Result = CheckPlaceholderExpr(Input);
8841 if (Result.isInvalid()) return ExprError();
8842 Input = Result.take();
8880 /// the result is a producing expression (like a call to an
8958 // (when dealing with a retainable type), the result
8960 // result will be +1, and we'll need to balance that out with
9286 TypeLoc Result = ExplicitSignature.getResultLoc();
9287 unsigned Size = Result.getFullDataSize();
9288 Sig = Context.CreateTypeSourceInfo(Result.getType(), Size);
9289 Sig->getTypeLoc().initializeFullCopy(Result, Size);
9488 BlockExpr *Result = new (Context) BlockExpr(BSI->TheDecl, BlockTy);
9490 PopFunctionScopeInfo(&WP, Result->getBlockDecl(), Result);
9494 if (Result->getBlockDecl()->hasCaptures()) {
9496 ExprCleanupObjects.push_back(Result->getBlockDecl());
9502 ci = Result->getBlockDecl()->capture_begin(),
9503 ce = Result->getBlockDecl()->capture_end(); ci != ce; ++ci) {
9512 return Owned(Result);
9536 ExprResult Result = UsualUnaryConversions(E);
9537 if (Result.isInvalid())
9539 E = Result.take();
9656 // Decode the result (notice that AST's are still created for extensions).
9811 llvm::APSInt *Result) {
9819 return VerifyIntegerConstantExpression(E, Result, Diagnoser);
9823 llvm::APSInt *Result,
9838 return VerifyIntegerConstantExpression(E, Result, Diagnoser, AllowFold);
9847 Sema::VerifyIntegerConstantExpression(Expr *E, llvm::APSInt *Result,
9980 if (Result)
9981 *Result = E->EvaluateKnownConstInt(Context);
9998 if (Result)
9999 *Result = EvalResult.Val.getInt();
10026 if (Result)
10027 *Result = EvalResult.Val.getInt();
10481 ExprResult Result(true);
10483 Result = Init.Perform(S, Entities.back(), InitKind, Ref);
10495 return Result;
10672 ExprResult Result
10681 if (!Result.isInvalid() &&
10682 !cast<CXXConstructExpr>(Result.get())->getConstructor()
10684 Result = MaybeCreateExprWithCleanups(Result);
10685 CopyExpr = Result.take();
10754 ExprResult Result = captureInLambda(*this, LSI, Var, CaptureType,
10757 if (!Result.isInvalid())
10758 CopyExpr = Result.take();
11114 /// Failure to do so will likely result in spurious diagnostics or failures
11275 ExprResult result = CheckPlaceholderExpr(E);
11276 if (result.isInvalid()) return ExprError();
11277 E = result.take();
11388 ExprResult Result = RebuildUnknownAnyFunction(S).Visit(FunctionExpr);
11389 if (Result.isInvalid()) return ExprError();
11390 return S.DefaultFunctionArrayConversion(Result.take());
11501 // Verify that this is a legal result type of a function.
11512 // Otherwise, go ahead and set DestType as the call's result.
11517 // Rebuild the function type, replacing the result type with DestType.
11552 // Verify that this is a legal result type of a call.
11559 // Rewrite the method result type if available.
11583 ExprResult Result = Visit(E->getSubExpr());
11584 if (!Result.isUsable()) return ExprError();
11586 E->setSubExpr(Result.take());
11599 ExprResult Result = Visit(E->getSubExpr());
11600 if (!Result.isUsable()) return ExprError();
11602 E->setSubExpr(Result.take());
11619 ExprResult Result = resolveDecl(E, VD);
11620 if (Result.isInvalid()) return ExprError();
11621 return S.ImpCastExprToType(Result.take(), Type,
11670 ExprResult result = RebuildUnknownAnyExpr(*this, CastType).Visit(CastExpr);
11671 if (!result.isUsable()) return ExprError();
11673 CastExpr = result.take();
11739 ExprResult result = Owned(E);
11740 if (ResolveAndFixSingleFunctionTemplateSpecialization(result, false)) {
11741 return result;
11745 tryToRecoverWithCall(result, PDiag(diag::err_ovl_unresolvable),
11747 return result;
11753 ExprResult result = Owned(E);
11754 tryToRecoverWithCall(result, PDiag(diag::err_bound_member_function),
11756 return result;
11804 LookupResult Result(*this, &Context.Idents.get("BOOL"), SourceLocation(),
11806 if (LookupName(Result, getCurScope())) {
11807 NamedDecl *ND = Result.getFoundDecl();
