[Sema][NFC] Create Sema::BuildImplicitCast

[fcloutier]

Summary

This change creates Sema::BuildImplicitCast, which the rest of Sema now uses to create implicit casts. The main change in terms of interface is that now, technically, creating an implicit cast could fail. However, the current implementation of BuildImplicitCast never does because it simply calls ImplicitCastExpr::Create.

Nevertheless, Sema users of ImplicitCastExpr::Create, and their downstream users in several cases, were updated to allow failing, except in some cases (such as in OpenMP) where existing code already didn't bother to check implicit casts failing.

rdar://74050758

[shafik]

clang/lib/Sema/SemaCast.cpp

1060

Can we ever have this case w/ the added if (SrcExpr.isInvalid()) above

clang/include/clang/Sema/Sema.h

 //===--- Sema.h - Semantic Analysis & AST Building --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
bool ResolveAndFixSingleFunctionTemplateSpecialization(
                       ExprResult &SrcExpr,
                       bool DoFunctionPointerConverion = false,
                       bool Complain = false,
                       SourceRange OpRangeForComplaining = SourceRange(),
                       QualType DestTypeForComplaining = QualType(),
                       unsigned DiagIDForComplaining = 0);
 
 
-  Expr *FixOverloadedFunctionReference(Expr *E,
-                                       DeclAccessPair FoundDecl,
-                                       FunctionDecl *Fn);
   ExprResult FixOverloadedFunctionReference(ExprResult,
                                             DeclAccessPair FoundDecl,
                                             FunctionDecl *Fn);
 
   void AddOverloadedCallCandidates(UnresolvedLookupExpr *ULE,
                                    ArrayRef<Expr *> Args,
                                    OverloadCandidateSet &CandidateSet,
                                    bool PartialOverloading = false);
ExprResult ActOnCastExpr(Scope *S, SourceLocation LParenLoc,
                            Declarator &D, ParsedType &Ty,
                            SourceLocation RParenLoc, Expr *CastExpr);
   ExprResult BuildCStyleCastExpr(SourceLocation LParenLoc,
                                  TypeSourceInfo *Ty,
                                  SourceLocation RParenLoc,
                                  Expr *Op);
   CastKind PrepareScalarCast(ExprResult &src, QualType destType);
 
+  /// Build an implicit cast expression, giving Sema a chance to make
+  /// modifications where appropriate.
+  ExprResult BuildImplicitCastExpr(Expr *Src, QualType DstTy, CastKind CK,
+                                   ExprValueKind VK, FPOptionsOverride FPOO,
+                                   const CXXCastPath *CastPath = nullptr);
+
   /// Build an altivec or OpenCL literal.
   ExprResult BuildVectorLiteral(SourceLocation LParenLoc,
                                 SourceLocation RParenLoc, Expr *E,
                                 TypeSourceInfo *TInfo);
 
   ExprResult MaybeConvertParenListExprToParenExpr(Scope *S, Expr *ME);
 
   ExprResult ActOnCompoundLiteral(SourceLocation LParenLoc,

clang/lib/Sema/Sema.cpp

 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
#endif
   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
       ImpCast->setType(Ty);
       ImpCast->setValueKind(VK);
       return E;
     }
   }
 
-  return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK,
-                                  CurFPFeatureOverrides());
+  return BuildImplicitCastExpr(E, Ty, Kind, VK, CurFPFeatureOverrides(),
+                               BasePath);
 }
 
 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
 /// to the conversion from scalar type ScalarTy to the Boolean type.
 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
   switch (ScalarTy->getScalarTypeKind()) {
   case Type::STK_Bool: return CK_NoOp;
   case Type::STK_CPointer: return CK_PointerToBoolean;

clang/lib/Sema/SemaCast.cpp

 //===--- SemaCast.cpp - Semantic Analysis for Casts -----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
struct CastOperation {
     }
 
     /// Complete an apparently-successful cast operation that yields
     /// the given expression.
     ExprResult complete(CastExpr *castExpr) {
       // If this is an unbridged cast, wrap the result in an implicit
       // cast that yields the unbridged-cast placeholder type.
       if (IsARCUnbridgedCast) {
-        castExpr = ImplicitCastExpr::Create(
-            Self.Context, Self.Context.ARCUnbridgedCastTy, CK_Dependent,
-            castExpr, nullptr, castExpr->getValueKind(),
-            Self.CurFPFeatureOverrides());
+        ExprResult ImpCast = Self.BuildImplicitCastExpr(
+            castExpr, Self.Context.ARCUnbridgedCastTy, CK_Dependent,
+            castExpr->getValueKind(), Self.CurFPFeatureOverrides());
+        if (ImpCast.isInvalid())
+          return ExprError();
+        castExpr = cast<CastExpr>(ImpCast.get());
       }
       updatePartOfExplicitCastFlags(castExpr);
       return castExpr;
     }
 
     // Internal convenience methods.
 
     /// Try to handle the given placeholder expression kind.  Return
else
     checkNonOverloadPlaceholders();
   if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
     return;
 
   unsigned msg = diag::err_bad_cxx_cast_generic;
   TryCastResult tcr =
     TryReinterpretCast(Self, SrcExpr, DestType,
                        /*CStyle*/false, OpRange, msg, Kind);
+  if (SrcExpr.isInvalid())
+    return;
   if (tcr != TC_Success && msg != 0) {
     if (SrcExpr.isInvalid()) // if conversion failed, don't report another error
       return;
     if (SrcExpr.get()->getType() == Self.Context.OverloadTy) {
       //FIXME: &f<int>; is overloaded and resolvable
       Self.Diag(OpRange.getBegin(), diag::err_bad_reinterpret_cast_overload)
         << OverloadExpr::find(SrcExpr.get()).Expression->getName()
         << DestType << OpRange;
       Self.NoteAllOverloadCandidates(SrcExpr.get());
 
if (!CStyle &&
         !DestType->getPointeeType().getQualifiers().isAddressSpaceSupersetOf(
             SrcType->getPointeeType().getQualifiers())) {
       SuccessResult = TC_Failed;
     }
   } else if (IsLValueCast) {
     Kind = CK_LValueBitCast;
   } else if (DestType->isObjCObjectPointerType()) {
     Kind = Self.PrepareCastToObjCObjectPointer(SrcExpr);
+    if (SrcExpr.isInvalid())
+      return TC_Failed;
   } else if (DestType->isBlockPointerType()) {
     if (!SrcType->isBlockPointerType()) {
       Kind = CK_AnyPointerToBlockPointerCast;
     } else {
       Kind = CK_BitCast;
     }
   } else {
     Kind = CK_BitCast;

clang/lib/Sema/SemaDecl.cpp

 //===--- SemaDecl.cpp - Semantic Analysis for Declarations ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (auto *D : Elements) {
 
     // Adjust the APSInt value.
     InitVal = InitVal.extOrTrunc(NewWidth);
     InitVal.setIsSigned(NewSign);
     ECD->setInitVal(InitVal);
 
     // Adjust the Expr initializer and type.
     if (ECD->getInitExpr() &&
-        !Context.hasSameType(NewTy, ECD->getInitExpr()->getType()))
-      ECD->setInitExpr(ImplicitCastExpr::Create(
-          Context, NewTy, CK_IntegralCast, ECD->getInitExpr(),
-          /*base paths*/ nullptr, VK_RValue, FPOptionsOverride()));
+        !Context.hasSameType(NewTy, ECD->getInitExpr()->getType())) {
+      ExprResult ImpCast = BuildImplicitCastExpr(
+          ECD->getInitExpr(), NewTy, CK_IntegralCast, VK_RValue,
+          FPOptionsOverride(), /*base paths*/ nullptr);
+      if (!ImpCast.isInvalid())
+        ECD->setInitExpr(ImpCast.get());
+    }
     if (getLangOpts().CPlusPlus)
       // C++ [dcl.enum]p4: Following the closing brace of an
       // enum-specifier, each enumerator has the type of its
       // enumeration.
       ECD->setType(EnumType);
     else
       ECD->setType(NewTy);
   }

clang/lib/Sema/SemaDeclAttr.cpp

 //===--- SemaDeclAttr.cpp - Declaration Attribute Handling ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (unsigned Idx = 0; Idx < Attr->args_size(); Idx++) {
     if (E->isValueDependent() || E->isTypeDependent())
       continue;
 
     if (E->getType()->isArrayType())
       E = ImpCastExprToType(E, Context.getPointerType(E->getType()),
                             clang::CK_ArrayToPointerDecay)
               .get();
     if (E->getType()->isFunctionType())
-      E = ImplicitCastExpr::Create(Context,
-                                   Context.getPointerType(E->getType()),
-                                   clang::CK_FunctionToPointerDecay, E, nullptr,
-                                   VK_RValue, FPOptionsOverride());
+      E = BuildImplicitCastExpr(E, Context.getPointerType(E->getType()),
+                                CK_FunctionToPointerDecay, VK_RValue,
+                                FPOptionsOverride(), nullptr)
+              .get();
     if (E->isLValue())
-      E = ImplicitCastExpr::Create(Context, E->getType().getNonReferenceType(),
-                                   clang::CK_LValueToRValue, E, nullptr,
-                                   VK_RValue, FPOptionsOverride());
+      E = BuildImplicitCastExpr(E, E->getType().getNonReferenceType(),
+                                CK_LValueToRValue, VK_RValue,
+                                FPOptionsOverride(), nullptr)
+              .get();
 
     Expr::EvalResult Eval;
     Notes.clear();
     Eval.Diag = &Notes;
 
     bool Result =
         E->EvaluateAsConstantExpr(Eval, Context);
 

clang/lib/Sema/SemaDeclCXX.cpp

 //===------ SemaDeclCXX.cpp - Semantic Analysis for C++ Declarations ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (auto *B : Bindings) {
     SourceLocation Loc = B->getLocation();
 
     ExprResult E = S.BuildDeclRefExpr(Src, DecompType, VK_LValue, Loc);
     if (E.isInvalid())
       return true;
 
     //   e is an lvalue if the type of the entity is an lvalue reference and
     //   an xvalue otherwise
-    if (!Src->getType()->isLValueReferenceType())
-      E = ImplicitCastExpr::Create(S.Context, E.get()->getType(), CK_NoOp,
-                                   E.get(), nullptr, VK_XValue,
-                                   FPOptionsOverride());
+    if (!Src->getType()->isLValueReferenceType()) {
+      E = S.BuildImplicitCastExpr(E.get(), E.get()->getType(), CK_NoOp,
+                                  VK_XValue, FPOptionsOverride());
+      if (E.isInvalid())
+        return true;
+    }
 
     TemplateArgumentListInfo Args(Loc, Loc);
     Args.addArgument(
         getTrivialIntegralTemplateArgument(S, Loc, S.Context.getSizeType(), I));
 
     if (UseMemberGet) {
       //   if [lookup of member get] finds at least one declaration, the
       //   initializer is e.get<i-1>().
ExprResult BuildBlock = BuildBlockForLambdaConversion(CurrentLocation,
                                                         Conv->getLocation(),
                                                         Conv, DerefThis);
 
   // If we're not under ARC, make sure we still get the _Block_copy/autorelease
   // behavior.  Note that only the general conversion function does this
   // (since it's unusable otherwise); in the case where we inline the
   // block literal, it has block literal lifetime semantics.
   if (!BuildBlock.isInvalid() && !getLangOpts().ObjCAutoRefCount)
-    BuildBlock = ImplicitCastExpr::Create(
-        Context, BuildBlock.get()->getType(), CK_CopyAndAutoreleaseBlockObject,
-        BuildBlock.get(), nullptr, VK_RValue, FPOptionsOverride());
+    BuildBlock = BuildImplicitCastExpr(
+        BuildBlock.get(), BuildBlock.get()->getType(),
+        CK_CopyAndAutoreleaseBlockObject, VK_RValue, FPOptionsOverride());
 
   if (BuildBlock.isInvalid()) {
     Diag(CurrentLocation, diag::note_lambda_to_block_conv);
     Conv->setInvalidDecl();
     return;
   }
 
   // Create the return statement that returns the block from the conversion

clang/lib/Sema/SemaExpr.cpp

 //===--- SemaExpr.cpp - Semantic Analysis for Expressions -----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (E->getType().getObjCLifetime() == Qualifiers::OCL_Weak)
     Cleanup.setExprNeedsCleanups(true);
 
   if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
     Cleanup.setExprNeedsCleanups(true);
 
   // C++ [conv.lval]p3:
   //   If T is cv std::nullptr_t, the result is a null pointer constant.
   CastKind CK = T->isNullPtrType() ? CK_NullToPointer : CK_LValueToRValue;
-  Res = ImplicitCastExpr::Create(Context, T, CK, E, nullptr, VK_RValue,
-                                 CurFPFeatureOverrides());
+  Res = BuildImplicitCastExpr(E, T, CK, VK_RValue, CurFPFeatureOverrides());
+  if (Res.isInvalid())
+    return Res;
 
   // C11 6.3.2.1p2:
   //   ... if the lvalue has atomic type, the value has the non-atomic version
   //   of the type of the lvalue ...
   if (const AtomicType *Atomic = T->getAs<AtomicType>()) {
     T = Atomic->getValueType().getUnqualifiedType();
-    Res = ImplicitCastExpr::Create(Context, T, CK_AtomicToNonAtomic, Res.get(),
-                                   nullptr, VK_RValue, FPOptionsOverride());
+    Res = BuildImplicitCastExpr(Res.get(), T, CK_AtomicToNonAtomic, VK_RValue,
+                                CurFPFeatureOverrides());
+    if (Res.isInvalid())
+      return Res;
   }
 
   return Res;
 }
 
 ExprResult Sema::DefaultFunctionArrayLvalueConversion(Expr *E, bool Diagnose) {
   ExprResult Res = DefaultFunctionArrayConversion(E, Diagnose);
   if (Res.isInvalid())
if (const BuiltinType *PlaceholderTy = E->getType()->getAsPlaceholderType()) {
     }
   }
 
   ExprResult ExprRes = DefaultArgumentPromotion(E);
   if (ExprRes.isInvalid())
     return ExprError();
 
   // Copy blocks to the heap.
-  if (ExprRes.get()->getType()->isBlockPointerType())
+  if (ExprRes.get()->getType()->isBlockPointerType()) {
     maybeExtendBlockObject(ExprRes);
+    if (ExprRes.isInvalid())
+      return ExprError();
+  }
 
   E = ExprRes.get();
 
   // Diagnostics regarding non-POD argument types are
   // emitted along with format string checking in Sema::CheckFunctionCall().
   if (isValidVarArgType(E->getType()) == VAK_Undefined) {
     // Turn this into a trap.
     CXXScopeSpec SS;

 /// Do an explicit extend of the given block pointer if we're in ARC.
 void Sema::maybeExtendBlockObject(ExprResult &E) {
   assert(E.get()->getType()->isBlockPointerType());
   assert(E.get()->isRValue());
 
   // Only do this in an r-value context.
   if (!getLangOpts().ObjCAutoRefCount) return;
 
-  E = ImplicitCastExpr::Create(
-      Context, E.get()->getType(), CK_ARCExtendBlockObject, E.get(),
-      /*base path*/ nullptr, VK_RValue, FPOptionsOverride());
+  E = BuildImplicitCastExpr(E.get(), E.get()->getType(),
+                            CK_ARCExtendBlockObject, VK_RValue,
+                            FPOptionsOverride());
   Cleanup.setExprNeedsCleanups(true);
 }
 
 /// Prepare a conversion of the given expression to an ObjC object
 /// pointer type.
 CastKind Sema::PrepareCastToObjCObjectPointer(ExprResult &E) {
   QualType type = E.get()->getType();
   if (type->isObjCObjectPointerType()) {
case Type::STK_FixedPoint:
       return CK_IntegralCast;
     }
     llvm_unreachable("Should have returned before this");
   }
 
   llvm_unreachable("Unhandled scalar cast");
 }
 
+ExprResult Sema::BuildImplicitCastExpr(Expr *Src, QualType DstTy, CastKind CK,
+                                       ExprValueKind VK, FPOptionsOverride FPOO,
+                                       const CXXCastPath *CastPath) {
+  return ImplicitCastExpr::Create(Context, DstTy, CK, Src, CastPath, VK, FPOO);
+}
+
 static bool breakDownVectorType(QualType type, uint64_t &len,
                                 QualType &eltType) {
   // Vectors are simple.
   if (const VectorType *vecType = type->getAs<VectorType>()) {
     len = vecType->getNumElements();
     eltType = vecType->getElementType();
     assert(eltType->isScalarType());
     return true;
if (VTy->getVectorKind() == VectorType::AltiVecVector) {
     // The number of initializers must be one or must match the size of the
     // vector. If a single value is specified in the initializer then it will
     // be replicated to all the components of the vector
     if (numExprs == 1) {
       QualType ElemTy = VTy->getElementType();
       ExprResult Literal = DefaultLvalueConversion(exprs[0]);
       if (Literal.isInvalid())
         return ExprError();
-      Literal = ImpCastExprToType(Literal.get(), ElemTy,
-                                  PrepareScalarCast(Literal, ElemTy));
+      CastKind CK = PrepareScalarCast(Literal, ElemTy);
+      if (Literal.isInvalid())
+        return ExprError();
+      Literal = ImpCastExprToType(Literal.get(), ElemTy, CK);
+      if (Literal.isInvalid())
+        return ExprError();
       return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
     }
     else if (numExprs < numElems) {
       Diag(E->getExprLoc(),
            diag::err_incorrect_number_of_vector_initializers);
       return ExprError();
     }
     else
       initExprs.append(exprs, exprs + numExprs);
   }
   else {
     // For OpenCL, when the number of initializers is a single value,
     // it will be replicated to all components of the vector.
     if (getLangOpts().OpenCL &&
         VTy->getVectorKind() == VectorType::GenericVector &&
         numExprs == 1) {
         QualType ElemTy = VTy->getElementType();
         ExprResult Literal = DefaultLvalueConversion(exprs[0]);
         if (Literal.isInvalid())
           return ExprError();
-        Literal = ImpCastExprToType(Literal.get(), ElemTy,
-                                    PrepareScalarCast(Literal, ElemTy));
+        CastKind CK = PrepareScalarCast(Literal, ElemTy);
+        if (Literal.isInvalid())
+          return ExprError();
+        Literal = ImpCastExprToType(Literal.get(), ElemTy, CK);
         return BuildCStyleCastExpr(LParenLoc, TInfo, RParenLoc, Literal.get());
     }
 
     initExprs.append(exprs, exprs + numExprs);
   }
   // FIXME: This means that pretty-printing the final AST will produce curly
   // braces instead of the original commas.
   InitListExpr *initE = new (Context) InitListExpr(Context, LiteralLParenLoc,
if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
     // different sizes, or between ExtInts and other types.
     if (ResTy.isNull() && (LHSTy->isExtIntType() || RHSTy->isExtIntType())) {
       Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
           << LHSTy << RHSTy << LHS.get()->getSourceRange()
           << RHS.get()->getSourceRange();
       return QualType();
     }
 
-    LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
-    RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
+    CastKind LHSCK = PrepareScalarCast(LHS, ResTy);
+    CastKind RHSCK = PrepareScalarCast(RHS, ResTy);
+    if (LHS.isInvalid() || RHS.isInvalid())
+      return QualType();
+    LHS = ImpCastExprToType(LHS.get(), ResTy, LHSCK);
+    RHS = ImpCastExprToType(RHS.get(), ResTy, RHSCK);
 
     return ResTy;
   }
 
   // And if they're both bfloat (which isn't arithmetic), that's fine too.
   if (LHSTy->isBFloat16Type() && RHSTy->isBFloat16Type()) {
     return LHSTy;
   }
if (getLangOpts().CPlusPlus && RHSType->getAs<ComplexType>() &&
       !LHSType->getAs<ComplexType>())
     return Incompatible;
 
   // Arithmetic conversions.
   if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
       !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
     if (ConvertRHS)
       Kind = PrepareScalarCast(RHS, LHSType);
-    return Compatible;
+    return RHS.isInvalid() ? Incompatible : Compatible;
   }
 
   // Conversions to normal pointers.
   if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
     // U* -> T*
     if (isa<PointerType>(RHSType)) {
       LangAS AddrSpaceL = LHSPointer->getPointeeType().getAddressSpace();
       LangAS AddrSpaceR = RHSType->getPointeeType().getAddressSpace();
for (auto *it : UD->fields()) {
     }
 
     CastKind Kind;
     if (CheckAssignmentConstraints(it->getType(), RHS, Kind)
           == Compatible) {
       RHS = ImpCastExprToType(RHS.get(), it->getType(), Kind);
       InitField = it;
       break;
+    } else if (RHS.isInvalid()) {
+      return Incompatible;
     }
   }
 
   if (!InitField)
     return Incompatible;
 
   ConstructTransparentUnion(*this, Context, RHS, ArgType, InitField);
   return Compatible;
if (getLangOpts().CPlusPlus) {
     // structures.
     // FIXME: We also fall through for atomics; not sure what should
     // happen there, though.
   } else if (RHS.get()->getType() == Context.OverloadTy) {
     // As a set of extensions to C, we support overloading on functions. These
     // functions need to be resolved here.
     DeclAccessPair DAP;
     if (FunctionDecl *FD = ResolveAddressOfOverloadedFunction(
-            RHS.get(), LHSType, /*Complain=*/false, DAP))
-      RHS = FixOverloadedFunctionReference(RHS.get(), DAP, FD);
-    else
+            RHS.get(), LHSType, /*Complain=*/false, DAP)) {
+      RHS = FixOverloadedFunctionReference(RHS, DAP, FD);
+      if (RHS.isInvalid())
+        return Incompatible;
+    } else
       return Incompatible;
   }
 
   // C99 6.5.16.1p1: the left operand is a pointer and the right is
   // a null pointer constant.
   if ((LHSType->isPointerType() || LHSType->isObjCObjectPointerType() ||
        LHSType->isBlockPointerType()) &&
       RHS.get()->isNullPointerConstant(Context,

clang/lib/Sema/SemaExprCXX.cpp

 //===--- SemaExprCXX.cpp - Semantic Analysis for Expressions --------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 ///
case CK_UserDefinedConversion: {
 
     // Create an implicit call expr that calls it.
     CXXConversionDecl *Conv = cast<CXXConversionDecl>(Method);
     ExprResult Result = S.BuildCXXMemberCallExpr(From, FoundDecl, Conv,
                                                  HadMultipleCandidates);
     if (Result.isInvalid())
       return ExprError();
     // Record usage of conversion in an implicit cast.
-    Result = ImplicitCastExpr::Create(S.Context, Result.get()->getType(),
-                                      CK_UserDefinedConversion, Result.get(),
-                                      nullptr, Result.get()->getValueKind(),
-                                      S.CurFPFeatureOverrides());
-
+    Result = S.BuildImplicitCastExpr(
+        Result.get(), Result.get()->getType(), CK_UserDefinedConversion,
+        Result.get()->getValueKind(), S.CurFPFeatureOverrides());
+    if (Result.isInvalid())
+      return ExprError();
     return S.MaybeBindToTemporary(Result.get());
   }
   }
 }
 
 /// PerformImplicitConversion - Perform an implicit conversion of the
 /// expression From to the type ToType using the pre-computed implicit
 /// conversion sequence ICS. Returns the converted
if (Context.hasSameType(FromType, Context.OverloadTy)) {
     FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(From, ToType,
                                                           true, Found);
     if (!Fn)
       return ExprError();
 
     if (DiagnoseUseOfDecl(Fn, From->getBeginLoc()))
       return ExprError();
 
-    From = FixOverloadedFunctionReference(From, Found, Fn);
+    ExprResult OverloadResult = FixOverloadedFunctionReference(From, Found, Fn);
+    if (OverloadResult.isInvalid())
+      return ExprError();
+    From = OverloadResult.get();
     FromType = From->getType();
   }
 
   // If we're converting to an atomic type, first convert to the corresponding
   // non-atomic type.
   QualType ToAtomicType;
   if (const AtomicType *ToAtomic = ToType->getAs<AtomicType>()) {
     ToAtomicType = ToType;
     ToType = ToAtomic->getValueType();
   }
 
   QualType InitialFromType = FromType;
   // Perform the first implicit conversion.
   switch (SCS.First) {
   case ICK_Identity:
     if (const AtomicType *FromAtomic = FromType->getAs<AtomicType>()) {
       FromType = FromAtomic->getValueType().getUnqualifiedType();
-      From = ImplicitCastExpr::Create(Context, FromType, CK_AtomicToNonAtomic,
-                                      From, /*BasePath=*/nullptr, VK_RValue,
-                                      FPOptionsOverride());
+      ExprResult FromRes = BuildImplicitCastExpr(
+          From, FromType, CK_AtomicToNonAtomic, VK_RValue, FPOptionsOverride());
+      assert(!FromRes.isInvalid() && "Can't perform identity conversion?!");
+      From = FromRes.get();
     }
     break;
 
   case ICK_Lvalue_To_Rvalue: {
     assert(From->getObjectKind() != OK_ObjCProperty);
     ExprResult FromRes = DefaultLvalueConversion(From);
     assert(!FromRes.isInvalid() && "Can't perform deduced conversion?!");
     From = FromRes.get();
case ICK_Pointer_Conversion: {
     if (CheckPointerConversion(From, NewToType, Kind, BasePath, CStyle))
       return ExprError();
 
     // Make sure we extend blocks if necessary.
     // FIXME: doing this here is really ugly.
     if (Kind == CK_BlockPointerToObjCPointerCast) {
       ExprResult E = From;
       (void) PrepareCastToObjCObjectPointer(E);
+      if (E.isInvalid())
+        return ExprError();
       From = E.get();
     }
     if (getLangOpts().allowsNonTrivialObjCLifetimeQualifiers())
       CheckObjCConversion(SourceRange(), NewToType, From, CCK);
     From = ImpCastExprToType(From, NewToType, Kind, VK_RValue, &BasePath, CCK)
              .get();
     break;
   }
if (LHS.isInvalid() || RHS.isInvalid())
       return QualType();
     if (ResTy.isNull()) {
       Diag(QuestionLoc,
            diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
       return QualType();
     }
 
-    LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
-    RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
+    CastKind LHSCK = PrepareScalarCast(LHS, ResTy);
+    CastKind RHSCK = PrepareScalarCast(RHS, ResTy);
+    if (LHS.isInvalid() || RHS.isInvalid())
+      return QualType();
+    LHS = ImpCastExprToType(LHS.get(), ResTy, LHSCK);
+    RHS = ImpCastExprToType(RHS.get(), ResTy, RHSCK);
 
     return ResTy;
   }
 
   //   -- The second and third operands have pointer type, or one has pointer
   //      type and the other is a null pointer constant, or both are null
   //      pointer constants, at least one of which is non-integral; pointer
   //      conversions and qualification conversions are performed to bring them
if (getLangOpts().ObjCAutoRefCount &&
     // Don't reclaim an object of Class type.
     if (!ReturnsRetained && E->getType()->isObjCARCImplicitlyUnretainedType())
       return E;
 
     Cleanup.setExprNeedsCleanups(true);
 
     CastKind ck = (ReturnsRetained ? CK_ARCConsumeObject
                                    : CK_ARCReclaimReturnedObject);
-    return ImplicitCastExpr::Create(Context, E->getType(), ck, E, nullptr,
-                                    VK_RValue, FPOptionsOverride());
+    return BuildImplicitCastExpr(E, E->getType(), ck, VK_RValue,
+                                 FPOptionsOverride());
   }
 
   if (E->getType().isDestructedType() == QualType::DK_nontrivial_c_struct)
     Cleanup.setExprNeedsCleanups(true);
 
   if (!getLangOpts().CPlusPlus)
     return E;
 

clang/lib/Sema/SemaExprObjC.cpp

 //===--- SemaExprObjC.cpp - Semantic Analysis for ObjC Expressions --------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
case ACC_invalid:
     break;
 
   // Do nothing for both bottom and +0.
   case ACC_bottom:
   case ACC_plusZero:
     return ACR_okay;
 
   // If the result is +1, consume it here.
-  case ACC_plusOne:
-    castExpr = ImplicitCastExpr::Create(Context, castExpr->getType(),
-                                        CK_ARCConsumeObject, castExpr, nullptr,
-                                        VK_RValue, FPOptionsOverride());
+  case ACC_plusOne: {
+    ExprResult ImpCast = BuildImplicitCastExpr(castExpr, castExpr->getType(),
+                                               CK_ARCConsumeObject, VK_RValue,
+                                               FPOptionsOverride())
+                             .get();
+    if (ImpCast.isInvalid())
+      return ACR_error;
+    castExpr = ImpCast.get();
     Cleanup.setExprNeedsCleanups(true);
     return ACR_okay;
   }
+  }
 
   // If this is a non-implicit cast from id or block type to a
   // CoreFoundation type, delay complaining in case the cast is used
   // in an acceptable context.
   if (exprACTC == ACTC_retainable && isAnyRetainable(castACTC) && isCast(CCK))
     return ACR_unbridged;
 
   // Issue a diagnostic about a missing @-sign when implicit casting a cstring
if (T->isDependentType() || SubExpr->isTypeDependent()) {
     CK = CK_BitCast;
     switch (Kind) {
     case OBC_Bridge:
       // Reclaiming a value that's going to be __bridge-casted to CF
       // is very dangerous, so we don't do it.
       SubExpr = maybeUndoReclaimObject(SubExpr);
       break;
 
-    case OBC_BridgeRetained:
+    case OBC_BridgeRetained: {
       // Produce the object before casting it.
-      SubExpr = ImplicitCastExpr::Create(Context, FromType, CK_ARCProduceObject,
-                                         SubExpr, nullptr, VK_RValue,
-                                         FPOptionsOverride());
+      ExprResult ImpCast =
+          BuildImplicitCastExpr(SubExpr, FromType, CK_ARCProduceObject,
+                                VK_RValue, FPOptionsOverride())
+              .get();
+      if (ImpCast.isInvalid())
+        return ExprError();
+      SubExpr = ImpCast.get();
       break;
+    }
 
     case OBC_BridgeTransfer: {
       bool br = isKnownName("CFBridgingRetain");
       Diag(BridgeKeywordLoc, diag::err_arc_bridge_cast_wrong_kind)
         << (FromType->isBlockPointerType()? 1 : 0)
         << FromType
         << 2
         << T
ExprResult Sema::BuildObjCBridgedCast(SourceLocation LParenLoc,
   } else {
     Diag(LParenLoc, diag::err_arc_bridge_cast_incompatible)
       << FromType << T << Kind
       << SubExpr->getSourceRange()
       << TSInfo->getTypeLoc().getSourceRange();
     return ExprError();
   }
 
-  Expr *Result = new (Context) ObjCBridgedCastExpr(LParenLoc, Kind, CK,
-                                                   BridgeKeywordLoc,
-                                                   TSInfo, SubExpr);
+  ExprResult Result = new (Context) ObjCBridgedCastExpr(
+      LParenLoc, Kind, CK, BridgeKeywordLoc, TSInfo, SubExpr);
 
   if (MustConsume) {
     Cleanup.setExprNeedsCleanups(true);
-    Result = ImplicitCastExpr::Create(Context, T, CK_ARCConsumeObject, Result,
-                                      nullptr, VK_RValue, FPOptionsOverride());
+    Result = BuildImplicitCastExpr(Result.get(), T, CK_ARCConsumeObject,
+                                   VK_RValue, FPOptionsOverride());
   }
 
   return Result;
 }
 
 ExprResult Sema::ActOnObjCBridgedCast(Scope *S,
                                       SourceLocation LParenLoc,
                                       ObjCBridgeCastKind Kind,

clang/lib/Sema/SemaInit.cpp

 //===--- SemaInit.cpp - Semantic Analysis for Initializers ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (IsStringLiteralInitUpdate && VerifyOnly) {
     QualType CharTy = AT->getElementType();
 
     // Compute the type of the integer literals.
     QualType PromotedCharTy = CharTy;
     if (CharTy->isPromotableIntegerType())
       PromotedCharTy = Context.getPromotedIntegerType(CharTy);
     unsigned PromotedCharTyWidth = Context.getTypeSize(PromotedCharTy);
 
+    uint64_t StrLen;
+    std::string TmpStr;
+    StringRef StrRef;
     if (StringLiteral *SL = dyn_cast<StringLiteral>(SubExpr)) {
       // Get the length of the string.
-      uint64_t StrLen = SL->getLength();
-      if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
-        StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
-      StructuredList->resizeInits(Context, StrLen);
-
-      // Build a literal for each character in the string, and put them into
-      // the init list.
-      for (unsigned i = 0, e = StrLen; i != e; ++i) {
-        llvm::APInt CodeUnit(PromotedCharTyWidth, SL->getCodeUnit(i));
-        Expr *Init = new (Context) IntegerLiteral(
-            Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
-        if (CharTy != PromotedCharTy)
-          Init =
-              ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast, Init,
-                                       nullptr, VK_RValue, FPOptionsOverride());
-        StructuredList->updateInit(Context, i, Init);
-      }
+      StrRef = SL->getString();
+      StrLen = SL->getLength();
     } else {
       ObjCEncodeExpr *E = cast<ObjCEncodeExpr>(SubExpr);
-      std::string Str;
-      Context.getObjCEncodingForType(E->getEncodedType(), Str);
+      Context.getObjCEncodingForType(E->getEncodedType(), TmpStr);
+      StrRef = TmpStr;
 
       // Get the length of the string.
-      uint64_t StrLen = Str.size();
-      if (cast<ConstantArrayType>(AT)->getSize().ult(StrLen))
-        StrLen = cast<ConstantArrayType>(AT)->getSize().getZExtValue();
-      StructuredList->resizeInits(Context, StrLen);
+      StrLen = TmpStr.size();
+    }
+
 
-      // Build a literal for each character in the string, and put them into
-      // the init list.
-      for (unsigned i = 0, e = StrLen; i != e; ++i) {
-        llvm::APInt CodeUnit(PromotedCharTyWidth, Str[i]);
-        Expr *Init = new (Context) IntegerLiteral(
-            Context, CodeUnit, PromotedCharTy, SubExpr->getExprLoc());
-        if (CharTy != PromotedCharTy)
-          Init =
-              ImplicitCastExpr::Create(Context, CharTy, CK_IntegralCast, Init,
-                                       nullptr, VK_RValue, FPOptionsOverride());
-        StructuredList->updateInit(Context, i, Init);
-      }
+      llvm::APInt CodeUnit(PromotedCharTyWidth, StrRef[i]);
+      ExprResult Init = new (Context) IntegerLiteral(
+            SemaRef.BuildImplicitCastExpr(Init.get(), CharTy, CK_IntegralCast,
+                                          VK_RValue, FPOptionsOverride());
+      if (Init.isInvalid())
+        hadError = true;
+      else
+        StructuredList->updateInit(Context, i, Init.get());
     }
   }
 
   // Make sure that our non-designated initializer list has space
   // for a subobject corresponding to this array element.
   if (StructuredList &&
       DesignatedEndIndex.getZExtValue() >= StructuredList->getNumInits())
     StructuredList->resizeInits(SemaRef.Context,
case SK_CastDerivedToBaseLValue: {
         return ExprError();
 
       ExprValueKind VK =
           Step->Kind == SK_CastDerivedToBaseLValue ?
               VK_LValue :
               (Step->Kind == SK_CastDerivedToBaseXValue ?
                    VK_XValue :
                    VK_RValue);
-      CurInit = ImplicitCastExpr::Create(S.Context, Step->Type,
-                                         CK_DerivedToBase, CurInit.get(),
-                                         &BasePath, VK, FPOptionsOverride());
+      CurInit =
+          S.BuildImplicitCastExpr(CurInit.get(), Step->Type, CK_DerivedToBase,
+                                  VK, FPOptionsOverride(), &BasePath);
       break;
     }
 
     case SK_BindReference:
       // Reference binding does not have any corresponding ASTs.
 
       // Check exception specifications
       if (S.CheckExceptionSpecCompatibility(CurInit.get(), DestType))
case SK_UserConversion: {
 
         CastKind = CK_UserDefinedConversion;
         CreatedObject = Conversion->getReturnType()->isRecordType();
       }
 
       if (CreatedObject && checkAbstractType(CurInit.get()->getType()))
         return ExprError();
 
-      CurInit = ImplicitCastExpr::Create(
-          S.Context, CurInit.get()->getType(), CastKind, CurInit.get(), nullptr,
-          CurInit.get()->getValueKind(), S.CurFPFeatureOverrides());
+      CurInit = S.BuildImplicitCastExpr(CurInit.get(), CurInit.get()->getType(),
+                                        CastKind, CurInit.get()->getValueKind(),
+                                        S.CurFPFeatureOverrides());
 
       if (shouldBindAsTemporary(Entity))
         // The overall entity is temporary, so this expression should be
         // destroyed at the end of its full-expression.
         CurInit = S.MaybeBindToTemporary(CurInit.getAs<Expr>());
       else if (CreatedObject && shouldDestroyEntity(Entity)) {
         // The object outlasts the full-expression, but we need to prepare for
         // a destructor being run on it.
for (step_iterator Step = step_begin(), StepEnd = step_end();
     case SK_PassByIndirectRestore:
       checkIndirectCopyRestoreSource(S, CurInit.get());
       CurInit = new (S.Context) ObjCIndirectCopyRestoreExpr(
           CurInit.get(), Step->Type,
           Step->Kind == SK_PassByIndirectCopyRestore);
       break;
 
     case SK_ProduceObjCObject:
-      CurInit = ImplicitCastExpr::Create(
-          S.Context, Step->Type, CK_ARCProduceObject, CurInit.get(), nullptr,
-          VK_RValue, FPOptionsOverride());
+      CurInit = S.BuildImplicitCastExpr(CurInit.get(), Step->Type,
+                                        CK_ARCProduceObject, VK_RValue,
+                                        FPOptionsOverride());
       break;
 
     case SK_StdInitializerList: {
       S.Diag(CurInit.get()->getExprLoc(),
              diag::warn_cxx98_compat_initializer_list_init)
         << CurInit.get()->getSourceRange();
 
       // Materialize the temporary into memory.
case SK_OCLSamplerInit: {
           S.Diag(Kind.getLocation(), diag::err_sampler_argument_required)
             << SourceType;
           break;
         } else if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Init)) {
           auto Var = cast<VarDecl>(DRE->getDecl());
           // Case 1b and 1c
           // No cast from integer to sampler is needed.
           if (!Var->hasGlobalStorage()) {
-            CurInit = ImplicitCastExpr::Create(
-                S.Context, Step->Type, CK_LValueToRValue, Init,
-                /*BasePath=*/nullptr, VK_RValue, FPOptionsOverride());
+            CurInit =
+                S.BuildImplicitCastExpr(Init, Step->Type, CK_LValueToRValue,
+                                        VK_RValue, FPOptionsOverride())
+                    .get();
             break;
           }
           // Case 1a
           // For function call with a file-scope sampler variable as argument,
           // get the integer literal.
           // Do not diagnose if the file-scope variable does not have initializer
           // since this has already been diagnosed when parsing the variable
           // declaration.

clang/lib/Sema/SemaLambda.cpp

 //===--- SemaLambda.cpp - Semantic Analysis for C++11 Lambdas -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
for (ArrayRef<ReturnStmt*>::iterator
 
     // Right now we only support integral fixup casts.
     assert(returnType->isIntegralOrUnscopedEnumerationType());
     assert(retValue->getType()->isIntegralOrUnscopedEnumerationType());
 
     ExprWithCleanups *cleanups = dyn_cast<ExprWithCleanups>(retValue);
 
     Expr *E = (cleanups ? cleanups->getSubExpr() : retValue);
-    E = ImplicitCastExpr::Create(S.Context, returnType, CK_IntegralCast, E,
-                                 /*base path*/ nullptr, VK_RValue,
-                                 FPOptionsOverride());
+    ExprResult IC = S.BuildImplicitCastExpr(E, returnType, CK_IntegralCast,
+                                            VK_RValue, FPOptionsOverride());
+    if (!IC.isInvalid()) {
       if (cleanups) {
         cleanups->setSubExpr(E);
       } else {
         ret->setRetValue(E);
       }
     }
   }
+}
 
 void Sema::deduceClosureReturnType(CapturingScopeInfo &CSI) {
   assert(CSI.HasImplicitReturnType);
   // If it was ever a placeholder, it had to been deduced to DependentTy.
   assert(CSI.ReturnType.isNull() || !CSI.ReturnType->isUndeducedType());
   assert((!isa<LambdaScopeInfo>(CSI) || !getLangOpts().CPlusPlus14) &&
          "lambda expressions use auto deduction in C++14 onwards");
 

clang/lib/Sema/SemaObjCProperty.cpp

 //===--- SemaObjCProperty.cpp - Semantic Analysis for ObjC @property ------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
       // returned by the getter as it must conform to C++'s copy-return rules.
       // FIXME. Eventually we want to do this for Objective-C as well.
       SynthesizedFunctionScope Scope(*this, getterMethod);
       ImplicitParamDecl *SelfDecl = getterMethod->getSelfDecl();
       DeclRefExpr *SelfExpr = new (Context)
           DeclRefExpr(Context, SelfDecl, false, SelfDecl->getType(), VK_LValue,
                       PropertyDiagLoc);
       MarkDeclRefReferenced(SelfExpr);
-      Expr *LoadSelfExpr = ImplicitCastExpr::Create(
-          Context, SelfDecl->getType(), CK_LValueToRValue, SelfExpr, nullptr,
-          VK_RValue, FPOptionsOverride());
-      Expr *IvarRefExpr =
-        new (Context) ObjCIvarRefExpr(Ivar,
-                                      Ivar->getUsageType(SelfDecl->getType()),
-                                      PropertyDiagLoc,
-                                      Ivar->getLocation(),
-                                      LoadSelfExpr, true, true);
+      ExprResult LoadSelfExpr = BuildImplicitCastExpr(
+          SelfExpr, SelfDecl->getType(), CK_LValueToRValue, VK_RValue,
+          FPOptionsOverride());
+      if (!LoadSelfExpr.isInvalid()) {
+        Expr *IvarRefExpr = new (Context) ObjCIvarRefExpr(
+            Ivar, Ivar->getUsageType(SelfDecl->getType()), PropertyDiagLoc,
+            Ivar->getLocation(), LoadSelfExpr.get(), true, true);
         ExprResult Res = PerformCopyInitialization(
             InitializedEntity::InitializeResult(PropertyDiagLoc,
                                                 getterMethod->getReturnType(),
                                                 /*NRVO=*/false),
             PropertyDiagLoc, IvarRefExpr);
         if (!Res.isInvalid()) {
           Expr *ResExpr = Res.getAs<Expr>();
           if (ResExpr)
             ResExpr = MaybeCreateExprWithCleanups(ResExpr);
           PIDecl->setGetterCXXConstructor(ResExpr);
         }
       }
+    }
     if (property->hasAttr<NSReturnsNotRetainedAttr>() &&
         !getterMethod->hasAttr<NSReturnsNotRetainedAttr>()) {
       Diag(getterMethod->getLocation(),
            diag::warn_property_getter_owning_mismatch);
       Diag(property->getLocation(), diag::note_property_declare);
     }
     if (getLangOpts().ObjCAutoRefCount && Synthesize)
       switch (getterMethod->getMethodFamily()) {
if (getLangOpts().CPlusPlus && Synthesize && !CompleteTypeErr &&
         Ivar->getType()->isRecordType()) {
       // FIXME. Eventually we want to do this for Objective-C as well.
       SynthesizedFunctionScope Scope(*this, setterMethod);
       ImplicitParamDecl *SelfDecl = setterMethod->getSelfDecl();
       DeclRefExpr *SelfExpr = new (Context)
           DeclRefExpr(Context, SelfDecl, false, SelfDecl->getType(), VK_LValue,
                       PropertyDiagLoc);
       MarkDeclRefReferenced(SelfExpr);
-      Expr *LoadSelfExpr = ImplicitCastExpr::Create(
-          Context, SelfDecl->getType(), CK_LValueToRValue, SelfExpr, nullptr,
-          VK_RValue, FPOptionsOverride());
-      Expr *lhs =
-        new (Context) ObjCIvarRefExpr(Ivar,
-                                      Ivar->getUsageType(SelfDecl->getType()),
-                                      PropertyDiagLoc,
-                                      Ivar->getLocation(),
-                                      LoadSelfExpr, true, true);
+      ExprResult LoadSelfExpr =
+          BuildImplicitCastExpr(SelfExpr, SelfDecl->getType(),
+                                CK_LValueToRValue, VK_RValue,
+                                FPOptionsOverride())
+              .get();
+      if (!LoadSelfExpr.isInvalid()) {
+        Expr *lhs = new (Context) ObjCIvarRefExpr(
+            Ivar, Ivar->getUsageType(SelfDecl->getType()), PropertyDiagLoc,
+            Ivar->getLocation(), LoadSelfExpr.get(), true, true);
         ObjCMethodDecl::param_iterator P = setterMethod->param_begin();
         ParmVarDecl *Param = (*P);
         QualType T = Param->getType().getNonReferenceType();
         DeclRefExpr *rhs = new (Context)
             DeclRefExpr(Context, Param, false, T, VK_LValue, PropertyDiagLoc);
         MarkDeclRefReferenced(rhs);
-      ExprResult Res = BuildBinOp(S, PropertyDiagLoc,
-                                  BO_Assign, lhs, rhs);
+        ExprResult Res = BuildBinOp(S, PropertyDiagLoc, BO_Assign, lhs, rhs);
         if (property->getPropertyAttributes() &
             ObjCPropertyAttribute::kind_atomic) {
           Expr *callExpr = Res.getAs<Expr>();
           if (const CXXOperatorCallExpr *CXXCE =
                   dyn_cast_or_null<CXXOperatorCallExpr>(callExpr))
             if (const FunctionDecl *FuncDecl = CXXCE->getDirectCallee())
               if (!FuncDecl->isTrivial())
                 if (property->getType()->isReferenceType()) {
                   Diag(PropertyDiagLoc,
                        diag::err_atomic_property_nontrivial_assign_op)
                       << property->getType();
                   Diag(FuncDecl->getBeginLoc(), diag::note_callee_decl)
                       << FuncDecl;
                 }
         }
         PIDecl->setSetterCXXAssignment(Res.getAs<Expr>());
       }
     }
+  }
 
   if (IC) {
     if (Synthesize)
       if (ObjCPropertyImplDecl *PPIDecl =
           IC->FindPropertyImplIvarDecl(PropertyIvar)) {
         Diag(PropertyLoc, diag::err_duplicate_ivar_use)
         << PropertyId << PPIDecl->getPropertyDecl()->getIdentifier()
         << PropertyIvar;

clang/lib/Sema/SemaOpenMP.cpp

 //===--- SemaOpenMP.cpp - Semantic Analysis for OpenMP constructs ---------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 /// \file
for (Expr *RefExpr : VarList) {
     if (DeclareReductionRef.isUsable()) {
       QualType RedTy = DeclareReductionRef.get()->getType();
       QualType PtrRedTy = Context.getPointerType(RedTy);
       ExprResult LHS = S.CreateBuiltinUnaryOp(ELoc, UO_AddrOf, LHSDRE);
       ExprResult RHS = S.CreateBuiltinUnaryOp(ELoc, UO_AddrOf, RHSDRE);
       if (!BasePath.empty()) {
         LHS = S.DefaultLvalueConversion(LHS.get());
         RHS = S.DefaultLvalueConversion(RHS.get());
-        LHS = ImplicitCastExpr::Create(
-            Context, PtrRedTy, CK_UncheckedDerivedToBase, LHS.get(), &BasePath,
-            LHS.get()->getValueKind(), FPOptionsOverride());
-        RHS = ImplicitCastExpr::Create(
-            Context, PtrRedTy, CK_UncheckedDerivedToBase, RHS.get(), &BasePath,
-            RHS.get()->getValueKind(), FPOptionsOverride());
+        LHS = S.BuildImplicitCastExpr(
+            LHS.get(), PtrRedTy, CK_UncheckedDerivedToBase,
+            LHS.get()->getValueKind(), FPOptionsOverride(), &BasePath);
+        RHS = S.BuildImplicitCastExpr(
+            RHS.get(), PtrRedTy, CK_UncheckedDerivedToBase,
+            RHS.get()->getValueKind(), FPOptionsOverride(), &BasePath);
       }
       FunctionProtoType::ExtProtoInfo EPI;
       QualType Params[] = {PtrRedTy, PtrRedTy};
       QualType FnTy = Context.getFunctionType(Context.VoidTy, Params, EPI);
       auto *OVE = new (Context) OpaqueValueExpr(
           ELoc, Context.getPointerType(FnTy), VK_RValue, OK_Ordinary,
           S.DefaultLvalueConversion(DeclareReductionRef.get()).get());
       Expr *Args[] = {LHS.get(), RHS.get()};

clang/lib/Sema/SemaOverload.cpp

 //===--- SemaOverload.cpp - C++ Overloading -------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (FunctionDecl *Fn
                "Non-address-of operator for overloaded function expression");
         FromType = S.Context.getPointerType(FromType);
       }
 
       // Check that we've computed the proper type after overload resolution.
       // FIXME: FixOverloadedFunctionReference has side-effects; we shouldn't
       // be calling it from within an NDEBUG block.
       assert(S.Context.hasSameType(
-        FromType,
-        S.FixOverloadedFunctionReference(From, AccessPair, Fn)->getType()));
+          FromType, S.FixOverloadedFunctionReference(From, AccessPair, Fn)
+                        .get()
+                        ->getType()));
     } else {
       return false;
     }
   }
   // Lvalue-to-rvalue conversion (C++11 4.1):
   //   A glvalue (3.10) of a non-function, non-array type T can
   //   be converted to a prvalue.
   bool argIsLValue = From->isGLValue();
if (SemaRef.isSFINAEContext())
       return true;
 
     SemaRef.CheckMemberOperatorAccess(From->getExprLoc(), From, nullptr, Found);
     ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
                                                        HadMultipleCandidates);
     if (Result.isInvalid())
       return true;
     // Record usage of conversion in an implicit cast.
-    From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
-                                    CK_UserDefinedConversion, Result.get(),
-                                    nullptr, Result.get()->getValueKind(),
-                                    SemaRef.CurFPFeatureOverrides());
+    Result = SemaRef.BuildImplicitCastExpr(
+        Result.get(), Result.get()->getType(), CK_UserDefinedConversion,
+        Result.get()->getValueKind(), SemaRef.CurFPFeatureOverrides());
+    if (Result.isInvalid())
+      return true;
+    From = Result.get();
   }
   return false;
 }
 
 static bool recordConversion(Sema &SemaRef, SourceLocation Loc, Expr *&From,
                              Sema::ContextualImplicitConverter &Converter,
                              QualType T, bool HadMultipleCandidates,
                              DeclAccessPair &Found) {
Converter.diagnoseConversion(SemaRef, Loc, T, ToType)
         << From->getSourceRange();
   }
 
   ExprResult Result = SemaRef.BuildCXXMemberCallExpr(From, Found, Conversion,
                                                      HadMultipleCandidates);
   if (Result.isInvalid())
     return true;
   // Record usage of conversion in an implicit cast.
-  From = ImplicitCastExpr::Create(SemaRef.Context, Result.get()->getType(),
-                                  CK_UserDefinedConversion, Result.get(),
-                                  nullptr, Result.get()->getValueKind(),
-                                  SemaRef.CurFPFeatureOverrides());
+  Result = SemaRef.BuildImplicitCastExpr(
+      Result.get(), Result.get()->getType(), CK_UserDefinedConversion,
+      Result.get()->getValueKind(), SemaRef.CurFPFeatureOverrides());
+  if (Result.isInvalid())
+    return true;
+  From = Result.get();
   return false;
 }
 
 static ExprResult finishContextualImplicitConversion(
     Sema &SemaRef, SourceLocation Loc, Expr *From,
     Sema::ContextualImplicitConverter &Converter) {
   if (!Converter.match(From->getType()) && !Converter.Suppress)
     Converter.diagnoseNoMatch(SemaRef, Loc, From->getType())
if (!Found || Found->isCPUDispatchMultiVersion() ||
       Found->isCPUSpecificMultiVersion())
     return false;
 
   // Emitting multiple diagnostics for a function that is both inaccessible and
   // unavailable is consistent with our behavior elsewhere. So, always check
   // for both.
   DiagnoseUseOfDecl(Found, E->getExprLoc());
   CheckAddressOfMemberAccess(E, DAP);
-  Expr *Fixed = FixOverloadedFunctionReference(E, DAP, Found);
-  if (DoFunctionPointerConverion && Fixed->getType()->isFunctionType())
-    SrcExpr = DefaultFunctionArrayConversion(Fixed, /*Diagnose=*/false);
+  ExprResult Fixed = FixOverloadedFunctionReference(E, DAP, Found);
+  if (Fixed.isInvalid())
+    return false;
+  if (DoFunctionPointerConverion && Fixed.get()->getType()->isFunctionType())
+    SrcExpr = DefaultFunctionArrayConversion(Fixed.get(), /*Diagnose=*/false);
   else
-    SrcExpr = Fixed;
+    SrcExpr = Fixed.get();
   return true;
 }
 
 /// Given an expression that refers to an overloaded function, try to
 /// resolve that overloaded function expression down to a single function.
 ///
 /// This routine can only resolve template-ids that refer to a single function
 /// template, where that template-id refers to a single template whose template
if (!ovl.HasFormOfMemberPointer &&
       // Ideally we would note which candidate was chosen and why
       // the static candidates were rejected.
       SrcExpr = ExprError();
       return true;
     }
 
     // Fix the expression to refer to 'fn'.
     SingleFunctionExpression =
-        FixOverloadedFunctionReference(SrcExpr.get(), found, fn);
+        FixOverloadedFunctionReference(SrcExpr, found, fn);
 
     // If desired, do function-to-pointer decay.
-    if (doFunctionPointerConverion) {
+    if (!SingleFunctionExpression.isInvalid() && doFunctionPointerConverion) {
       SingleFunctionExpression =
         DefaultFunctionArrayLvalueConversion(SingleFunctionExpression.get());
       if (SingleFunctionExpression.isInvalid()) {
         SrcExpr = ExprError();
         return true;
       }
     }
   }
static ExprResult FinishOverloadedCallExpr(Sema &SemaRef, Scope *S, Expr *Fn,
                                            OverloadingResult OverloadResult,
                                            bool AllowTypoCorrection) {
   switch (OverloadResult) {
   case OR_Success: {
     FunctionDecl *FDecl = (*Best)->Function;
     SemaRef.CheckUnresolvedLookupAccess(ULE, (*Best)->FoundDecl);
     if (SemaRef.DiagnoseUseOfDecl(FDecl, ULE->getNameLoc()))
       return ExprError();
-    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
-    return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
-                                         ExecConfig, /*IsExecConfig=*/false,
-                                         (*Best)->IsADLCandidate);
+    ExprResult OverloadFn =
+        SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+    if (OverloadFn.isInvalid())
+      return ExprError();
+    return SemaRef.BuildResolvedCallExpr(
+        OverloadFn.get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
+        /*IsExecConfig=*/false, (*Best)->IsADLCandidate);
   }
 
   case OR_No_Viable_Function: {
     // Try to recover by looking for viable functions which the user might
     // have meant to call.
     ExprResult Recovery = BuildRecoveryCallExpr(SemaRef, S, Fn, ULE, LParenLoc,
                                                 Args, RParenLoc,
                                                 CandidateSet->empty(),
CandidateSet->NoteCandidates(
         PartialDiagnosticAt(Fn->getBeginLoc(),
                             SemaRef.PDiag(diag::err_ovl_deleted_call)
                                 << ULE->getName() << Fn->getSourceRange()),
         SemaRef, OCD_AllCandidates, Args);
 
     // We emitted an error for the unavailable/deleted function call but keep
     // the call in the AST.
     FunctionDecl *FDecl = (*Best)->Function;
-    Fn = SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
-    return SemaRef.BuildResolvedCallExpr(Fn, FDecl, LParenLoc, Args, RParenLoc,
-                                         ExecConfig, /*IsExecConfig=*/false,
-                                         (*Best)->IsADLCandidate);
+    ExprResult OverloadFn =
+        SemaRef.FixOverloadedFunctionReference(Fn, (*Best)->FoundDecl, FDecl);
+    if (OverloadFn.isInvalid())
+      return ExprError();
+    return SemaRef.BuildResolvedCallExpr(
+        OverloadFn.get(), FDecl, LParenLoc, Args, RParenLoc, ExecConfig,
+        /*IsExecConfig=*/false, (*Best)->IsADLCandidate);
   }
   }
 
   // Overload resolution failed, try to recover.
   SmallVector<Expr *, 8> SubExprs = {Fn};
   SubExprs.append(Args.begin(), Args.end());
   return SemaRef.CreateRecoveryExpr(Fn->getBeginLoc(), RParenLoc, SubExprs,
                                     chooseRecoveryType(*CandidateSet, Best));
case OR_Deleted:
                                   << DeclName << MemExprE->getSourceRange()),
           *this, OCD_AllCandidates, Args);
       break;
     }
     // Overload resolution fails, try to recover.
     if (!Succeeded)
       return BuildRecoveryExpr(chooseRecoveryType(CandidateSet, &Best));
 
-    MemExprE = FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
+    ExprResult OverloadFn =
+        FixOverloadedFunctionReference(MemExprE, FoundDecl, Method);
+    if (OverloadFn.isInvalid())
+      return BuildRecoveryExpr(chooseRecoveryType(CandidateSet, &Best));
+    MemExprE = OverloadFn.get();
 
     // If overload resolution picked a static member, build a
     // non-member call based on that function.
     if (Method->isStatic()) {
       return BuildResolvedCallExpr(MemExprE, Method, LParenLoc, Args,
                                    RParenLoc);
     }
 
if (Best->Function == nullptr) {
 
     // Create an implicit member expr to refer to the conversion operator.
     // and then call it.
     ExprResult Call = BuildCXXMemberCallExpr(Object.get(), Best->FoundDecl,
                                              Conv, HadMultipleCandidates);
     if (Call.isInvalid())
       return ExprError();
     // Record usage of conversion in an implicit cast.
-    Call = ImplicitCastExpr::Create(
-        Context, Call.get()->getType(), CK_UserDefinedConversion, Call.get(),
-        nullptr, VK_RValue, CurFPFeatureOverrides());
+    Call = BuildImplicitCastExpr(Call.get(), Call.get()->getType(),
+                                 CK_UserDefinedConversion, VK_RValue,
+                                 CurFPFeatureOverrides());
+    if (Call.isInvalid())
+      return ExprError();
 
     return BuildCallExpr(S, Call.get(), LParenLoc, Args, RParenLoc);
   }
 
   CheckMemberOperatorAccess(LParenLoc, Object.get(), nullptr, Best->FoundDecl);
 
   // We found an overloaded operator(). Build a CXXOperatorCallExpr
   // that calls this method, using Object for the implicit object

 }
 
 
 /// FixOverloadedFunctionReference - E is an expression that refers to
 /// a C++ overloaded function (possibly with some parentheses and
 /// perhaps a '&' around it). We have resolved the overloaded function
 /// to the function declaration Fn, so patch up the expression E to
 /// refer (possibly indirectly) to Fn. Returns the new expr.
-Expr *Sema::FixOverloadedFunctionReference(Expr *E, DeclAccessPair Found,
+ExprResult Sema::FixOverloadedFunctionReference(ExprResult ER,
+                                                DeclAccessPair Found,
                                                 FunctionDecl *Fn) {
+  Expr *E = ER.get();
   if (ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
-    Expr *SubExpr = FixOverloadedFunctionReference(PE->getSubExpr(),
-                                                   Found, Fn);
-    if (SubExpr == PE->getSubExpr())
+    ExprResult SubExpr =
+        FixOverloadedFunctionReference(PE->getSubExpr(), Found, Fn);
+    if (SubExpr.isInvalid())
+      return ExprError();
+    if (SubExpr.get() == PE->getSubExpr())
       return PE;
 
-    return new (Context) ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr);
+    return new (Context)
+        ParenExpr(PE->getLParen(), PE->getRParen(), SubExpr.get());
   }
 
   if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
-    Expr *SubExpr = FixOverloadedFunctionReference(ICE->getSubExpr(),
-                                                   Found, Fn);
+    ExprResult SubExpr =
+        FixOverloadedFunctionReference(ICE->getSubExpr(), Found, Fn);
+    if (SubExpr.isInvalid())
+      return ExprError();
     assert(Context.hasSameType(ICE->getSubExpr()->getType(),
-                               SubExpr->getType()) &&
+                               SubExpr.get()->getType()) &&
            "Implicit cast type cannot be determined from overload");
     assert(ICE->path_empty() && "fixing up hierarchy conversion?");
-    if (SubExpr == ICE->getSubExpr())
+    if (SubExpr.get() == ICE->getSubExpr())
       return ICE;
 
-    return ImplicitCastExpr::Create(Context, ICE->getType(), ICE->getCastKind(),
-                                    SubExpr, nullptr, ICE->getValueKind(),
-                                    CurFPFeatureOverrides());
+    return BuildImplicitCastExpr(SubExpr.get(), ICE->getType(),
+                                 ICE->getCastKind(), ICE->getValueKind(),
   }
 
   if (auto *GSE = dyn_cast<GenericSelectionExpr>(E)) {
     if (!GSE->isResultDependent()) {
-      Expr *SubExpr =
+      ExprResult SubExpr =
           FixOverloadedFunctionReference(GSE->getResultExpr(), Found, Fn);
-      if (SubExpr == GSE->getResultExpr())
+      if (SubExpr.isInvalid())
+        return ExprError();
+      if (SubExpr.get() == GSE->getResultExpr())
         return GSE;
 
       // Replace the resulting type information before rebuilding the generic
       // selection expression.
       ArrayRef<Expr *> A = GSE->getAssocExprs();
       SmallVector<Expr *, 4> AssocExprs(A.begin(), A.end());
       unsigned ResultIdx = GSE->getResultIndex();
-      AssocExprs[ResultIdx] = SubExpr;
+      AssocExprs[ResultIdx] = SubExpr.get();
 
       return GenericSelectionExpr::Create(
           Context, GSE->getGenericLoc(), GSE->getControllingExpr(),
           GSE->getAssocTypeSourceInfos(), AssocExprs, GSE->getDefaultLoc(),
           GSE->getRParenLoc(), GSE->containsUnexpandedParameterPack(),
           ResultIdx);
     }
     // Rather than fall through to the unreachable, return the original generic
     // selection expression.
     return GSE;
   }
 
   if (UnaryOperator *UnOp = dyn_cast<UnaryOperator>(E)) {
     assert(UnOp->getOpcode() == UO_AddrOf &&
            "Can only take the address of an overloaded function");
     if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(Fn)) {
       if (Method->isStatic()) {
         // Do nothing: static member functions aren't any different
         // from non-member functions.
       } else {
         // Fix the subexpression, which really has to be an
         // UnresolvedLookupExpr holding an overloaded member function
         // or template.
-        Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
-                                                       Found, Fn);
-        if (SubExpr == UnOp->getSubExpr())
+        ExprResult SubExpr =
+            FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
+        if (SubExpr.isInvalid())
+          return ExprError();
+        if (SubExpr.get() == UnOp->getSubExpr())
           return UnOp;
 
-        assert(isa<DeclRefExpr>(SubExpr)
-               && "fixed to something other than a decl ref");
-        assert(cast<DeclRefExpr>(SubExpr)->getQualifier()
-               && "fixed to a member ref with no nested name qualifier");
+        assert(isa<DeclRefExpr>(SubExpr.get()) &&
+               "fixed to something other than a decl ref");
+        assert(cast<DeclRefExpr>(SubExpr.get())->getQualifier() &&
+               "fixed to a member ref with no nested name qualifier");
 
         // We have taken the address of a pointer to member
         // function. Perform the computation here so that we get the
         // appropriate pointer to member type.
         QualType ClassType
           = Context.getTypeDeclType(cast<RecordDecl>(Method->getDeclContext()));
         QualType MemPtrType
           = Context.getMemberPointerType(Fn->getType(), ClassType.getTypePtr());
         // Under the MS ABI, lock down the inheritance model now.
         if (Context.getTargetInfo().getCXXABI().isMicrosoft())
           (void)isCompleteType(UnOp->getOperatorLoc(), MemPtrType);
 
-        return UnaryOperator::Create(
-            Context, SubExpr, UO_AddrOf, MemPtrType, VK_RValue, OK_Ordinary,
-            UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
+        return UnaryOperator::Create(Context, SubExpr.get(), UO_AddrOf,
+                                     MemPtrType, VK_RValue, OK_Ordinary,
+                                     UnOp->getOperatorLoc(), false,
+                                     CurFPFeatureOverrides());
       }
     }
-    Expr *SubExpr = FixOverloadedFunctionReference(UnOp->getSubExpr(),
-                                                   Found, Fn);
-    if (SubExpr == UnOp->getSubExpr())
+    ExprResult SubExpr =
+        FixOverloadedFunctionReference(UnOp->getSubExpr(), Found, Fn);
+    if (SubExpr.isInvalid())
+      return ExprError();
+    if (SubExpr.get() == UnOp->getSubExpr())
       return UnOp;
 
-    return UnaryOperator::Create(Context, SubExpr, UO_AddrOf,
-                                 Context.getPointerType(SubExpr->getType()),
-                                 VK_RValue, OK_Ordinary, UnOp->getOperatorLoc(),
-                                 false, CurFPFeatureOverrides());
+    return UnaryOperator::Create(
+        Context, SubExpr.get(), UO_AddrOf,
+        Context.getPointerType(SubExpr.get()->getType()), VK_RValue,
+        OK_Ordinary, UnOp->getOperatorLoc(), false, CurFPFeatureOverrides());
   }
 
   if (UnresolvedLookupExpr *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
     // FIXME: avoid copy.
     TemplateArgumentListInfo TemplateArgsBuffer, *TemplateArgs = nullptr;
     if (ULE->hasExplicitTemplateArgs()) {
       ULE->copyTemplateArgumentsInto(TemplateArgsBuffer);
       TemplateArgs = &TemplateArgsBuffer;
return BuildMemberExpr(
         Base, MemExpr->isArrow(), MemExpr->getOperatorLoc(),
         MemExpr->getQualifierLoc(), MemExpr->getTemplateKeywordLoc(), Fn, Found,
         /*HadMultipleCandidates=*/true, MemExpr->getMemberNameInfo(),
         type, valueKind, OK_Ordinary, TemplateArgs);
   }
 
   llvm_unreachable("Invalid reference to overloaded function");
 }
-
-ExprResult Sema::FixOverloadedFunctionReference(ExprResult E,
-                                                DeclAccessPair Found,
-                                                FunctionDecl *Fn) {
-  return FixOverloadedFunctionReference(E.get(), Found, Fn);
-}

clang/lib/Sema/SemaStmt.cpp

 //===--- SemaStmt.cpp - Semantic Analysis for Statements ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
if (ConvertingConstructorsOnly) {
       } else {
         continue;
       }
     }
 
     NeedSecondOverloadResolution = false;
     // Promote "AsRvalue" to the heap, since we now need this
     // expression node to persist.
-    Value =
-        ImplicitCastExpr::Create(S.Context, Value->getType(), CK_NoOp, Value,
-                                 nullptr, VK_XValue, FPOptionsOverride());
-
+    ExprResult AsXValue = S.BuildImplicitCastExpr(
+        Value, Value->getType(), CK_NoOp, VK_XValue, FPOptionsOverride());
     // Complete type-checking the initialization of the return type
     // using the constructor we found.
-    Res = Seq.Perform(S, Entity, Kind, Value);
+    if (AsXValue.isInvalid())
+      Res = ExprError();
+    else {
+      Expr *E = AsXValue.get();
+      Res = Seq.Perform(S, Entity, Kind, E);
+    }
   }
 
   return NeedSecondOverloadResolution;
 }
 
 /// Perform the initialization of a potentially-movable value, which
 /// is the result of return value.
 ///

clang/lib/Sema/SemaTemplate.cpp

 //===------- SemaTemplate.cpp - Semantic Analysis for C++ Templates -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //===----------------------------------------------------------------------===//
 //
 //  This file implements semantic analysis for C++ templates.
if (// -- For a non-type template-parameter of type pointer to
          ->isFunctionType())) {
 
     if (Arg->getType() == Context.OverloadTy) {
       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg, ParamType,
                                                                 true,
                                                                 FoundResult)) {
         if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
           return ExprError();
-
-        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        ExprResult OverloadArg =
+            FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        if (OverloadArg.isInvalid())
+          return ExprError();
+        Arg = OverloadArg.get();
         ArgType = Arg->getType();
       } else
         return ExprError();
     }
 
     if (!ParamType->isMemberPointerType()) {
       if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                          ParamType,
if (const ReferenceType *ParamRefType = ParamType->getAs<ReferenceType>()) {
     if (Arg->getType() == Context.OverloadTy) {
       if (FunctionDecl *Fn = ResolveAddressOfOverloadedFunction(Arg,
                                                  ParamRefType->getPointeeType(),
                                                                 true,
                                                                 FoundResult)) {
         if (DiagnoseUseOfDecl(Fn, Arg->getBeginLoc()))
           return ExprError();
 
-        Arg = FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        ExprResult OverloadArg =
+            FixOverloadedFunctionReference(Arg, FoundResult, Fn);
+        if (OverloadArg.isInvalid())
+          return ExprError();
+        Arg = OverloadArg.get();
         ArgType = Arg->getType();
       } else
         return ExprError();
     }
 
     if (CheckTemplateArgumentAddressOfObjectOrFunction(*this, Param,
                                                        ParamType,
                                                        Arg, Converted))