WIP unfmt

Author: David Ungar

include/swift/AST/ASTScope.h

@@ -71,7 +71,6 @@ class ASTScopeImpl;
 class GenericTypeOrExtensionScope;
 class IterableTypeScope;
 class TypeAliasScope;
-class StatementConditionElementPatternScope;
 class ScopeCreator;
 
 #pragma mark the root ASTScopeImpl class
@@ -262,7 +261,6 @@ class ASTScopeImpl {
 
   bool isATypeDeclScope() const;
 
-  virtual ASTScopeImpl *getStatementConditionIfAny();
 
 #pragma mark - - creation queries
 protected:
@@ -1012,15 +1010,15 @@ class ConditionalClauseScope final : public ASTScopeImpl {
   /// The index of the conditional clause.
   const unsigned index;
 
-  /// The statement after the conditions: body or then.
-  Stmt *const stmtAfterAllConditions;
+  const SourceLoc useScopeStart;
 
-  NullablePtr<ASTScopeImpl> statementConditionElementPatternScope;
+  /// If I have a let ..., this holds the pattern
+  NullablePtr<Pattern> pattern;
 
   ConditionalClauseScope(LabeledConditionalStmt *enclosingStmt, unsigned index,
-                         Stmt *stmtAfterAllConditions)
+                         SourceLoc useScopeStart)
       : enclosingStmt(enclosingStmt), index(index),
-        stmtAfterAllConditions(stmtAfterAllConditions) {}
+        useScopeStart(useScopeStart) {}
   virtual ~ConditionalClauseScope() {}
 
   ASTScopeImpl *expandMe(ScopeCreator &scopeCreator) override;
@@ -1038,11 +1036,6 @@ class ConditionalClauseScope final : public ASTScopeImpl {
   NullablePtr<const void> addressForPrinting() const override {
     return enclosingStmt;
   }
-  void createSubtreeForCondition(ScopeCreator &);
-  SourceLoc startLocAccordingToCondition() const;
-
-  ASTScopeImpl *getStatementConditionIfAny() override;
-
   SourceRange getChildlessSourceRange() const override;
 };
 
@@ -1051,11 +1044,11 @@ class ConditionalClauseScope final : public ASTScopeImpl {
 /// the normal lookup rule to pass the lookup scope into the deepest conditional
 /// clause.
 class ConditionalClauseUseScope final : public ASTScopeImpl {
-  ASTScopeImpl *const lookupParent;
+  ConditionalClauseScope *const lookupParent;
   const SourceLoc startLoc;
 
 public:
-  ConditionalClauseUseScope(ASTScopeImpl *lookupParent, SourceLoc startLoc)
+  ConditionalClauseUseScope(ConditionalClauseScope *lookupParent, SourceLoc startLoc)
       : lookupParent(lookupParent), startLoc(startLoc) {}
 
   SourceRange getChildlessSourceRange() const override;
@@ -1064,42 +1057,14 @@ class ConditionalClauseUseScope final : public ASTScopeImpl {
   ASTScopeImpl *expandMe(ScopeCreator &) override;
 
 protected:
+ bool lookupLocalBindings(Optional<bool>, DeclConsumer) const override;
+ 
   void printSpecifics(llvm::raw_ostream &out) const override;
   NullablePtr<const ASTScopeImpl> getLookupParent() const override {
     return lookupParent;
   }
 };
 
-/// Within a ConditionalClauseScope, there may be a pattern binding
-/// StmtConditionElement. If so, it splits the scope into two scopes: one
-/// containing the definitions and the other containing the initializer. We must
-/// split it because the initializer must not be in scope of the definitions:
-/// e.g.: if let a = a {}
-/// We need to be able to lookup either a and the second a must not bind to the
-/// first one. This scope represents the scope of the variable being
-/// initialized.
-class StatementConditionElementPatternScope final : public ASTScopeImpl {
-public:
-  Pattern *const pattern;
-  StatementConditionElementPatternScope(Pattern *e) : pattern(e) {}
-  virtual ~StatementConditionElementPatternScope() {}
-
-  std::string getClassName() const override;
-  SourceRange getChildlessSourceRange() const override;
-
-  ASTScopeImpl *expandMe(ScopeCreator &) override;
-
-protected:
-  void printSpecifics(llvm::raw_ostream &out) const override;
-
-public:
-  NullablePtr<const void> addressForPrinting() const override {
-    return pattern;
-  }
-
-protected:
-  bool lookupLocalBindings(Optional<bool>, DeclConsumer) const override;
-};
 
 /// Capture lists may contain initializer expressions
 /// No local bindings here (other than closures in initializers);
@@ -1336,7 +1301,7 @@ class LabeledConditionalStmtScope : public AbstractStmtScope {
 
 protected:
   /// Return the lookupParent required to search these.
-  ASTScopeImpl *createCondScopes(ScopeCreator &);
+  ASTScopeImpl *createNestedConditionalClauseScopes(ScopeCreator &, SourceLoc lastUseScopeStart);
   virtual Stmt *getStmtAfterTheConditions() const = 0;
 };
 

lib/AST/ASTScope.cpp

@@ -204,7 +204,6 @@ DEFINE_GET_CLASS_NAME(PatternEntryInitializerScope)
 DEFINE_GET_CLASS_NAME(PatternEntryUseScope)
 DEFINE_GET_CLASS_NAME(ConditionalClauseScope)
 DEFINE_GET_CLASS_NAME(ConditionalClauseUseScope)
-DEFINE_GET_CLASS_NAME(StatementConditionElementPatternScope)
 DEFINE_GET_CLASS_NAME(CaptureListScope)
 DEFINE_GET_CLASS_NAME(WholeClosureScope)
 DEFINE_GET_CLASS_NAME(ClosureParametersScope)

lib/AST/ASTScopeCreation.cpp

@@ -610,6 +610,7 @@ NO_EXPANSION(GenericParamScope)
 NO_EXPANSION(ASTSourceFileScope)
 NO_EXPANSION(ClosureParametersScope)
 NO_EXPANSION(SpecializeAttributeScope)
+// no accessors, unlike PatternEntryUseScope
 NO_EXPANSION(ConditionalClauseUseScope)
 NO_EXPANSION(AttachedPropertyWrapperScope)
 NO_EXPANSION(StatementConditionElementPatternScope)
@@ -673,14 +674,27 @@ ASTScopeImpl *PatternEntryUseScope::expandAScopeThatCreatesANewInsertionPoint(
 }
 
 ASTScopeImpl *ConditionalClauseScope::expandAScopeThatCreatesANewInsertionPoint(
-    ScopeCreator &scopeCreator) {
-  createSubtreeForCondition(scopeCreator);
-  return this;
+                                                                                ScopeCreator &scopeCreator) {
+  const auto &cond = enclosingStmt->getCond()[index];
+  switch (cond.getKind()) {
+    case StmtConditionElement::CK_Availability:
+      return this;
+    case StmtConditionElement::CK_Boolean:
+      ASTVisitorForScopeCreation().visitExpr(cond.getBoolean(), this,
+                                             scopeCreator);
+      return this;
+    case StmtConditionElement::CK_PatternBinding:
+      pattern = cond.getPattern());
+      ASTVisitorForScopeCreation().visitExpr(cond.getInitializer(), this,
+                                             scopeCreator);
+      return scopeCreator.createSubtree<ConditionalClauseUseScope>(this, this, cond.getEndLoc());
+  }
 }
 
 ASTScopeImpl *GuardStmtScope::expandAScopeThatCreatesANewInsertionPoint(
     ScopeCreator &scopeCreator) {
-  ASTScopeImpl *lookupParent = createCondScopes(scopeCreator);
+  
+  ASTScopeImpl *lookupParent = createNestedConditionalClauseScopes(scopeCreator, stmt->getBody()->getEndLoc();
   // Add a child for the 'guard' body, which always exits.
   // Parent is whole guard stmt scope, NOT the cond scopes
   scopeCreator.createScopeFor(stmt->getBody(), this);
@@ -746,19 +760,19 @@ void AbstractFunctionBodyScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
 
 void IfStmtScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
     ScopeCreator &scopeCreator) {
-  ASTScopeImpl *lookupParent = createCondScopes(scopeCreator);
+  ASTScopeImpl *insertionPoint = createNestedConditionalClauseScopes(scopeCreator, stmt->getThenStmt()->getStartLoc());
 
   // The 'then' branch
-  scopeCreator.createScopeFor(stmt->getThenStmt(), lookupParent);
+  scopeCreator.createScopeFor(stmt->getThenStmt(), insertionPoint);
 
   // Add the 'else' branch, if needed.
   scopeCreator.createScopeFor(stmt->getElseStmt(), this);
 }
 
 void WhileStmtScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
     ScopeCreator &scopeCreator) {
-  ASTScopeImpl *lookupParent = createCondScopes(scopeCreator);
-  scopeCreator.createScopeFor(stmt->getBody(), lookupParent);
+  ASTScopeImpl *insertionPoint = createNestedConditionalClauseScopes(scopeCreator, stmt->getBody()->getStartLoc());
+  scopeCreator.createScopeFor(stmt->getBody(), insertionPoint);
 }
 
 void RepeatWhileScope::expandAScopeThatDoesNotCreateANewInsertionPoint(
@@ -964,21 +978,16 @@ TypeAliasScope::createTrailingWhereClauseScope(ASTScopeImpl *parent,
 #pragma mark misc
 
 ASTScopeImpl *
-LabeledConditionalStmtScope::createCondScopes(ScopeCreator &scopeCreator) {
+LabeledConditionalStmtScope::createNestedConditionalClauseScopes(ScopeCreator &scopeCreator, SourceLoc lastUseScopeStart) {
   auto *stmt = getLabeledConditionalStmt();
   ASTScopeImpl *insertionPoint = this;
-  for (unsigned i = 0; i < stmt->getCond().size(); ++i)
+  for (unsigned i = 0; i < stmt->getCond().size(); ++i) {
+    // If cond has a pattern, it needs to know where to start the use scope
+    const SourceLoc useScopeStart = i + 1 < stmt->getCond().size() ? stmt->getCond()[i+1].getStartLoc() : lastUseStart;
     insertionPoint = scopeCreator.createSubtree<ConditionalClauseScope>(
-        insertionPoint, stmt, i, getStmtAfterTheConditions());
-  return insertionPoint->getStatementConditionIfAny();
-}
-
-ASTScopeImpl *ASTScopeImpl::getStatementConditionIfAny() { return this; }
-
-ASTScopeImpl *ConditionalClauseScope::getStatementConditionIfAny() {
-  return statementConditionElementPatternScope
-             ? statementConditionElementPatternScope.get()
-             : this;
+        insertionPoint, stmt, i, useScopeStart);
+  }
+  return insertionPoint;
 }
 
 AbstractPatternEntryScope::AbstractPatternEntryScope(
@@ -1002,27 +1011,6 @@ void AbstractPatternEntryScope::forEachVarDeclWithExplicitAccessors(
   });
 }
 
-
-void ConditionalClauseScope::createSubtreeForCondition(
-    ScopeCreator &scopeCreator) {
-  const auto &cond = enclosingStmt->getCond()[index];
-  switch (cond.getKind()) {
-  case StmtConditionElement::CK_Availability:
-    return;
-  case StmtConditionElement::CK_Boolean:
-    ASTVisitorForScopeCreation().visitExpr(cond.getBoolean(), this,
-                                           scopeCreator);
-    return;
-  case StmtConditionElement::CK_PatternBinding:
-    statementConditionElementPatternScope =
-        scopeCreator.createSubtree<StatementConditionElementPatternScope>(
-            this, cond.getPattern());
-    ASTVisitorForScopeCreation().visitExpr(cond.getInitializer(), this,
-                                           scopeCreator);
-    return;
-  }
-}
-
 bool AbstractPatternEntryScope::isLastEntry() const {
   return patternEntryIndex + 1 == decl->getPatternList().size();
 }

lib/AST/ASTScopeLookup.cpp

@@ -342,6 +342,7 @@ bool PatternEntryUseScope::lookupLocalBindings(Optional<bool> isCascadingUse,
                                       consumer);
 }
 
+#error use scope stuff here
 bool StatementConditionElementPatternScope::lookupLocalBindings(
     Optional<bool> isCascadingUse, DeclConsumer consumer) const {
   return lookupLocalBindingsInPattern(
@@ -468,6 +469,13 @@ bool ClosureParametersScope::lookupLocalBindings(Optional<bool> isCascadingUse,
   return false;
 }
 
+bool ConditionalClauseUseScope::lookupLocalBindings(Optional<bool> isCascadingUse, DeclConsumer consumer) const {
+  if (auto *pattern = lookupParent->pattern.getPtrOrNull()) {
+    return lookupLocalBindingsInPattern(pattern, isCascadingUse, DeclVisibilityKind::LocalVariable, consumer);
+  }
+  return false;
+}
+
 bool ASTScopeImpl::lookupLocalBindingsInPattern(Pattern *p,
                                                 Optional<bool> isCascadingUse,
                                                 DeclVisibilityKind vis,

lib/AST/ASTScopePrinting.cpp

@@ -167,7 +167,7 @@ void AbstractPatternEntryScope::printSpecifics(llvm::raw_ostream &out) const {
   });
 }
 
-
+#error ruse scope
 void StatementConditionElementPatternScope::printSpecifics(
     llvm::raw_ostream &out) const {
   pattern->print(out);
@@ -178,9 +178,6 @@ void ConditionalClauseScope::printSpecifics(llvm::raw_ostream &out) const {
   out << " in ";
   printSourceRange(out, enclosingStmt->getSourceRange(), getSourceManager());
   out << " index " << index;
-  out << " before ";
-  printSourceRange(out, stmtAfterAllConditions->getSourceRange(),
-                   getSourceManager());
   out << "  ";
 }
 

lib/AST/ASTScopeSourceRange.cpp

@@ -159,10 +159,6 @@ SourceRange AbstractFunctionBodyScope::getChildlessSourceRange() const {
   return decl->getBodySourceRange();
 }
 
-SourceRange
-StatementConditionElementPatternScope::getChildlessSourceRange() const {
-  return pattern->getSourceRange();
-}
 
 SourceRange TopLevelCodeScope::getChildlessSourceRange() const {
   return decl->getSourceRange();
@@ -349,26 +345,12 @@ SourceRange BraceStmtScope::getChildlessSourceRange() const {
   return stmt->getSourceRange();
 }
 
-SourceLoc ConditionalClauseScope::startLocAccordingToCondition() const {
-  // Determine the start location if the condition can provide it.
-  auto conditionals = enclosingStmt->getCond();
-  const StmtConditionElement cond = conditionals[index];
-  switch (cond.getKind()) {
-  case StmtConditionElement::CK_Boolean:
-  case StmtConditionElement::CK_Availability:
-    return cond.getStartLoc();
-  case StmtConditionElement::CK_PatternBinding:
-    return index + 1 < conditionals.size()
-               ? conditionals[index + 1].getStartLoc()
-               : SourceLoc();
-  }
-}
 
 SourceRange ConditionalClauseScope::getChildlessSourceRange() const {
   // From the start of this particular condition to the start of the
   // then/body part.
-  const auto startLoc = startLocAccordingToCondition();
-  const auto endLoc = stmtAfterAllConditions->getStartLoc();
+  const auto startLoc = enclosingStmt->getCond()[index].getStartLoc();
+  const auto endLoc = useScopeStart;
   return startLoc.isValid() ? SourceRange(startLoc, endLoc)
                             : SourceRange(endLoc);
 }