[Sema] Requestify default init synthesis

This commit adds two requests, one to compute
whether or not a decl should have a default
initializer, and another to synthesize it.

This then allows us to remove the default constructor
synthesis from addImplicitConstructorsToClass as
well as completely eliminate addImplicitConstructorsToStruct.
For now, we can just force the requests in
addImplicitConstructors.

Author: hamishknight

include/swift/AST/Decl.h

@@ -3471,6 +3471,14 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// or \c nullptr if it does not have one.
   ConstructorDecl *getMemberwiseInitializer() const;
 
+  /// Whether this declaration has a synthesized zero parameter default
+  /// initializer.
+  bool hasDefaultInitializer() const;
+
+  /// Retrieves the synthesized zero parameter default initializer for this
+  /// declaration, or \c nullptr if it doesn't have one.
+  ConstructorDecl *getDefaultInitializer() const;
+
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) {
     return D->getKind() >= DeclKind::First_NominalTypeDecl &&

include/swift/AST/TypeCheckRequests.h

@@ -1587,6 +1587,46 @@ class SynthesizeMemberwiseInitRequest
   bool isCached() const { return true; }
 };
 
+/// Checks whether this type has a synthesized zero parameter default
+/// initializer.
+class HasDefaultInitRequest
+    : public SimpleRequest<HasDefaultInitRequest, bool(NominalTypeDecl *),
+                           CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<bool> evaluate(Evaluator &evaluator,
+                                NominalTypeDecl *decl) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
+/// Synthesizes a default initializer for a given type.
+class SynthesizeDefaultInitRequest
+    : public SimpleRequest<SynthesizeDefaultInitRequest,
+                           ConstructorDecl *(NominalTypeDecl *),
+                           CacheKind::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  llvm::Expected<ConstructorDecl *> evaluate(Evaluator &evaluator,
+                                             NominalTypeDecl *decl) const;
+
+public:
+  // Caching.
+  bool isCached() const { return true; }
+};
+
 // Allow AnyValue to compare two Type values, even though Type doesn't
 // support ==.
 template<>

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -173,3 +173,7 @@ SWIFT_REQUEST(TypeChecker, HasMemberwiseInitRequest,
               bool(StructDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, SynthesizeMemberwiseInitRequest,
               ConstructorDecl *(NominalTypeDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, HasDefaultInitRequest,
+              bool(NominalTypeDecl *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeDefaultInitRequest,
+              ConstructorDecl *(NominalTypeDecl *), Cached, NoLocationInfo)

lib/AST/Decl.cpp

@@ -3856,6 +3856,27 @@ ConstructorDecl *NominalTypeDecl::getMemberwiseInitializer() const {
       ctx.evaluator, SynthesizeMemberwiseInitRequest{mutableThis}, nullptr);
 }
 
+bool NominalTypeDecl::hasDefaultInitializer() const {
+  // Currently only structs and classes can have default initializers.
+  if (!isa<StructDecl>(this) && !isa<ClassDecl>(this))
+    return false;
+
+  auto &ctx = getASTContext();
+  auto *mutableThis = const_cast<NominalTypeDecl *>(this);
+  return evaluateOrDefault(ctx.evaluator, HasDefaultInitRequest{mutableThis},
+                           false);
+}
+
+ConstructorDecl *NominalTypeDecl::getDefaultInitializer() const {
+  if (!hasDefaultInitializer())
+    return nullptr;
+
+  auto &ctx = getASTContext();
+  auto *mutableThis = const_cast<NominalTypeDecl *>(this);
+  return evaluateOrDefault(ctx.evaluator,
+                           SynthesizeDefaultInitRequest{mutableThis}, nullptr);
+}
+
 ClassDecl::ClassDecl(SourceLoc ClassLoc, Identifier Name, SourceLoc NameLoc,
                      MutableArrayRef<TypeLoc> Inherited,
                      GenericParamList *GenericParams, DeclContext *Parent)

lib/Sema/CodeSynthesis.cpp

@@ -864,26 +864,7 @@ static bool hasUserDefinedDesignatedInit(Evaluator &eval,
                            false);
 }
 
-static void addImplicitConstructorsToStruct(StructDecl *decl) {
-  assert(!decl->hasClangNode() &&
-         "ClangImporter is responsible for adding implicit constructors");
-  assert(!decl->hasUnreferenceableStorage() &&
-         "User-defined structs cannot have unreferenceable storage");
-
-  decl->setAddedImplicitInitializers();
-  (void)decl->getMemberwiseInitializer();
-
-  // If the user has already defined a designated initializer, then don't
-  // synthesize a default initializer.
-  auto &ctx = decl->getASTContext();
-  if (hasUserDefinedDesignatedInit(ctx.evaluator, decl))
-    return;
-
-  if (areAllStoredPropertiesDefaultInitializable(ctx.evaluator, decl))
-    TypeChecker::defineDefaultConstructor(decl);
-}
-
-static void addImplicitConstructorsToClass(ClassDecl *decl) {
+static void addImplicitInheritedConstructorsToClass(ClassDecl *decl) {
   // Bail out if we're validating one of our constructors already;
   // we'll revisit the issue later.
   if (!decl->hasClangNode()) {
@@ -1048,22 +1029,6 @@ static void addImplicitConstructorsToClass(ClassDecl *decl) {
 
     return;
   }
-
-  if (!foundDesignatedInit) {
-    // For a class with no superclass, automatically define a default
-    // constructor.
-
-    // ... unless there are uninitialized stored properties.
-    if (!defaultInitable)
-      return;
-
-    // Clang-imported types should never get a default constructor, just a
-    // memberwise one.
-    if (decl->hasClangNode())
-      return;
-
-    TypeChecker::defineDefaultConstructor(decl);
-  }
 }
 
 void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
@@ -1083,10 +1048,13 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
     }
   }
 
-  if (auto *structDecl = dyn_cast<StructDecl>(decl))
-    addImplicitConstructorsToStruct(structDecl);
   if (auto *classDecl = dyn_cast<ClassDecl>(decl))
-    addImplicitConstructorsToClass(classDecl);
+    addImplicitInheritedConstructorsToClass(classDecl);
+
+  // Force the memberwise and default initializers if the type has them.
+  // FIXME: We need to be more lazy about synthesizing constructors.
+  (void)decl->getMemberwiseInitializer();
+  (void)decl->getDefaultInitializer();
 }
 
 void TypeChecker::synthesizeMemberForLookup(NominalTypeDecl *target,
@@ -1218,6 +1186,37 @@ SynthesizeMemberwiseInitRequest::evaluate(Evaluator &evaluator,
   return ctor;
 }
 
+llvm::Expected<bool>
+HasDefaultInitRequest::evaluate(Evaluator &evaluator,
+                                NominalTypeDecl *decl) const {
+  assert(isa<StructDecl>(decl) || isa<ClassDecl>(decl));
+
+  // Don't synthesize a default for imported decls.
+  if (decl->hasClangNode())
+    return false;
+
+  if (auto *sd = dyn_cast<StructDecl>(decl)) {
+    assert(!sd->hasUnreferenceableStorage() &&
+           "User-defined structs cannot have unreferenceable storage");
+    (void)sd;
+  }
+
+  // Don't synthesize a default for a subclass, it will attempt to inherit its
+  // initializers from its superclass.
+  if (auto *cd = dyn_cast<ClassDecl>(decl))
+    if (cd->getSuperclass())
+      return false;
+
+  // If the user has already defined a designated initializer, then don't
+  // synthesize a default init.
+  if (hasUserDefinedDesignatedInit(evaluator, decl))
+    return false;
+
+  // We can only synthesize a default init if all the stored properties have an
+  // initial value.
+  return areAllStoredPropertiesDefaultInitializable(evaluator, decl);
+}
+
 /// Synthesizer callback for a function body consisting of "return".
 static std::pair<BraceStmt *, bool>
 synthesizeSingleReturnFunctionBody(AbstractFunctionDecl *afd, void *) {
@@ -1228,7 +1227,9 @@ synthesizeSingleReturnFunctionBody(AbstractFunctionDecl *afd, void *) {
            /*isTypeChecked=*/true };
 }
 
-void TypeChecker::defineDefaultConstructor(NominalTypeDecl *decl) {
+llvm::Expected<ConstructorDecl *>
+SynthesizeDefaultInitRequest::evaluate(Evaluator &evaluator,
+                                       NominalTypeDecl *decl) const {
   auto &ctx = decl->getASTContext();
 
   FrontendStatsTracer StatsTracer(ctx.Stats, "define-default-ctor", decl);
@@ -1245,4 +1246,5 @@ void TypeChecker::defineDefaultConstructor(NominalTypeDecl *decl) {
 
   // Lazily synthesize an empty body for the default constructor.
   ctor->setBodySynthesizer(synthesizeSingleReturnFunctionBody);
+  return ctor;
 }

lib/Sema/TypeChecker.h

@@ -1149,9 +1149,6 @@ class TypeChecker final : public LazyResolver {
   Optional<Type> boolType;
 
 public:
-  /// Define the default constructor for the given struct or class.
-  static void defineDefaultConstructor(NominalTypeDecl *decl);
-
   /// Fold the given sequence expression into an (unchecked) expression
   /// tree.
   Expr *foldSequence(SequenceExpr *expr, DeclContext *dc);