ASTScope: Add finishLookupInBraceStmt parameter to ASTScope::lookupLocalDecls()

This will be used to implement re-declaration checking for local
declarations. Currently this is handled by parse-time lookup.

To make it work with ASTScope, we need to perform lookups that
look into the innermost local scope only; for example, this is
an invalid redeclaration:

do {
  let x = 321
  let x = 123
}

But the following is fine, even though both VarDecls are in the same
*DeclContext*:

do {
  let x = 321
  do {
    let x = 123
  }
}

Author: slavapestov

include/swift/AST/NameLookup.h

@@ -594,18 +594,33 @@ class AbstractASTScopeDeclConsumer {
   virtual ~AbstractASTScopeDeclConsumer() = default;
 
   /// Called for every ValueDecl visible from the lookup.
-  /// Returns true if the lookup can be stopped at this point.
-  /// BaseDC is per legacy
+  ///
   /// Takes an array in order to batch the consumption before setting
   /// IndexOfFirstOuterResult when necessary.
+  ///
+  /// \param baseDC either a type context or the local context of a
+  /// `self` parameter declaration. See LookupResult for a discussion
+  /// of type -vs- instance lookup results.
+  ///
+  /// \return true if the lookup should be stopped at this point.
   virtual bool consume(ArrayRef<ValueDecl *> values, DeclVisibilityKind vis,
                        NullablePtr<DeclContext> baseDC = nullptr) = 0;
 
-  /// Eventually this functionality should move into ASTScopeLookup
+  /// Look for members of a nominal type or extension scope.
+  ///
+  /// \return true if the lookup should be stopped at this point.
   virtual bool
   lookInMembers(DeclContext *const scopeDC,
                 NominalTypeDecl *const nominal) = 0;
 
+  /// Called right before looking at the parent scope of a BraceStmt.
+  ///
+  /// \return true if the lookup should be stopped at this point.
+  virtual bool
+  finishLookupInBraceStmt(BraceStmt *stmt) {
+    return false;
+  }
+
 #ifndef NDEBUG
   virtual void startingNextLookupStep() = 0;
   virtual void finishingLookup(std::string) const = 0;
@@ -661,7 +676,11 @@ class ASTScope {
 
   /// Lookup that only finds local declarations and does not trigger
   /// interface type computation.
+  ///
+  /// \param stopAfterInnermostBraceStmt If lookup should consider
+  /// local declarations inside the innermost syntactic scope only.
   static void lookupLocalDecls(SourceFile *, DeclName, SourceLoc,
+                               bool stopAfterInnermostBraceStmt,
                                SmallVectorImpl<ValueDecl *> &);
 
   /// Returns the result if there is exactly one, nullptr otherwise.

lib/AST/ASTScopeLookup.cpp

@@ -383,7 +383,13 @@ bool BraceStmtScope::lookupLocalsOrMembers(DeclConsumer consumer) const {
         localBindings.push_back(vd);
     }
   }
-  return consumer.consume(localBindings, DeclVisibilityKind::LocalVariable);
+  if (consumer.consume(localBindings, DeclVisibilityKind::LocalVariable))
+    return true;
+
+  if (consumer.finishLookupInBraceStmt(stmt))
+    return true;
+
+  return false;
 }
 
 bool PatternEntryInitializerScope::lookupLocalsOrMembers(

lib/AST/UnqualifiedLookup.cpp

@@ -736,13 +736,16 @@ namespace {
 
 class ASTScopeDeclConsumerForLocalLookup
     : public AbstractASTScopeDeclConsumer {
-  SmallVectorImpl<ValueDecl *> &results;
   DeclName name;
+  bool stopAfterInnermostBraceStmt;
+  SmallVectorImpl<ValueDecl *> &results;
 
 public:
   ASTScopeDeclConsumerForLocalLookup(
-      SmallVectorImpl<ValueDecl *> &results, DeclName name)
-    : results(results), name(name) {}
+      DeclName name, bool stopAfterInnermostBraceStmt,
+      SmallVectorImpl<ValueDecl *> &results)
+    : name(name), stopAfterInnermostBraceStmt(stopAfterInnermostBraceStmt),
+      results(results) {}
 
   bool consume(ArrayRef<ValueDecl *> values, DeclVisibilityKind vis,
                NullablePtr<DeclContext> baseDC) override {
@@ -753,14 +756,18 @@ class ASTScopeDeclConsumerForLocalLookup
       results.push_back(value);
     }
 
-    return !results.empty();
+    return (!stopAfterInnermostBraceStmt && !results.empty());
   }
 
   bool lookInMembers(DeclContext *const,
                      NominalTypeDecl *const) override {
     return true;
   }
 
+  bool finishLookupInBraceStmt(BraceStmt *stmt) override {
+    return stopAfterInnermostBraceStmt;
+  }
+
 #ifndef NDEBUG
   void startingNextLookupStep() override {}
   void finishingLookup(std::string) const override {}
@@ -773,15 +780,19 @@ class ASTScopeDeclConsumerForLocalLookup
 /// Lookup that only finds local declarations and does not trigger
 /// interface type computation.
 void ASTScope::lookupLocalDecls(SourceFile *sf, DeclName name, SourceLoc loc,
+                                bool stopAfterInnermostBraceStmt,
                                 SmallVectorImpl<ValueDecl *> &results) {
-  ASTScopeDeclConsumerForLocalLookup consumer(results, name);
+  ASTScopeDeclConsumerForLocalLookup consumer(name, stopAfterInnermostBraceStmt,
+                                              results);
   ASTScope::unqualifiedLookup(sf, loc, consumer);
 }
 
 ValueDecl *ASTScope::lookupSingleLocalDecl(SourceFile *sf, DeclName name,
                                            SourceLoc loc) {
   SmallVector<ValueDecl *, 1> result;
-  ASTScope::lookupLocalDecls(sf, name, loc, result);
+  ASTScope::lookupLocalDecls(sf, name, loc,
+                             /*finishLookupInBraceStmt=*/false,
+                             result);
   if (result.size() != 1)
     return nullptr;
   return result[0];