================ @@ -14270,6 +14318,113 @@ StmtResult Sema::ActOnCXXForRangeIdentifier(Scope *S, SourceLocation IdentLoc, : IdentLoc); } +static ImplicitConversionKind GetConversionKind(QualType FromType, + QualType ToType) { + if (ToType->isIntegerType()) { + if (FromType->isComplexType()) + return ICK_Complex_Real; + if (FromType->isFloatingType()) + return ICK_Floating_Integral; + if (FromType->isIntegerType()) + return ICK_Integral_Conversion; + } + + if (ToType->isFloatingType()) { + if (FromType->isComplexType()) + return ICK_Complex_Real; + if (FromType->isFloatingType()) + return ICK_Floating_Conversion; + if (FromType->isIntegerType()) + return ICK_Floating_Integral; + } + + return ICK_Identity; +} + +static bool CheckC23ConstexprInitConversion(Sema &S, const Expr *Init) { + assert(S.getLangOpts().C23); + const Expr *InitNoCast = Init->IgnoreParenImpCasts(); + StandardConversionSequence SCS; + SCS.setAsIdentityConversion(); + auto FromType = InitNoCast->getType(); + auto ToType = Init->getType(); + SCS.setToType(0, FromType); + SCS.setToType(1, ToType); + SCS.Second = GetConversionKind(FromType, ToType); + + APValue Value; + QualType PreNarrowingType; + // Reuse C++ narrowing check. + switch (SCS.getNarrowingKind(S.Context, Init, Value, PreNarrowingType, + /*IgnoreFloatToIntegralConversion*/ false)) { + // The value doesn't fit. + case NK_Constant_Narrowing: + S.Diag(Init->getBeginLoc(), diag::err_c23_constexpr_init_not_representable) + << Value.getAsString(S.Context, PreNarrowingType) << ToType; + return true; + + // Conversion to a narrower type. + case NK_Type_Narrowing: + S.Diag(Init->getBeginLoc(), diag::err_c23_constexpr_init_type_mismatch) + << ToType << FromType; + return true; + + // Since we only reuse narrowing check for C23 constexpr variables here, we're + // not really interested in these cases. + case NK_Dependent_Narrowing: + case NK_Variable_Narrowing: + case NK_Not_Narrowing: + return false; + } + llvm_unreachable("unhandled case in switch"); +} + +static bool CheckC23ConstexprInitStringLiteral(const StringLiteral *SE, + Sema &SemaRef, + SourceLocation Loc) { + assert(SemaRef.getLangOpts().C23); + // String literals have the target type attached but underneath may contain + // values that don't really fit into the target type. Check that every + // character fits. + const ConstantArrayType *CAT = + SemaRef.Context.getAsConstantArrayType(SE->getType()); + QualType CharType = CAT->getElementType(); + uint32_t BitWidth = SemaRef.Context.getTypeSize(CharType); + bool isUnsigned = CharType->isUnsignedIntegerType(); + llvm::APSInt Value(BitWidth, isUnsigned); + for (unsigned I = 0, N = SE->getLength(); I != N; ++I) { + int64_t C = SE->getCodeUnitS(I, SemaRef.Context.getCharWidth()); + Value = C; + if (Value != C) { + SemaRef.Diag(Loc, diag::err_c23_constexpr_init_not_representable) ---------------- Fznamznon wrote:
Yeah why not. Looks better this way https://github.com/llvm/llvm-project/pull/73099 _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits