Merge pull request swiftlang#28780 from slavapestov/sr-75-cleanups

A handful of cleanups in preparation for building curry thunks in Sema

Author: slavapestov

include/swift/AST/Expr.h

@@ -3748,7 +3748,8 @@ class AutoClosureExpr : public AbstractClosureExpr {
                   DeclContext *Parent)
       : AbstractClosureExpr(ExprKind::AutoClosure, ResultTy, /*Implicit=*/true,
                             Discriminator, Parent) {
-    setBody(Body);
+    if (Body != nullptr)
+      setBody(Body);
   }
 
   SourceRange getSourceRange() const;

include/swift/AST/ParameterList.h

@@ -103,15 +103,15 @@ class alignas(ParamDecl *) ParameterList final :
   /// Change the DeclContext of any contained parameters to the specified
   /// DeclContext.
   void setDeclContextOfParamDecls(DeclContext *DC);
-  
-  
+
   /// Flags used to indicate how ParameterList cloning should operate.
   enum CloneFlags {
     /// The cloned ParamDecls should be marked implicit.
     Implicit = 0x01,
-    /// The cloned pattern is for an inherited constructor; mark default
-    /// arguments as inherited, and mark unnamed arguments as named.
+    /// Mark default arguments as inherited.
     Inherited = 0x02,
+    /// Mark unnamed arguments as named.
+    NamedArguments = 0x04,
   };
 
   friend OptionSet<CloneFlags> operator|(CloneFlags flag1, CloneFlags flag2) {

lib/AST/Parameter.cpp

@@ -67,10 +67,9 @@ ParameterList *ParameterList::clone(const ASTContext &C,
     if (options & Implicit)
       decl->setImplicit();
 
-    // If the argument isn't named, and we're cloning for an inherited
-    // constructor, give the parameter a name so that silgen will produce a
-    // value for it.
-    if (decl->getName().empty() && (options & Inherited))
+    // If the argument isn't named, give the parameter a name so that
+    // silgen will produce a value for it.
+    if (decl->getName().empty() && (options & NamedArguments))
       decl->setName(C.getIdentifier("argument"));
 
     // If we're inheriting a default argument, mark it as such.

lib/SILGen/SILGenFunction.cpp

@@ -513,10 +513,7 @@ void SILGenFunction::emitClosure(AbstractClosureExpr *ace) {
     emitStmt(ce->getBody());
   } else {
     auto *autoclosure = cast<AutoClosureExpr>(ace);
-    // Closure expressions implicitly return the result of their body
-    // expression.
-    emitReturnExpr(ImplicitReturnLocation(ace),
-                   autoclosure->getSingleExpressionBody());
+    emitStmt(autoclosure->getBody());
   }
   emitEpilog(ace);
 }

lib/SILGen/SILGenProlog.cpp

@@ -443,19 +443,6 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
   uint16_t ArgNo = emitProlog(paramList, selfParam, resultType,
                               DC, throws, throwsLoc);
 
-  // Emit an unreachable instruction if a parameter type is
-  // uninhabited
-  if (paramList) {
-    for (auto *param : *paramList) {
-      if (param->getType()->isStructurallyUninhabited()) {
-        SILLocation unreachableLoc(param);
-        unreachableLoc.markAsPrologue();
-        B.createUnreachable(unreachableLoc);
-        break;
-      }
-    }
-  }
-
   // Emit the capture argument variables. These are placed last because they
   // become the first curry level of the SIL function.
   assert((captureInfo.hasBeenComputed() ||
@@ -491,6 +478,19 @@ void SILGenFunction::emitProlog(CaptureInfo captureInfo,
     emitCaptureArguments(*this, DC->getGenericSignatureOfContext(),
                          capture, ++ArgNo);
   }
+
+  // Emit an unreachable instruction if a parameter type is
+  // uninhabited
+  if (paramList) {
+    for (auto *param : *paramList) {
+      if (param->getType()->isStructurallyUninhabited()) {
+        SILLocation unreachableLoc(param);
+        unreachableLoc.markAsPrologue();
+        B.createUnreachable(unreachableLoc);
+        break;
+      }
+    }
+  }
 }
 
 static void emitIndirectResultParameters(SILGenFunction &SGF, Type resultType,

lib/Sema/CSApply.cpp

@@ -303,12 +303,10 @@ namespace {
     ///
     /// \param expr The expression to be coerced.
     /// \param toType The type to which the expression will be coerced.
-    /// \param locator Locator describing where this conversion occurs.
     ///
     /// \return The coerced expression, whose type will be equivalent to
     /// \c toType.
-    Expr *coerceSuperclass(Expr *expr, Type toType,
-                           ConstraintLocatorBuilder locator);
+    Expr *coerceSuperclass(Expr *expr, Type toType);
 
     /// Coerce the given value to existential type.
     ///
@@ -320,12 +318,10 @@ namespace {
     ///
     /// \param expr The expression to be coerced.
     /// \param toType The type to which the expression will be coerced.
-    /// \param locator Locator describing where this conversion occurs.
     ///
     /// \return The coerced expression, whose type will be equivalent to
     /// \c toType.
-    Expr *coerceExistential(Expr *expr, Type toType,
-                            ConstraintLocatorBuilder locator);
+    Expr *coerceExistential(Expr *expr, Type toType);
 
     /// Coerce an expression of (possibly unchecked) optional
     /// type to have a different (possibly unchecked) optional type.
@@ -4342,7 +4338,8 @@ namespace {
       auto closureTy =
           FunctionType::get({ FunctionType::Param(baseTy) }, leafTy);
       auto closure = new (ctx)
-          AutoClosureExpr(E, leafTy, discriminator, cs.DC);
+          AutoClosureExpr(/*set body later*/nullptr, leafTy,
+                          discriminator, cs.DC);
       auto param = new (ctx) ParamDecl(
           SourceLoc(),
           /*argument label*/ SourceLoc(), Identifier(),
@@ -4356,7 +4353,8 @@ namespace {
       auto outerClosureTy =
           FunctionType::get({ FunctionType::Param(keyPathTy) }, closureTy);
       auto outerClosure = new (ctx)
-          AutoClosureExpr(closure, closureTy, discriminator, cs.DC);
+          AutoClosureExpr(/*set body later*/nullptr, closureTy,
+                          discriminator, cs.DC);
       auto outerParam =
           new (ctx) ParamDecl(SourceLoc(),
                               /*argument label*/ SourceLoc(), Identifier(),
@@ -4754,8 +4752,7 @@ static Type getMetatypeSuperclass(Type t) {
   return t->getSuperclass();
 }
 
-Expr *ExprRewriter::coerceSuperclass(Expr *expr, Type toType,
-                                     ConstraintLocatorBuilder locator) {
+Expr *ExprRewriter::coerceSuperclass(Expr *expr, Type toType) {
   auto &ctx = cs.getASTContext();
 
   auto fromType = cs.getType(expr);
@@ -4780,7 +4777,7 @@ Expr *ExprRewriter::coerceSuperclass(Expr *expr, Type toType,
         new (ctx) ArchetypeToSuperExpr(expr, superclass));
 
     if (!superclass->isEqual(toType))
-      return coerceSuperclass(expr, toType, locator);
+      return coerceSuperclass(expr, toType);
 
     return expr;
 
@@ -4794,7 +4791,7 @@ Expr *ExprRewriter::coerceSuperclass(Expr *expr, Type toType,
     auto *archetypeVal = cs.cacheType(new (ctx) OpaqueValueExpr(
         expr->getSourceRange(), fromArchetype));
 
-    auto *result = coerceSuperclass(archetypeVal, toType, locator);
+    auto *result = coerceSuperclass(archetypeVal, toType);
 
     return cs.cacheType(
       new (ctx) OpenExistentialExpr(expr, archetypeVal, result,
@@ -4830,8 +4827,7 @@ collectExistentialConformances(Type fromType, Type toType,
   return toType->getASTContext().AllocateCopy(conformances);
 }
 
-Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType,
-                                      ConstraintLocatorBuilder locator) {
+Expr *ExprRewriter::coerceExistential(Expr *expr, Type toType) {
   Type fromType = cs.getType(expr);
   Type fromInstanceType = fromType;
   Type toInstanceType = toType;
@@ -5823,11 +5819,11 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
 
     case ConversionRestrictionKind::Superclass:
     case ConversionRestrictionKind::ExistentialMetatypeToMetatype:
-      return coerceSuperclass(expr, toType, locator);
+      return coerceSuperclass(expr, toType);
 
     case ConversionRestrictionKind::Existential:
     case ConversionRestrictionKind::MetatypeToExistentialMetatype:
-      return coerceExistential(expr, toType, locator);
+      return coerceExistential(expr, toType);
 
     case ConversionRestrictionKind::ClassMetatypeToAnyObject: {
       assert(ctx.LangOpts.EnableObjCInterop &&
@@ -6060,7 +6056,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
          fromSuperClass;
          fromSuperClass = fromSuperClass->getSuperclass()) {
       if (fromSuperClass->isEqual(toType)) {
-        return coerceSuperclass(expr, toType, locator);
+        return coerceSuperclass(expr, toType);
       }
     }
     break;
@@ -6193,7 +6189,7 @@ Expr *ExprRewriter::coerceToType(Expr *expr, Type toType,
   case TypeKind::ExistentialMetatype:
   case TypeKind::ProtocolComposition:
   case TypeKind::Protocol:
-    return coerceExistential(expr, toType, locator);
+    return coerceExistential(expr, toType);
 
   // Coercion to Optional<T>.
   case TypeKind::BoundGenericEnum: {

lib/Sema/CSDiag.cpp

@@ -201,10 +201,6 @@ class FailureDiagnosis :public ASTVisitor<FailureDiagnosis, /*exprresult*/bool>{
                                          ContextualTypePurpose CTP,
                                          Type suggestedType = Type());
 
-  /// For an expression being type checked with a CTP_CalleeResult contextual
-  /// type, try to diagnose a problem.
-  bool diagnoseCalleeResultContextualConversionError();
-
   /// Attempt to produce a diagnostic for a mismatch between a call's
   /// type and its assumed contextual type.
   bool diagnoseCallContextualConversionErrors(ApplyExpr *callEpxr,

lib/Sema/CodeSynthesis.cpp

@@ -642,7 +642,8 @@ createDesignatedInitOverride(ClassDecl *classDecl,
   // Create the initializer parameter patterns.
   OptionSet<ParameterList::CloneFlags> options
     = (ParameterList::Implicit |
-       ParameterList::Inherited);
+       ParameterList::Inherited |
+       ParameterList::NamedArguments);
   auto *superclassParams = superclassCtor->getParameters();
   auto *bodyParams = superclassParams->clone(ctx, options);
 

lib/Sema/TypeCheckCaptures.cpp

@@ -42,7 +42,8 @@ class FindCapturedVars : public ASTWalker {
   OpaqueValueExpr *OpaqueValue = nullptr;
   SourceLoc CaptureLoc;
   DeclContext *CurDC;
-  bool NoEscape, ObjC, IsGenericFunction;
+  bool NoEscape, ObjC;
+  bool HasGenericParamCaptures;
 
 public:
   FindCapturedVars(SourceLoc CaptureLoc,
@@ -51,23 +52,23 @@ class FindCapturedVars : public ASTWalker {
                    bool ObjC,
                    bool IsGenericFunction)
       : Context(CurDC->getASTContext()), CaptureLoc(CaptureLoc), CurDC(CurDC),
-        NoEscape(NoEscape), ObjC(ObjC), IsGenericFunction(IsGenericFunction) {}
+        NoEscape(NoEscape), ObjC(ObjC), HasGenericParamCaptures(IsGenericFunction) {}
 
   CaptureInfo getCaptureInfo() const {
     DynamicSelfType *dynamicSelfToRecord = nullptr;
-    bool hasGenericParamCaptures = IsGenericFunction;
 
     // Only local functions capture dynamic 'Self'.
     if (CurDC->getParent()->isLocalContext()) {
-      if (GenericParamCaptureLoc.isValid())
-        hasGenericParamCaptures = true;
-
       if (DynamicSelfCaptureLoc.isValid())
         dynamicSelfToRecord = DynamicSelf;
     }
 
     return CaptureInfo(Context, Captures, dynamicSelfToRecord, OpaqueValue,
-                       hasGenericParamCaptures);
+                       HasGenericParamCaptures);
+  }
+
+  bool hasGenericParamCaptures() const {
+    return HasGenericParamCaptures;
   }
 
   SourceLoc getGenericParamCaptureLoc() const {
@@ -148,17 +149,19 @@ class FindCapturedVars : public ASTWalker {
         if ((t->is<ArchetypeType>() ||
              t->is<GenericTypeParamType>()) &&
             !t->isOpenedExistential() &&
-            GenericParamCaptureLoc.isInvalid()) {
+            !HasGenericParamCaptures) {
           GenericParamCaptureLoc = loc;
+          HasGenericParamCaptures = true;
         }
       }));
     }
 
     if (auto *gft = type->getAs<GenericFunctionType>()) {
       TypeCaptureWalker walker(ObjC, [&](Type t) {
         if (t->is<GenericTypeParamType>() &&
-            GenericParamCaptureLoc.isInvalid()) {
+            !HasGenericParamCaptures) {
           GenericParamCaptureLoc = loc;
+          HasGenericParamCaptures = true;
         }
       });
 
@@ -339,9 +342,12 @@ class FindCapturedVars : public ASTWalker {
       addCapture(CapturedValue(capture.getDecl(), Flags, capture.getLoc()));
     }
 
-    if (GenericParamCaptureLoc.isInvalid())
-      if (captureInfo.hasGenericParamCaptures())
+    if (!HasGenericParamCaptures) {
+      if (captureInfo.hasGenericParamCaptures()) {
         GenericParamCaptureLoc = loc;
+        HasGenericParamCaptures = true;
+      }
+    }
 
     if (DynamicSelfCaptureLoc.isInvalid()) {
       if (captureInfo.hasDynamicSelfCapture()) {
@@ -631,7 +637,7 @@ void TypeChecker::computeCaptures(AnyFunctionRef AFR) {
 
   // Extensions of generic ObjC functions can't use generic parameters from
   // their context.
-  if (AFD && finder.getGenericParamCaptureLoc().isValid()) {
+  if (AFD && finder.hasGenericParamCaptures()) {
     if (auto Clas = AFD->getParent()->getSelfClassDecl()) {
       if (Clas->usesObjCGenericsModel()) {
         AFD->diagnose(diag::objc_generic_extension_using_type_parameter);

test/SILGen/functions_uninhabited_param.swift

@@ -8,3 +8,10 @@ func foo(baz: Never) -> Int { // expected-note {{'baz' is uninhabited, so this f
 }
 
 func bar(baz: Never) -> Int {} // ok
+
+// We used to crash when emitting the closure below.
+enum E {
+  static func f(_: E) {}
+}
+
+let _: (E.Type) -> (E) -> () = { s in { e in s.f(e) } }