Merge pull request #8110 from rudkx/cs-typemap

Author: swift-ci

include/swift/AST/Expr.h

@@ -790,6 +790,7 @@ class LiteralExpr : public Expr {
   // Make an exact copy of this one AST node.
   LiteralExpr *
   shallowClone(ASTContext &Ctx,
+               llvm::function_ref<void(Expr *, Type)> setType,
                llvm::function_ref<Type(const Expr *)> getType) const;
 
   static bool classof(const Expr *E) {

lib/AST/Expr.cpp

@@ -930,7 +930,8 @@ shallowCloneImpl(const ObjectLiteralExpr *E, ASTContext &Ctx,
 
 // Make an exact copy of this AST node.
 LiteralExpr *LiteralExpr::shallowClone(
-    ASTContext &Ctx, llvm::function_ref<Type(const Expr *)> getType) const {
+    ASTContext &Ctx, llvm::function_ref<void(Expr *, Type)> setType,
+                     llvm::function_ref<Type(const Expr *)> getType) const {
   LiteralExpr *Result = nullptr;
   switch (getKind()) {
   default: llvm_unreachable("Unknown literal type!");
@@ -950,7 +951,7 @@ LiteralExpr *LiteralExpr::shallowClone(
 #undef DISPATCH_CLONE
   }
 
-  Result->setType(getType(this));
+  setType(Result, getType(this));
   Result->setImplicit(isImplicit());
   return Result;
 }

lib/Sema/CSApply.cpp

@@ -5980,13 +5980,18 @@ Expr *ExprRewriter::convertLiteral(Expr *literal,
     return cs.getType(E);
   };
 
+  auto setType = [&](Expr *E, Type Ty) {
+    cs.setType(E, Ty);
+  };
+
   // If coercing a literal to an unresolved type, we don't try to look up the
   // witness members, just do it.
   if (type->is<UnresolvedType>()) {
     // Instead of updating the literal expr in place, allocate a new node.  This
     // avoids issues where Builtin types end up on expr nodes and pollute
     // diagnostics.
-    literal = cast<LiteralExpr>(literal)->shallowClone(tc.Context, getType);
+    literal = cast<LiteralExpr>(literal)->shallowClone(tc.Context, setType,
+                                                       getType);
 
     // The literal expression has this type.
     cs.setType(literal, type);
@@ -6021,7 +6026,8 @@ Expr *ExprRewriter::convertLiteral(Expr *literal,
     // Instead of updating the literal expr in place, allocate a new node.  This
     // avoids issues where Builtin types end up on expr nodes and pollute
     // diagnostics.
-    literal = cast<LiteralExpr>(literal)->shallowClone(tc.Context, getType);
+    literal = cast<LiteralExpr>(literal)->shallowClone(tc.Context, setType,
+                                                       getType);
 
     // The literal expression has this type.
     cs.setType(literal, argType);
@@ -6124,13 +6130,18 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
     return cs.getType(E);
   };
 
+  auto setType = [&](Expr *E, Type Ty) {
+    cs.setType(E, Ty);
+  };
+
   // If coercing a literal to an unresolved type, we don't try to look up the
   // witness members, just do it.
   if (type->is<UnresolvedType>()) {
     // Instead of updating the literal expr in place, allocate a new node.  This
     // avoids issues where Builtin types end up on expr nodes and pollute
     // diagnostics.
-    literal = cast<LiteralExpr>(literal)->shallowClone(tc.Context, getType);
+    literal = cast<LiteralExpr>(literal)->shallowClone(tc.Context, setType,
+                                                       getType);
 
     // The literal expression has this type.
     cs.setType(literal, type);