Merge pull request #26118 from slavapestov/shallow-clone-be-gone

AST: Remove LiteralExpr::shallowClone()

Author: slavapestov

include/swift/AST/Expr.h

@@ -599,12 +599,6 @@ class CodeCompletionExpr : public Expr {
 class LiteralExpr : public Expr {
 public:
   LiteralExpr(ExprKind Kind, bool Implicit) : Expr(Kind, Implicit) {}
-  
-  // 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) {
     return E->getKind() >= ExprKind::First_LiteralExpr &&

lib/AST/Expr.cpp

@@ -773,103 +773,6 @@ llvm::DenseMap<Expr *, unsigned> Expr::getPreorderIndexMap() {
 // Support methods for Exprs.
 //===----------------------------------------------------------------------===//
 
-static LiteralExpr *
-shallowCloneImpl(const NilLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  return new (Ctx) NilLiteralExpr(E->getLoc());
-}
-
-static LiteralExpr *
-shallowCloneImpl(const IntegerLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  auto res = new (Ctx) IntegerLiteralExpr(E->getDigitsText(),
-                                          E->getSourceRange().End);
-  if (E->isNegative())
-    res->setNegative(E->getSourceRange().Start);
-  return res;
-}
-
-static LiteralExpr *
-shallowCloneImpl(const FloatLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  auto res = new (Ctx) FloatLiteralExpr(E->getDigitsText(),
-                                        E->getSourceRange().End);
-  if (E->isNegative())
-    res->setNegative(E->getSourceRange().Start);
-  return res;
-}
-static LiteralExpr *
-shallowCloneImpl(const BooleanLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  return new (Ctx) BooleanLiteralExpr(E->getValue(), E->getLoc());
-}
-static LiteralExpr *
-shallowCloneImpl(const StringLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  auto res = new (Ctx) StringLiteralExpr(E->getValue(), E->getSourceRange());
-  res->setEncoding(E->getEncoding());
-  return res;
-}
-
-static LiteralExpr *
-shallowCloneImpl(const InterpolatedStringLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  auto res = new (Ctx) InterpolatedStringLiteralExpr(E->getLoc(),
-                                                     E->getTrailingQuoteLoc(),
-                                                     E->getLiteralCapacity(),
-                                                     E->getInterpolationCount(),
-                                                     E->getAppendingExpr());
-  res->setSemanticExpr(E->getSemanticExpr());
-  return res;
-}
-
-static LiteralExpr *
-shallowCloneImpl(const MagicIdentifierLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  auto res = new (Ctx) MagicIdentifierLiteralExpr(E->getKind(),
-                                                  E->getSourceRange().End);
-  if (res->isString())
-    res->setStringEncoding(E->getStringEncoding());
-  return res;
-}
-
-static LiteralExpr *
-shallowCloneImpl(const ObjectLiteralExpr *E, ASTContext &Ctx,
-                 llvm::function_ref<Type(const Expr *)> getType) {
-  auto res =
-      ObjectLiteralExpr::create(Ctx, E->getStartLoc(), E->getLiteralKind(),
-                                E->getArg(), E->isImplicit(), getType);
-  return res;
-}
-
-// Make an exact copy of this AST node.
-LiteralExpr *LiteralExpr::shallowClone(
-    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!");
-#define DISPATCH_CLONE(KIND)                                                   \
-  case ExprKind::KIND:                                                         \
-    Result = shallowCloneImpl(cast<KIND##Expr>(this), Ctx, getType);           \
-    break;
-
-    DISPATCH_CLONE(NilLiteral)
-    DISPATCH_CLONE(IntegerLiteral)
-    DISPATCH_CLONE(FloatLiteral)
-    DISPATCH_CLONE(BooleanLiteral)
-    DISPATCH_CLONE(StringLiteral)
-    DISPATCH_CLONE(InterpolatedStringLiteral)
-    DISPATCH_CLONE(ObjectLiteral)
-    DISPATCH_CLONE(MagicIdentifierLiteral)
-#undef DISPATCH_CLONE
-  }
-
-  setType(Result, getType(this));
-  Result->setImplicit(isImplicit());
-  return Result;
-}
-
 IntegerLiteralExpr * IntegerLiteralExpr::createFromUnsigned(ASTContext &C, unsigned value) {
   llvm::SmallString<8> Scratch;
   llvm::APInt(sizeof(unsigned)*8, value).toString(Scratch, 10, /*signed*/ false);

lib/Sema/CSApply.cpp

@@ -6685,26 +6685,9 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
                                           DeclName builtinLiteralFuncName,
                                           Diag<> brokenProtocolDiag,
                                           Diag<> brokenBuiltinProtocolDiag) {
-  auto &tc = cs.getTypeChecker();
-
-  auto getType = [&](const Expr *E) -> Type {
-    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, setType,
-                                                       getType);
-
-    // The literal expression has this type.
     cs.setType(literal, type);
     return literal;
   }
@@ -6753,9 +6736,8 @@ Expr *ExprRewriter::convertLiteralInPlace(Expr *literal,
   // Dig out the literal type and perform a builtin literal conversion to it.
   if (!literalType.empty()) {
     // Extract the literal type.
-    Type builtinLiteralType = tc.getWitnessType(type, protocol, *conformance,
-                                                literalType,
-                                                brokenProtocolDiag);
+    Type builtinLiteralType =
+        conformance->getTypeWitnessByName(type, literalType);
     if (!builtinLiteralType)
       return nullptr;
 

test/Constraints/add_with_nil.swift

@@ -2,5 +2,5 @@
 
 func test(_ x: Int) -> Int {
   return x + nil
-  // expected-error@-1 {{cannot convert value of type 'Int' to expected argument type '_.Stride'}}
+  // expected-error@-1 {{type of expression is ambiguous without more context}}
 }