Merge pull request swiftlang#27758 from CodaFi/a-pattern-of-deescalation

Author: swift-ci

include/swift/AST/ASTScope.h

@@ -1270,8 +1270,7 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
   PatternEntryInitializerScope(PatternBindingDecl *pbDecl, unsigned entryIndex,
                                DeclVisibilityKind vis)
       : AbstractPatternEntryScope(pbDecl, entryIndex, vis),
-        initAsWrittenWhenCreated(
-            pbDecl->getPatternList()[entryIndex].getOriginalInit()) {}
+        initAsWrittenWhenCreated(pbDecl->getOriginalInit(entryIndex)) {}
   virtual ~PatternEntryInitializerScope() {}
 
 protected:

include/swift/AST/Decl.h

@@ -93,6 +93,12 @@ namespace swift {
   class VarDecl;
   class OpaqueReturnTypeRepr;
 
+  namespace ast_scope {
+  class AbstractPatternEntryScope;
+  class PatternEntryDeclScope;
+  class PatternEntryInitializerScope;
+  } // namespace ast_scope
+
 enum class DeclKind : uint8_t {
 #define DECL(Id, Parent) Id,
 #define LAST_DECL(Id) Last_Decl = Id,
@@ -1929,8 +1935,14 @@ class PatternBindingEntry {
   /// Values captured by this initializer.
   CaptureInfo Captures;
 
+  friend class Parser;
   friend class PatternBindingInitializer;
+  friend class PatternBindingDecl;
+  friend class ast_scope::AbstractPatternEntryScope;
+  friend class ast_scope::PatternEntryDeclScope;
+  friend class ast_scope::PatternEntryInitializerScope;
 
+private:
   // FIXME: This API is transitional. Once the callers of
   // typeCheckPatternBinding are requestified, merge this bit with
   // Flags::Checked.
@@ -1952,6 +1964,7 @@ class PatternBindingEntry {
       : PatternAndFlags(P, {}), InitExpr({E, E, EqualLoc}),
         InitContextAndFlags({InitContext, None}) {}
 
+private:
   Pattern *getPattern() const { return PatternAndFlags.getPointer(); }
   void setPattern(Pattern *P) { PatternAndFlags.setPointer(P); }
 
@@ -2051,6 +2064,8 @@ class PatternBindingEntry {
   CaptureInfo getCaptureInfo() const { return Captures; }
   void setCaptureInfo(CaptureInfo captures) { Captures = captures; }
 
+  unsigned getNumBoundVariables() const;
+
 private:
   SourceLoc getLastAccessorEndLoc() const;
 };
@@ -2136,6 +2151,9 @@ class PatternBindingDecl final : public Decl,
   Expr *getExecutableInit(unsigned i) const {
     return getPatternList()[i].getExecutableInit();
   }
+  Expr *getOriginalInit(unsigned i) const {
+    return getPatternList()[i].getOriginalInit();
+  }
 
   SourceRange getOriginalInitRange(unsigned i) const {
     return getPatternList()[i].getOriginalInitRange();
@@ -2172,13 +2190,6 @@ class PatternBindingDecl final : public Decl,
   /// and "c" and "d" will have index 1 since they correspond to the second one.
   unsigned getPatternEntryIndexForVarDecl(const VarDecl *VD) const;
 
-  /// Return the PatternEntry (a pattern + initializer pair) for the specified
-  /// VarDecl.
-  const PatternBindingEntry &getPatternEntryForVarDecl(
-    const VarDecl *VD) const {
-    return getPatternList()[getPatternEntryIndexForVarDecl(VD)];
-  }
-  
   bool isInitializerChecked(unsigned i) const {
     return getPatternList()[i].isInitializerChecked();
   }
@@ -2201,7 +2212,7 @@ class PatternBindingDecl final : public Decl,
   /// Determines whether this binding either has an initializer expression, or is
   /// default initialized, without performing any type checking on it.
   bool isDefaultInitializable() const {
-    for (unsigned i = 0, e = getNumPatternEntries(); i < e; ++i)
+    for (unsigned i : range(getNumPatternEntries()))
       if (!isDefaultInitializable(i))
         return false;
 
@@ -2210,11 +2221,25 @@ class PatternBindingDecl final : public Decl,
 
   /// Can the pattern at index i be default initialized?
   bool isDefaultInitializable(unsigned i) const;
-  
+
+  /// Does this pattern have a user-provided initializer expression?
+  bool isExplicitlyInitialized(unsigned i) const;
+
+  /// Whether the pattern entry at the given index can generate a string
+  /// representation of its initializer expression.
+  bool hasInitStringRepresentation(unsigned i) const {
+    return getPatternList()[i].hasInitStringRepresentation();
+  }
+
+  SourceLoc getEqualLoc(unsigned i) const;
+
   /// When the pattern binding contains only a single variable with no
   /// destructuring, retrieve that variable.
   VarDecl *getSingleVar() const;
 
+  /// Return the first variable initialized by the pattern at the given index.
+  VarDecl *getAnchoringVarDecl(unsigned i) const;
+
   bool isStatic() const { return Bits.PatternBindingDecl.IsStatic; }
   void setStatic(bool s) { Bits.PatternBindingDecl.IsStatic = s; }
   SourceLoc getStaticLoc() const { return StaticLoc; }
@@ -2229,6 +2254,14 @@ class PatternBindingDecl final : public Decl,
   /// Is the pattern binding entry for this variable  currently being computed?
   bool isComputingPatternBindingEntry(const VarDecl *vd) const;
 
+  /// Gets the text of the initializer expression for the pattern entry at the
+  /// given index, stripping out inactive branches of any #ifs inside the
+  /// expression.
+  StringRef getInitStringRepresentation(unsigned i,
+                                        SmallVectorImpl<char> &scratch) const {
+    return getPatternList()[i].getInitStringRepresentation(scratch);
+  }
+
   static bool classof(const Decl *D) {
     return D->getKind() == DeclKind::PatternBinding;
   }
@@ -4981,15 +5014,19 @@ class VarDecl : public AbstractStorageDecl {
   /// binding has no initial value, this returns null.
   ///
   Expr *getParentInitializer() const {
-    if (auto *PBD = getParentPatternBinding())
-      return PBD->getPatternEntryForVarDecl(this).getInit();
+    if (auto *PBD = getParentPatternBinding()) {
+      const auto i = PBD->getPatternEntryIndexForVarDecl(this);
+      return PBD->getInit(i);
+    }
     return nullptr;
   }
 
   /// Whether there exists an initializer for this \c VarDecl.
   bool isParentInitialized() const {
-    if (auto *PBD = getParentPatternBinding())
-      return PBD->getPatternEntryForVarDecl(this).isInitialized();
+    if (auto *PBD = getParentPatternBinding()) {
+      const auto i = PBD->getPatternEntryIndexForVarDecl(this);
+      return PBD->isInitialized(i);
+    }
     return false;
   }
 

lib/AST/ASTDumper.cpp

@@ -895,20 +895,20 @@ namespace {
     void visitPatternBindingDecl(PatternBindingDecl *PBD) {
       printCommon(PBD, "pattern_binding_decl");
 
-      for (auto entry : PBD->getPatternList()) {
+      for (auto idx : range(PBD->getNumPatternEntries())) {
         OS << '\n';
-        printRec(entry.getPattern());
-        if (entry.getOriginalInit()) {
+        printRec(PBD->getPattern(idx));
+        if (PBD->getOriginalInit(idx)) {
           OS << '\n';
           OS.indent(Indent + 2);
           OS << "Original init:\n";
-          printRec(entry.getOriginalInit());
+          printRec(PBD->getOriginalInit(idx));
         }
-        if (entry.getInit()) {
+        if (PBD->getInit(idx)) {
           OS << '\n';
           OS.indent(Indent + 2);
           OS << "Processed init:\n";
-          printRec(entry.getInit());
+          printRec(PBD->getInit(idx));
         }
       }
       PrintWithColorRAII(OS, ParenthesisColor) << ')';

lib/AST/ASTMangler.cpp

@@ -1606,8 +1606,8 @@ namespace {
 /// least one name, which is probably a reasonable assumption but may
 /// not be adequately enforced.
 static Optional<VarDecl*> findFirstVariable(PatternBindingDecl *binding) {
-  for (auto entry : binding->getPatternList()) {
-    auto var = FindFirstVariable().visit(entry.getPattern());
+  for (auto idx : range(binding->getNumPatternEntries())) {
+    auto var = FindFirstVariable().visit(binding->getPattern(idx));
     if (var) return var;
   }
   // Pattern-binding bound without variables exists in erroneous code, e.g.

lib/AST/ASTPrinter.cpp

@@ -1665,8 +1665,8 @@ bool ShouldPrintChecker::shouldPrint(const Decl *D,
   // attributes can only be retrieved from the inside VarDecls.
   if (auto *PD = dyn_cast<PatternBindingDecl>(D)) {
     auto ShouldPrint = false;
-    for (auto entry : PD->getPatternList()) {
-      ShouldPrint |= shouldPrint(entry.getPattern(), Options);
+    for (auto idx : range(PD->getNumPatternEntries())) {
+      ShouldPrint |= shouldPrint(PD->getPattern(idx), Options);
       if (ShouldPrint)
         return true;
     }
@@ -2162,8 +2162,8 @@ void PrintAST::visitPatternBindingDecl(PatternBindingDecl *decl) {
   // variables are immutable, and if so, we print as 'let'.  This allows us to
   // handle the 'let x = 4' case properly at least.
   const VarDecl *anyVar = nullptr;
-  for (auto entry : decl->getPatternList()) {
-    entry.getPattern()->forEachVariable([&](VarDecl *V) {
+  for (auto idx : range(decl->getNumPatternEntries())) {
+    decl->getPattern(idx)->forEachVariable([&](VarDecl *V) {
       anyVar = V;
     });
     if (anyVar) break;
@@ -2190,29 +2190,29 @@ void PrintAST::visitPatternBindingDecl(PatternBindingDecl *decl) {
   }
 
   bool isFirst = true;
-  for (auto &entry : decl->getPatternList()) {
-    if (!shouldPrintPattern(entry.getPattern()))
+  for (auto idx : range(decl->getNumPatternEntries())) {
+    auto *pattern = decl->getPattern(idx);
+    if (!shouldPrintPattern(pattern))
       continue;
     if (isFirst)
       isFirst = false;
     else
       Printer << ", ";
 
-    printPattern(entry.getPattern());
+    printPattern(pattern);
 
     // We also try to print type for named patterns, e.g. var Field = 10;
     // and tuple patterns, e.g. var (T1, T2) = (10, 10)
-    if (isa<NamedPattern>(entry.getPattern()) ||
-        isa<TuplePattern>(entry.getPattern())) {
-      printPatternType(entry.getPattern());
+    if (isa<NamedPattern>(pattern) || isa<TuplePattern>(pattern)) {
+      printPatternType(pattern);
     }
 
     if (Options.VarInitializers) {
-      auto vd = entry.getAnchoringVarDecl();
-      if (entry.hasInitStringRepresentation() &&
+      auto *vd = decl->getAnchoringVarDecl(idx);
+      if (decl->hasInitStringRepresentation(idx) &&
           vd->isInitExposedToClients()) {
         SmallString<128> scratch;
-        Printer << " = " << entry.getInitStringRepresentation(scratch);
+        Printer << " = " << decl->getInitStringRepresentation(idx, scratch);
       }
     }
 
@@ -3401,7 +3401,7 @@ bool Decl::shouldPrintInContext(const PrintOptions &PO) const {
     if (auto pbd = dyn_cast<PatternBindingDecl>(this)) {
       if (pbd->getPatternList().size() == 1) {
         auto pattern =
-          pbd->getPatternList()[0].getPattern()->getSemanticsProvidingPattern();
+          pbd->getPattern(0)->getSemanticsProvidingPattern();
         if (auto named = dyn_cast<NamedPattern>(pattern)) {
           if (!named->getDecl()->hasStorage())
             return false;

lib/AST/ASTScope.cpp

@@ -190,10 +190,7 @@ NullablePtr<DeclContext> CaptureListScope::getDeclContext() const {
 }
 
 NullablePtr<DeclContext> AttachedPropertyWrapperScope::getDeclContext() const {
-  return decl->getParentPatternBinding()
-      ->getPatternList()
-      .front()
-      .getInitContext();
+  return decl->getParentPatternBinding()->getInitContext(0);
 }
 
 NullablePtr<DeclContext> AbstractFunctionDeclScope::getDeclContext() const {

lib/AST/ASTScopeCreation.cpp

@@ -920,16 +920,15 @@ class NodeAdder
         isInTypeDecl ? DeclVisibilityKind::MemberOfCurrentNominal
                      : DeclVisibilityKind::LocalVariable;
     auto *insertionPoint = parentScope;
-    for (unsigned i = 0; i < patternBinding->getPatternList().size(); ++i) {
+    for (auto i : range(patternBinding->getNumPatternEntries())) {
       // TODO: Won't need to do so much work to avoid creating one without
       // a SourceRange once parser is fixed to not create two
       // PatternBindingDecls with same locaiton and getSourceRangeOfThisASTNode
       // for PatternEntryDeclScope is simplified to use the PatternEntry's
       // source range.
-      auto &patternEntry = patternBinding->getPatternList()[i];
-      if (!patternEntry.getOriginalInit()) {
+      if (!patternBinding->getOriginalInit(i)) {
         bool found = false;
-        patternEntry.getPattern()->forEachVariable([&](VarDecl *vd) {
+        patternBinding->getPattern(i)->forEachVariable([&](VarDecl *vd) {
           if (!vd->isImplicit())
             found = true;
           else
@@ -1913,27 +1912,22 @@ bool TopLevelCodeScope::isCurrentIfWasExpanded() const {
 // Try to avoid the work of counting
 static const bool assumeVarsDoNotGetAdded = true;
 
-static unsigned countVars(const PatternBindingEntry &entry) {
-  unsigned varCount = 0;
-  entry.getPattern()->forEachVariable([&](VarDecl *) { ++varCount; });
-  return varCount;
-}
-
 void PatternEntryDeclScope::beCurrent() {
   initWhenLastExpanded = getPatternEntry().getOriginalInit();
   if (assumeVarsDoNotGetAdded && varCountWhenLastExpanded)
     return;
-  varCountWhenLastExpanded = countVars(getPatternEntry());
+  varCountWhenLastExpanded = getPatternEntry().getNumBoundVariables();
 }
 bool PatternEntryDeclScope::isCurrentIfWasExpanded() const {
   if (initWhenLastExpanded != getPatternEntry().getOriginalInit())
     return false;
   if (assumeVarsDoNotGetAdded && varCountWhenLastExpanded) {
-    ASTScopeAssert(varCountWhenLastExpanded == countVars(getPatternEntry()),
+    ASTScopeAssert(varCountWhenLastExpanded ==
+                       getPatternEntry().getNumBoundVariables(),
                    "Vars were not supposed to be added to a pattern entry.");
     return true;
   }
-  return countVars(getPatternEntry()) == varCountWhenLastExpanded;
+  return getPatternEntry().getNumBoundVariables() == varCountWhenLastExpanded;
 }
 
 void WholeClosureScope::beCurrent() {
@@ -2060,8 +2054,8 @@ class LocalizableDeclContextCollector : public ASTWalker {
   }
 
   void recordInitializers(PatternBindingDecl *pbd) {
-    for (auto entry : pbd->getPatternList())
-      record(entry.getInitContext());
+    for (auto idx : range(pbd->getNumPatternEntries()))
+      record(pbd->getInitContext(idx));
   }
 
   void catchForDebugging(Decl *D, const char *file, const unsigned line) {

lib/AST/ASTScopeLookup.cpp

@@ -457,7 +457,7 @@ bool PatternEntryInitializerScope::lookupLocalsOrMembers(
     ArrayRef<const ASTScopeImpl *>, DeclConsumer consumer) const {
   // 'self' is available within the pattern initializer of a 'lazy' variable.
   auto *initContext = cast_or_null<PatternBindingInitializer>(
-      decl->getPatternList()[0].getInitContext());
+      decl->getInitContext(0));
   if (initContext) {
     if (auto *selfParam = initContext->getImplicitSelfDecl()) {
       return consumer.consume({selfParam},

lib/AST/ASTVerifier.cpp

@@ -2357,8 +2357,8 @@ class Verifier : public ASTWalker {
 
     void verifyChecked(PatternBindingDecl *binding) {
       // Look at all of the VarDecls being bound.
-      for (auto entry : binding->getPatternList())
-        if (auto *P = entry.getPattern())
+      for (auto idx : range(binding->getNumPatternEntries()))
+        if (auto *P = binding->getPattern(idx))
           P->forEachVariable([&](VarDecl *VD) {
             // ParamDecls never get PBD's.
             assert(!isa<ParamDecl>(VD) && "ParamDecl has a PatternBindingDecl?");

lib/AST/ASTWalker.cpp

@@ -171,21 +171,19 @@ class Traversal : public ASTVisitor<Traversal, Expr*, Stmt*,
         singleVar->getOriginalWrappedProperty() != nullptr;
     }
 
-    unsigned idx = 0U-1;
-    for (auto entry : PBD->getPatternList()) {
-      ++idx;
-      if (Pattern *Pat = doIt(entry.getPattern()))
-        PBD->setPattern(idx, Pat, entry.getInitContext());
+    for (auto idx : range(PBD->getNumPatternEntries())) {
+      if (Pattern *Pat = doIt(PBD->getPattern(idx)))
+        PBD->setPattern(idx, Pat, PBD->getInitContext(idx));
       else
         return true;
-      if (entry.getInit() &&
+      if (PBD->getInit(idx) &&
           !isPropertyWrapperBackingProperty &&
-          (!entry.isInitializerSubsumed() ||
+          (!PBD->isInitializerSubsumed(idx) ||
            Walker.shouldWalkIntoLazyInitializers())) {
 #ifndef NDEBUG
         PrettyStackTraceDecl debugStack("walking into initializer for", PBD);
 #endif
-        if (Expr *E2 = doIt(entry.getInit()))
+        if (Expr *E2 = doIt(PBD->getInit(idx)))
           PBD->setInit(idx, E2);
         else
           return true;