Use DefaultArgumentExpr for caller-side defaults

This commit changes how we represent caller-side
default arguments within the AST. Instead of
directly inserting them into the call-site, use
a DefaultArgumentExpr to refer to them indirectly.

The main goal of this change is to make it such
that the expression type-checker no longer cares
about the difference between caller-side and
callee-side default arguments. In particular, it
no longer cares about whether a caller-side
default argument is well-formed when type-checking
an apply. This is important because any
conversions introduced by the default argument
shouldn't affect the score of the resulting
solution.

Instead, caller-side defaults are now lazily
type-checked when we want to emit them in SILGen.
This is done through introducing a request, and
adjusting the logic in SILGen to be more lenient
with ErrorExprs. Caller-side defaults in primary
files are still also currently checked as a part
of the declaration by `checkDefaultArguments`.

Resolves SR-11085.
Resolves rdar://problem/56144412.

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,6 +3900,17 @@ class DefaultArgumentExpr final : public Expr {
     return ParamIndex;
   }
 
+  /// Retrieves the parameter declaration for this default argument.
+  const ParamDecl *getParamDecl() const;
+
+  /// Checks whether this is a caller-side default argument that is emitted
+  /// directly at the call site.
+  bool isCallerSide() const;
+
+  /// 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::DefaultArgument;
   }
@@ -5398,6 +5418,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/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/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"
@@ -1382,6 +1383,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 +2227,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/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();
 

lib/SILGen/SILGenExpr.cpp

@@ -499,6 +499,8 @@ namespace {
     RValue visitUnevaluatedInstanceExpr(UnevaluatedInstanceExpr *E,
                                         SGFContext C);
     RValue visitTapExpr(TapExpr *E, SGFContext C);
+    RValue visitDefaultArgumentExpr(DefaultArgumentExpr *E, SGFContext C);
+    RValue visitErrorExpr(ErrorExpr *E, SGFContext C);
   };
 } // end anonymous namespace
 
@@ -5399,6 +5401,25 @@ RValue RValueEmitter::visitTapExpr(TapExpr *E, SGFContext C) {
   return outerScope.popPreservingValue(std::move(result));
 }
 
+RValue RValueEmitter::visitDefaultArgumentExpr(DefaultArgumentExpr *E,
+                                               SGFContext C) {
+  // We should only be emitting this as an rvalue for caller-side default
+  // arguments such as magic literals. Other default arguments get handled
+  // specially.
+  return SGF.emitRValue(E->getCallerSideDefaultExpr());
+}
+
+RValue RValueEmitter::visitErrorExpr(ErrorExpr *E, SGFContext C) {
+  // Running into an ErrorExpr here means we've failed to lazily typecheck
+  // something. Just emit an undef of the appropriate type and carry on.
+  if (SGF.getASTContext().Diags.hadAnyError())
+    return SGF.emitUndefRValue(E, E->getType());
+
+  // Use report_fatal_error to ensure we trap in release builds instead of
+  // miscompiling.
+  llvm::report_fatal_error("Found an ErrorExpr but didn't emit an error?");
+}
+
 RValue SILGenFunction::emitRValue(Expr *E, SGFContext C) {
   assert(!E->getType()->hasLValueType() &&
          "l-values must be emitted with emitLValue");