Use DefaultArgumentExpr for caller-side defaults (#28279)

Use DefaultArgumentExpr for caller-side defaults

Author: hamishknight

include/swift/AST/Decl.h

@@ -5263,6 +5263,10 @@ class ParamDecl : public VarDecl {
   /// have a textual representation of their default expression.
   bool hasDefaultExpr() const;
 
+  /// Whether this parameter has a caller-side default argument expression
+  /// such as the magic literal \c #function.
+  bool hasCallerSideDefaultExpr() const;
+
   /// Retrieve the fully type-checked default argument expression for this
   /// parameter, or \c nullptr if there is no default expression.
   ///

include/swift/AST/Expr.h

@@ -48,6 +48,7 @@ namespace swift {
   class Decl;
   class DeclRefExpr;
   class OpenedArchetypeType;
+  class ParamDecl;
   class Pattern;
   class SubscriptDecl;
   class Stmt;
@@ -3864,6 +3865,8 @@ class OpaqueValueExpr : public Expr {
 /// A DefaultArgumentExpr must only appear as a direct child of a
 /// ParenExpr or a TupleExpr that is itself a call argument.
 class DefaultArgumentExpr final : public Expr {
+  friend class CallerSideDefaultArgExprRequest;
+
   /// The owning declaration.
   ConcreteDeclRef DefaultArgsOwner;
 
@@ -3873,11 +3876,17 @@ class DefaultArgumentExpr final : public Expr {
   /// The source location of the argument list.
   SourceLoc Loc;
 
+  /// Stores either a DeclContext or, upon type-checking, the caller-side
+  /// default expression.
+  PointerUnion<DeclContext *, Expr *> ContextOrCallerSideExpr;
+
 public:
-  explicit DefaultArgumentExpr(ConcreteDeclRef defaultArgsOwner, unsigned paramIndex,
-                               SourceLoc loc, Type Ty)
+  explicit DefaultArgumentExpr(ConcreteDeclRef defaultArgsOwner,
+                               unsigned paramIndex, SourceLoc loc, Type Ty,
+                               DeclContext *dc)
     : Expr(ExprKind::DefaultArgument, /*Implicit=*/true, Ty),
-      DefaultArgsOwner(defaultArgsOwner), ParamIndex(paramIndex), Loc(loc) { }
+      DefaultArgsOwner(defaultArgsOwner), ParamIndex(paramIndex), Loc(loc),
+      ContextOrCallerSideExpr(dc) { }
 
   SourceRange getSourceRange() const {
     return Loc;
@@ -3891,46 +3900,19 @@ class DefaultArgumentExpr final : public Expr {
     return ParamIndex;
   }
 
-  static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::DefaultArgument;
-  }
-};
-
-/// An expression referring to a caller-side default argument left unspecified
-/// at the call site.
-///
-/// A CallerDefaultArgumentExpr must only appear as a direct child of a
-/// ParenExpr or a TupleExpr that is itself a call argument.
-///
-/// FIXME: This only exists to distinguish caller default arguments from arguments
-/// that were specified at the call site. Once we remove SanitizeExpr, we can remove
-/// this hack too.
-class CallerDefaultArgumentExpr final : public Expr {
-  /// The expression that is evaluated to produce the default argument value.
-  Expr *SubExpr;
-
-  /// The source location of the argument list.
-  SourceLoc Loc;
-
-public:
-  explicit CallerDefaultArgumentExpr(Expr *subExpr, SourceLoc loc, Type Ty)
-    : Expr(ExprKind::CallerDefaultArgument, /*Implicit=*/true, Ty),
-      SubExpr(subExpr), Loc(loc) { }
+  /// Retrieves the parameter declaration for this default argument.
+  const ParamDecl *getParamDecl() const;
 
-  SourceRange getSourceRange() const {
-    return Loc;
-  }
+  /// Checks whether this is a caller-side default argument that is emitted
+  /// directly at the call site.
+  bool isCallerSide() const;
 
-  Expr *getSubExpr() const {
-    return SubExpr;
-  }
-
-  void setSubExpr(Expr *subExpr) {
-    SubExpr = subExpr;
-  }
+  /// For a caller-side default argument, retrieves the fully type-checked
+  /// expression within the context of the call site.
+  Expr *getCallerSideDefaultExpr() const;
 
   static bool classof(const Expr *E) {
-    return E->getKind() == ExprKind::CallerDefaultArgument;
+    return E->getKind() == ExprKind::DefaultArgument;
   }
 };
 
@@ -5398,6 +5380,9 @@ Expr *packSingleArgument(ASTContext &ctx, SourceLoc lParenLoc,
                               });
 
 void simple_display(llvm::raw_ostream &out, const ClosureExpr *CE);
+void simple_display(llvm::raw_ostream &out, const DefaultArgumentExpr *expr);
+
+SourceLoc extractNearestSourceLoc(const DefaultArgumentExpr *expr);
 
 } // end namespace swift
 

include/swift/AST/ExprNodes.def

@@ -127,7 +127,6 @@ EXPR(DynamicType, Expr)
 EXPR(RebindSelfInConstructor, Expr)
 EXPR(OpaqueValue, Expr)
 EXPR(DefaultArgument, Expr)
-EXPR(CallerDefaultArgument, Expr)
 EXPR(BindOptional, Expr)
 EXPR(OptionalEvaluation, Expr)
 EXPR(ForceValue, Expr)

include/swift/AST/TypeCheckRequests.h

@@ -33,6 +33,7 @@ namespace swift {
 class AbstractStorageDecl;
 class AccessorDecl;
 enum class AccessorKind;
+class DefaultArgumentExpr;
 class GenericParamList;
 class PrecedenceGroupDecl;
 struct PropertyWrapperBackingPropertyInfo;
@@ -1886,6 +1887,29 @@ class DefaultArgumentExprRequest
   void cacheResult(Expr *expr) const;
 };
 
+/// Computes the fully type-checked caller-side default argument within the
+/// context of the call site that it will be inserted into.
+class CallerSideDefaultArgExprRequest
+    : public SimpleRequest<CallerSideDefaultArgExprRequest,
+                           Expr *(DefaultArgumentExpr *),
+                           CacheKind::SeparatelyCached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<Expr *> evaluate(Evaluator &evaluator,
+                                  DefaultArgumentExpr *defaultExpr) const;
+
+public:
+  // Separate caching.
+  bool isCached() const { return true; }
+  Optional<Expr *> getCachedResult() const;
+  void cacheResult(Expr *expr) const;
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -27,6 +27,8 @@ SWIFT_REQUEST(TypeChecker, AttachedPropertyWrapperTypeRequest,
 SWIFT_REQUEST(TypeChecker, AttachedPropertyWrappersRequest,
               llvm::TinyPtrVector<CustomAttr *>(VarDecl *), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CallerSideDefaultArgExprRequest,
+              Expr *(DefaultArgumentExpr *), SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ClassAncestryFlagsRequest,
               AncestryFlags(ClassDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, CompareDeclSpecializationRequest,

lib/AST/ASTDumper.cpp

@@ -2494,12 +2494,6 @@ class PrintExpr : public ExprVisitor<PrintExpr> {
     PrintWithColorRAII(OS, ParenthesisColor) << ')';
   }
 
-  void visitCallerDefaultArgumentExpr(CallerDefaultArgumentExpr *E) {
-    printCommon(E, "caller_default_argument_expr");
-    printRec(E->getSubExpr());
-    PrintWithColorRAII(OS, ParenthesisColor) << ')';
-  }
-
   void printArgumentLabels(ArrayRef<Identifier> argLabels) {
     PrintWithColorRAII(OS, ArgumentsColor) << " arg_labels=";
     for (auto label : argLabels) {

lib/AST/ASTWalker.cpp

@@ -483,15 +483,6 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
 
   Expr *visitDefaultArgumentExpr(DefaultArgumentExpr *E) { return E; }
 
-  Expr *visitCallerDefaultArgumentExpr(CallerDefaultArgumentExpr *E) {
-    if (auto subExpr = doIt(E->getSubExpr())) {
-      E->setSubExpr(subExpr);
-      return E;
-    }
-
-    return nullptr;
-  }
-
   Expr *visitInterpolatedStringLiteralExpr(InterpolatedStringLiteralExpr *E) {
     if (auto oldAppendingExpr = E->getAppendingExpr()) {
       if (auto appendingExpr = doIt(oldAppendingExpr))

lib/AST/Decl.cpp

@@ -6081,6 +6081,25 @@ bool ParamDecl::hasDefaultExpr() const {
   llvm_unreachable("Unhandled case in switch");
 }
 
+bool ParamDecl::hasCallerSideDefaultExpr() const {
+  switch (getDefaultArgumentKind()) {
+  case DefaultArgumentKind::None:
+  case DefaultArgumentKind::Inherited:
+  case DefaultArgumentKind::StoredProperty:
+  case DefaultArgumentKind::Normal:
+    return false;
+  case DefaultArgumentKind::File:
+  case DefaultArgumentKind::Line:
+  case DefaultArgumentKind::Column:
+  case DefaultArgumentKind::Function:
+  case DefaultArgumentKind::DSOHandle:
+  case DefaultArgumentKind::NilLiteral:
+  case DefaultArgumentKind::EmptyArray:
+  case DefaultArgumentKind::EmptyDictionary:
+    return true;
+  }
+}
+
 Expr *ParamDecl::getTypeCheckedDefaultExpr() const {
   // Don't kick off a request if we know there's no default expr. The only
   // exception is for inherited default args which we need to perform a couple

lib/AST/Expr.cpp

@@ -25,6 +25,7 @@
 #include "swift/AST/ASTWalker.h"
 #include "swift/AST/AvailabilitySpec.h"
 #include "swift/AST/PrettyStackTrace.h"
+#include "swift/AST/TypeCheckRequests.h"
 #include "swift/AST/TypeLoc.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/PointerUnion.h"
@@ -311,7 +312,6 @@ ConcreteDeclRef Expr::getReferencedDecl() const {
 
   NO_REFERENCE(OpaqueValue);
   NO_REFERENCE(DefaultArgument);
-  NO_REFERENCE(CallerDefaultArgument);
 
   PASS_THROUGH_REFERENCE(BindOptional, getSubExpr);
   PASS_THROUGH_REFERENCE(OptionalEvaluation, getSubExpr);
@@ -620,7 +620,6 @@ bool Expr::canAppendPostfixExpression(bool appendingPostfixOperator) const {
   case ExprKind::RebindSelfInConstructor:
   case ExprKind::OpaqueValue:
   case ExprKind::DefaultArgument:
-  case ExprKind::CallerDefaultArgument:
   case ExprKind::BindOptional:
   case ExprKind::OptionalEvaluation:
     return false;
@@ -1382,6 +1381,23 @@ static ValueDecl *getCalledValue(Expr *E) {
   return nullptr;
 }
 
+const ParamDecl *DefaultArgumentExpr::getParamDecl() const {
+  return getParameterAt(DefaultArgsOwner.getDecl(), ParamIndex);
+}
+
+bool DefaultArgumentExpr::isCallerSide() const {
+  return getParamDecl()->hasCallerSideDefaultExpr();
+}
+
+Expr *DefaultArgumentExpr::getCallerSideDefaultExpr() const {
+  assert(isCallerSide());
+  auto &ctx = DefaultArgsOwner.getDecl()->getASTContext();
+  auto *mutableThis = const_cast<DefaultArgumentExpr *>(this);
+  return evaluateOrDefault(ctx.evaluator,
+                           CallerSideDefaultArgExprRequest{mutableThis},
+                           new (ctx) ErrorExpr(getSourceRange(), getType()));
+}
+
 ValueDecl *ApplyExpr::getCalledValue() const {
   return ::getCalledValue(Fn);
 }
@@ -2209,6 +2225,23 @@ void swift::simple_display(llvm::raw_ostream &out, const ClosureExpr *CE) {
   }
 }
 
+void swift::simple_display(llvm::raw_ostream &out,
+                           const DefaultArgumentExpr *expr) {
+  if (!expr) {
+    out << "(null)";
+    return;
+  }
+
+  out << "default arg for param ";
+  out << "#" << expr->getParamIndex() + 1 << " ";
+  out << "of ";
+  simple_display(out, expr->getDefaultArgsOwner().getDecl());
+}
+
+SourceLoc swift::extractNearestSourceLoc(const DefaultArgumentExpr *expr) {
+  return expr->getLoc();
+}
+
 // See swift/Basic/Statistic.h for declaration: this enables tracing Exprs, is
 // defined here to avoid too much layering violation / circular linkage
 // dependency.

lib/AST/TypeCheckRequests.cpp

@@ -1218,3 +1218,23 @@ void DefaultArgumentExprRequest::cacheResult(Expr *expr) const {
   auto *param = std::get<0>(getStorage());
   param->setDefaultExpr(expr, /*isTypeChecked*/ true);
 }
+
+//----------------------------------------------------------------------------//
+// CallerSideDefaultArgExprRequest computation.
+//----------------------------------------------------------------------------//
+
+Optional<Expr *> CallerSideDefaultArgExprRequest::getCachedResult() const {
+  auto *defaultExpr = std::get<0>(getStorage());
+  auto storage = defaultExpr->ContextOrCallerSideExpr;
+  assert(!storage.isNull());
+
+  if (auto *expr = storage.dyn_cast<Expr *>())
+    return expr;
+
+  return None;
+}
+
+void CallerSideDefaultArgExprRequest::cacheResult(Expr *expr) const {
+  auto *defaultExpr = std::get<0>(getStorage());
+  defaultExpr->ContextOrCallerSideExpr = expr;
+}

lib/SILGen/ASTVisitor.h

@@ -60,11 +60,6 @@ class ASTVisitor : public swift::ASTVisitor<ImplClass,
     llvm_unreachable("DefaultArgumentExpr should not appear in this position");
   }
 
-  ExprRetTy visitCallerDefaultArgumentExpr(CallerDefaultArgumentExpr *E, Args... AA) {
-    return static_cast<ImplClass*>(this)->visit(E->getSubExpr(),
-                                                std::forward<Args>(AA)...);
-  }
-
   ExprRetTy visitVarargExpansionExpr(VarargExpansionExpr *E, Args... AA) {
     return static_cast<ImplClass*>(this)->visit(E->getSubExpr(),
                                                 std::forward<Args>(AA)...);

lib/SILGen/ArgumentSource.h

@@ -172,15 +172,22 @@ class ArgumentSource {
   bool isRValue() const & { return StoredKind == Kind::RValue; }
   bool isLValue() const & { return StoredKind == Kind::LValue; }
 
-  bool isDefaultArg() const {
+  /// Whether this argument is for a default argument that should be delayed.
+  /// Note that this will return false for caller-side default arguments which
+  /// are emitted directly.
+  bool isDelayedDefaultArg() const {
     switch (StoredKind) {
     case Kind::Invalid:
       llvm_unreachable("argument source is invalid");
     case Kind::RValue:
     case Kind::LValue:
       return false;
-    case Kind::Expr:
-      return isa<DefaultArgumentExpr>(asKnownExpr());
+    case Kind::Expr: {
+      auto *defaultArg = dyn_cast<DefaultArgumentExpr>(asKnownExpr());
+      if (!defaultArg)
+        return false;
+      return !defaultArg->isCallerSide();
+    }
     }
     llvm_unreachable("bad kind");
   }

lib/SILGen/SILGenApply.cpp

@@ -2634,9 +2634,9 @@ class ArgEmitter {
 
   // origParamType is a parameter type.
   void emitSingleArg(ArgumentSource &&arg, AbstractionPattern origParamType) {
-    // If this is default argument, prepare to emit the default argument
+    // If this is delayed default argument, prepare to emit the default argument
     // generator later.
-    if (arg.isDefaultArg()) {
+    if (arg.isDelayedDefaultArg()) {
       auto substParamType = arg.getSubstRValueType();
       auto defArg = std::move(arg).asKnownDefaultArg();