[AST] Distinguish memberwise-initialized properties for storage vs. declared

The determination of whether a property is memberwise-initialized is
somewhat confused for properties that have synthesized backing properties.
Some clients (Sema/Index) want to see the declared properties, while others
(SILGen) want to see the backing stored properties. Add a flag to
`VarDecl::isMemberwiseInitialized()` to capture this variation.

Author: DougGregor

include/swift/AST/Decl.h

@@ -5145,7 +5145,13 @@ class VarDecl : public AbstractStorageDecl {
 
   /// Determine whether this property will be part of the implicit memberwise
   /// initializer.
-  bool isMemberwiseInitialized() const;
+  ///
+  /// \param preferDeclaredProperties When encountering a `lazy` property
+  /// or a property that has an attached property delegate, prefer the
+  /// actual declared property (which may or may not be considered "stored"
+  /// as the moment) to the backing storage property. Otherwise, the stored
+  /// backing property will be treated as the member-initialized property.
+  bool isMemberwiseInitialized(bool preferDeclaredProperties) const;
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { 

lib/AST/Decl.cpp

@@ -5254,19 +5254,50 @@ bool VarDecl::isSelfParameter() const {
   return false;
 }
 
-bool VarDecl::isMemberwiseInitialized() const {
-  if (!getDeclContext()->isTypeContext())
+/// Whether the given variable is the backing storage property for
+/// a declared property that is either `lazy` or has an attached
+/// property delegate.
+static bool isBackingStorageForDeclaredProperty(const VarDecl *var) {
+  if (var->getOriginalDelegatedProperty())
+    return true;
+
+  auto name = var->getName();
+  if (name.empty())
     return false;
 
-  // Implicit, computed, and static properties are not initialized.
-  // The exception is lazy properties, which due to batch mode we may or
-  // may not have yet finalized, so they may currently be "stored" or
-  // "computed" in the current AST state.
-  if (isImplicit() || isStatic())
+  return name.str().startswith("$__lazy_storage_$_");
+}
+
+/// Whether the given variable
+static bool isDeclaredPropertyWithBackingStorage(const VarDecl *var) {
+  if (var->getAttrs().hasAttribute<LazyAttr>())
+    return true;
+
+  if (var->getAttachedPropertyDelegate())
+    return true;
+
+  return false;
+}
+
+bool VarDecl::isMemberwiseInitialized(bool preferDeclaredProperties) const {
+  // Only non-static properties in type context can be part of a memberwise
+  // initializer.
+  if (!getDeclContext()->isTypeContext() || isStatic())
+    return false;
+
+  // If this is a stored property, and not a backing property in a case where
+  // we only want to see the declared properties, it can be memberwise
+  // initialized.
+  if (hasStorage() && preferDeclaredProperties &&
+      isBackingStorageForDeclaredProperty(this))
     return false;
 
-  if (!hasStorage() && !getAttrs().hasAttribute<LazyAttr>() &&
-      !getAttachedPropertyDelegate())
+  // If this is a computed property, it's not memberwise initialized unless
+  // the caller has asked for the declared properties and it is either a
+  // `lazy` property or a property with an attached delegate.
+  if (!hasStorage() &&
+      !(preferDeclaredProperties &&
+        isDeclaredPropertyWithBackingStorage(this)))
     return false;
 
   // Initialized 'let' properties have storage, but don't get an argument

lib/Index/Index.cpp

@@ -360,11 +360,12 @@ class IndexSwiftASTWalker : public SourceEntityWalker {
       return;
 
     unsigned CurLabel = 0;
-    for (auto Prop : TypeContext->getStoredProperties()) {
-      if (auto Original = Prop->getOriginalDelegatedProperty())
-        Prop = Original;
+    for (auto Member : TypeContext->getMembers()) {
+      auto Prop = dyn_cast<VarDecl>(Member);
+      if (!Prop)
+        continue;
 
-      if (!Prop->isMemberwiseInitialized())
+      if (!Prop->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
         continue;
 
       if (CurLabel == LabelLocs.size())

lib/SILGen/SILGenConstructor.cpp

@@ -218,7 +218,7 @@ static void emitImplicitValueConstructor(SILGenFunction &SGF,
     SILValue v;
 
     // If it's memberwise initialized, do so now.
-    if (field->isMemberwiseInitialized()) {
+    if (field->isMemberwiseInitialized(/*preferDeclaredProperties=*/false)) {
       FullExpr scope(SGF.Cleanups, field->getParentPatternBinding());
       assert(elti != eltEnd && "number of args does not match number of fields");
       (void)eltEnd;

lib/Sema/CodeSynthesis.cpp

@@ -2077,7 +2077,7 @@ ConstructorDecl *swift::createImplicitConstructor(TypeChecker &tc,
       if (!var)
         continue;
 
-      if (!var->isMemberwiseInitialized())
+      if (!var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
         continue;
 
       accessLevel = std::min(accessLevel, var->getFormalAccess());

lib/Sema/TypeCheckDecl.cpp

@@ -5230,7 +5230,7 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
   if (isa<StructDecl>(decl)) {
     for (auto member : decl->getMembers()) {
       if (auto var = dyn_cast<VarDecl>(member)) {
-        if (!var->isMemberwiseInitialized())
+        if (!var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true))
           continue;
 
         validateDecl(var);
@@ -5303,7 +5303,7 @@ void TypeChecker::addImplicitConstructors(NominalTypeDecl *decl) {
         if (backingStorageVars.count(var) > 0)
           continue;
 
-        if (var->isMemberwiseInitialized()) {
+        if (var->isMemberwiseInitialized(/*preferDeclaredProperties=*/true)) {
           // Initialized 'let' properties have storage, but don't get an argument
           // to the memberwise initializer since they already have an initial
           // value that cannot be overridden.