Remove Cascading Computations from ASTScope

CodaFi · CodaFi · commit d93c6d8b1255 · 2020-09-21T10:42:33.000-06:00
diff --git a/include/swift/AST/ASTScope.h b/include/swift/AST/ASTScope.h
@@ -417,10 +417,6 @@ class ASTScopeImpl {
   static llvm::SmallVector<LabeledStmt *, 4>
   lookupLabeledStmts(SourceFile *sourceFile, SourceLoc loc);
 
-  static Optional<bool>
-  computeIsCascadingUse(ArrayRef<const ASTScopeImpl *> history,
-                        Optional<bool> initialIsCascadingUse);
-
   static std::pair<CaseStmt *, CaseStmt *>
   lookupFallthroughSourceAndDest(SourceFile *sourceFile, SourceLoc loc);
 
@@ -448,7 +444,6 @@ class ASTScopeImpl {
   /// The main (recursive) lookup function:
   /// Tell DeclConsumer about all names found in this scope and if not done,
   /// recurse for enclosing scopes. Stop lookup if about to look in limit.
-  /// Return final value for isCascadingUse
   ///
   /// If the lookup depends on implicit self, selfDC is its context.
   /// (Names in extensions never depend on self.)
@@ -508,9 +503,6 @@ class ASTScopeImpl {
 
 #pragma mark - - lookup- local bindings
 protected:
-  virtual Optional<bool>
-  resolveIsCascadingUseForThisScope(Optional<bool>) const;
-
   // A local binding is a basically a local variable defined in that very scope
   // It is not an instance variable or inherited type.
 
@@ -611,11 +603,11 @@ class Portion {
   virtual ASTScopeImpl *expandScope(GenericTypeOrExtensionScope *,
                                     ScopeCreator &) const = 0;
 
+  /// \Returns \c true if this lookup is done looking for results, else \c false.
   virtual SourceRange
   getChildlessSourceRangeOf(const GenericTypeOrExtensionScope *scope,
                             bool omitAssertions) const = 0;
 
-  /// Returns isDone and isCascadingUse
   virtual bool lookupMembersOf(const GenericTypeOrExtensionScope *scope,
                                ArrayRef<const ASTScopeImpl *>,
                                ASTScopeImpl::DeclConsumer consumer) const;
@@ -780,10 +772,6 @@ class GenericTypeOrExtensionScope : public ASTScopeImpl {
   virtual bool doesDeclHaveABody() const;
   const char *portionName() const { return portion->portionName; }
 
-protected:
-  Optional<bool> resolveIsCascadingUseForThisScope(
-      Optional<bool> isCascadingUse) const override;
-
 public:
   // Only for DeclScope, not BodyScope
   // Returns the where clause scope, or the parent if none
@@ -969,8 +957,7 @@ class GenericParamScope final : public ASTScopeImpl {
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
                              DeclConsumer) const override;
-  Optional<bool>
-  resolveIsCascadingUseForThisScope(Optional<bool>) const override;
+  bool doesContextMatchStartingContext(const DeclContext *) const override;
 };
 
 /// Concrete class for a function/initializer/deinitializer
@@ -1014,9 +1001,6 @@ class AbstractFunctionDeclScope final : public ASTScopeImpl {
 
 protected:
   NullablePtr<const GenericParamList> genericParams() const override;
-
-  Optional<bool>
-  resolveIsCascadingUseForThisScope(Optional<bool>) const override;
 };
 
 /// The parameters for an abstract function (init/func/deinit)., subscript, and
@@ -1087,8 +1071,6 @@ class AbstractFunctionBodyScope : public ASTScopeImpl {
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
                              DeclConsumer) const override;
-  Optional<bool>
-  resolveIsCascadingUseForThisScope(Optional<bool>) const override;
 
 public:
   NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
@@ -1123,10 +1105,6 @@ class DefaultArgumentInitializerScope final : public ASTScopeImpl {
   virtual NullablePtr<DeclContext> getDeclContext() const override;
   virtual NullablePtr<Decl> getDeclIfAny() const override { return decl; }
   Decl *getDecl() const { return decl; }
-
-protected:
-  Optional<bool>
-  resolveIsCascadingUseForThisScope(Optional<bool>) const override;
 };
 
 /// Consider:
@@ -1274,9 +1252,6 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
                              DeclConsumer) const override;
-
-  Optional<bool>
-  resolveIsCascadingUseForThisScope(Optional<bool>) const override;
 };
 
 /// The scope introduced by a conditional clause in an if/guard/while
@@ -1392,6 +1367,42 @@ class ClosureParametersScope final : public ASTScopeImpl {
   NullablePtr<Expr> getExprIfAny() const override { return closureExpr; }
   Expr *getExpr() const { return closureExpr; }
   NullablePtr<const void> getReferrent() const override;
+};
+
+/// For a closure with named parameters, this scope does the local bindings.
+/// Absent if no "in".
+class ClosureParametersScope final : public AbstractClosureScope {
+public:
+  ClosureParametersScope(ClosureExpr *closureExpr,
+                         NullablePtr<CaptureListExpr> captureList)
+      : AbstractClosureScope(closureExpr, captureList) {}
+  virtual ~ClosureParametersScope() {}
+
+  std::string getClassName() const override;
+  SourceRange
+  getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
+  
+  /// Since explicit captures of \c self by closures enable the use of implicit
+  /// \c self, we need to make sure that the appropriate \c self is used as the
+  /// base decl for these uses (otherwise, the capture would be marked as
+  /// unused. \c ClosureParametersScope::capturedSelfDC() checks if we have such
+  ///  a capture of self.
+  NullablePtr<DeclContext> capturedSelfDC() const override;
+
+protected:
+  ASTScopeImpl *expandSpecifically(ScopeCreator &) override;
+  bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
+                             DeclConsumer) const override;
+};
+
+// The body encompasses the code in the closure; the part after the "in" if
+// there is an "in"
+class ClosureBodyScope final : public AbstractClosureScope {
+public:
+  ClosureBodyScope(ClosureExpr *closureExpr,
+                   NullablePtr<CaptureListExpr> captureList)
+      : AbstractClosureScope(closureExpr, captureList) {}
+  virtual ~ClosureBodyScope() {}
 
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
@@ -1402,8 +1413,10 @@ class ClosureParametersScope final : public ASTScopeImpl {
 protected:
   bool lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
                              DeclConsumer) const override;
-  Optional<bool> resolveIsCascadingUseForThisScope(
-      Optional<bool> isCascadingUse) const override;
+public:
+  std::string getClassName() const override;
+  SourceRange
+  getSourceRangeOfThisASTNode(bool omitAssertions = false) const override;
 };
 
 class TopLevelCodeScope final : public ASTScopeImpl {
diff --git a/include/swift/AST/NameLookup.h b/include/swift/AST/NameLookup.h
@@ -505,9 +505,6 @@ template <typename Result>
 void filterForDiscriminator(SmallVectorImpl<Result> &results,
                             DebuggerClient *debugClient);
 
-void recordLookupOfTopLevelName(DeclContext *topLevelContext, DeclName name,
-                                bool isCascading);
-
 } // end namespace namelookup
 
 /// Retrieve the set of nominal type declarations that are directly
@@ -632,8 +629,7 @@ class AbstractASTScopeDeclConsumer {
   /// Eventually this functionality should move into ASTScopeLookup
   virtual bool
   lookInMembers(DeclContext *const scopeDC,
-                NominalTypeDecl *const nominal,
-                function_ref<bool(Optional<bool>)> calculateIsCascadingUse) = 0;
+                NominalTypeDecl *const nominal) = 0;
 
 #ifndef NDEBUG
   virtual void startingNextLookupStep() = 0;
@@ -655,8 +651,7 @@ class ASTScopeDeclGatherer : public AbstractASTScopeDeclConsumer {
 
   /// Eventually this functionality should move into ASTScopeLookup
   bool lookInMembers(DeclContext *const,
-                     NominalTypeDecl *const,
-                     function_ref<bool(Optional<bool>)>) override {
+                     NominalTypeDecl *const) override {
     return false;
   }
 
@@ -691,10 +686,6 @@ class ASTScope {
   unqualifiedLookup(SourceFile *, DeclNameRef, SourceLoc,
                     namelookup::AbstractASTScopeDeclConsumer &);
 
-  static Optional<bool>
-  computeIsCascadingUse(ArrayRef<const ast_scope::ASTScopeImpl *> history,
-                        Optional<bool> initialIsCascadingUse);
-
   /// Entry point to record the visible statement labels from the given
   /// point.
   ///
diff --git a/lib/AST/ASTScope.cpp b/lib/AST/ASTScope.cpp
@@ -46,12 +46,6 @@ llvm::SmallVector<const ASTScopeImpl *, 0> ASTScope::unqualifiedLookup(
   return ASTScopeImpl::unqualifiedLookup(SF, name, loc, consumer);
 }
 
-Optional<bool> ASTScope::computeIsCascadingUse(
-    ArrayRef<const ast_scope::ASTScopeImpl *> history,
-    Optional<bool> initialIsCascadingUse) {
-  return ASTScopeImpl::computeIsCascadingUse(history, initialIsCascadingUse);
-}
-
 llvm::SmallVector<LabeledStmt *, 4> ASTScope::lookupLabeledStmts(
     SourceFile *sourceFile, SourceLoc loc) {
   return ASTScopeImpl::lookupLabeledStmts(sourceFile, loc);
diff --git a/lib/AST/ASTScopeLookup.cpp b/lib/AST/ASTScopeLookup.cpp
@@ -246,8 +246,6 @@ bool ASTScopeImpl::lookupLocalsOrMembers(ArrayRef<const ASTScopeImpl *>,
 bool GenericTypeOrExtensionScope::lookupLocalsOrMembers(
     ArrayRef<const ASTScopeImpl *> history,
     ASTScopeImpl::DeclConsumer consumer) const {
-  // isCascadingUseArg must have already been resolved, for a real lookup
-  // but may be \c None for dumping.
   return portion->lookupMembersOf(this, history, consumer);
 }
 
@@ -264,12 +262,7 @@ bool GenericTypeOrExtensionWhereOrBodyPortion::lookupMembersOf(
   auto nt = scope->getCorrespondingNominalTypeDecl().getPtrOrNull();
   if (!nt)
     return false;
-  return consumer.lookInMembers(scope->getDeclContext().get(), nt,
-                                [&](Optional<bool> initialIsCascadingUse) {
-                                  return ASTScopeImpl::computeIsCascadingUse(
-                                             history, initialIsCascadingUse)
-                                      .getValueOr(true);
-                                });
+  return consumer.lookInMembers(scope->getDeclContext().get(), nt);
 }
 
 bool GenericTypeOrExtensionWherePortion::lookupMembersOf(
@@ -455,17 +448,6 @@ bool ASTScopeImpl::lookupLocalBindingsInPattern(const Pattern *p,
   return isDone;
 }
 
-#pragma mark compute isCascadingUse
-
-Optional<bool> ASTScopeImpl::computeIsCascadingUse(
-    ArrayRef<const ASTScopeImpl *> history,
-    const Optional<bool> initialIsCascadingUse) {
-  Optional<bool> isCascadingUse = initialIsCascadingUse;
-  for (const auto *scope : history)
-    isCascadingUse = scope->resolveIsCascadingUseForThisScope(isCascadingUse);
-  return isCascadingUse;
-}
-
 #pragma mark getLookupLimit
 
 NullablePtr<const ASTScopeImpl> ASTScopeImpl::getLookupLimit() const {
@@ -523,77 +505,6 @@ NullablePtr<const ASTScopeImpl> ASTScopeImpl::ancestorWithDeclSatisfying(
   return nullptr;
 }
 
-#pragma mark ifUnknownIsCascadingUseAccordingTo
-
-static bool ifUnknownIsCascadingUseAccordingTo(Optional<bool> isCascadingUse,
-                                               const DeclContext *const dc) {
-  return isCascadingUse.getValueOr(false);
-}
-
-#pragma mark resolveIsCascadingUseForThisScope
-
-Optional<bool> ASTScopeImpl::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  return isCascadingUse;
-}
-
-Optional<bool> GenericParamScope::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  if (auto *dc = getDeclContext().getPtrOrNull())
-    return ifUnknownIsCascadingUseAccordingTo(isCascadingUse, dc);
-  ASTScope_unreachable("generic what?");
-}
-
-Optional<bool> AbstractFunctionDeclScope::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  return false;
-}
-
-Optional<bool> AbstractFunctionBodyScope::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  return false;
-}
-
-Optional<bool> GenericTypeOrExtensionScope::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  // Could override for ExtensionScope and just return true
-  return ifUnknownIsCascadingUseAccordingTo(isCascadingUse,
-                                            getDeclContext().get());
-}
-
-Optional<bool>
-DefaultArgumentInitializerScope::resolveIsCascadingUseForThisScope(
-    Optional<bool>) const {
-  return false;
-}
-
-Optional<bool> ClosureParametersScope::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  return ifUnknownIsCascadingUseAccordingTo(isCascadingUse, closureExpr);
-}
-
-Optional<bool> PatternEntryInitializerScope::resolveIsCascadingUseForThisScope(
-    Optional<bool> isCascadingUse) const {
-  auto *const initContext = getPatternEntry().getInitContext();
-  auto *PBI = dyn_cast_or_null<PatternBindingInitializer>(initContext);
-  auto *isd = PBI ? PBI->getImplicitSelfDecl() : nullptr;
-
-  // 'self' is available within the pattern initializer of a 'lazy' variable.
-  if (isd)
-    return ifUnknownIsCascadingUseAccordingTo(isCascadingUse, PBI);
-
-  // initializing stored property of a type
-  auto *const patternDeclContext = decl->getDeclContext();
-  if (patternDeclContext->isTypeContext())
-    return false;
-
-  // initializing global or local
-  if (PBI)
-    return ifUnknownIsCascadingUseAccordingTo(isCascadingUse, PBI);
-
-  return isCascadingUse;
-}
-
 #pragma mark isLabeledStmtLookupTerminator implementations
 bool ASTScopeImpl::isLabeledStmtLookupTerminator() const {
   return true;
diff --git a/lib/AST/NameLookup.cpp b/lib/AST/NameLookup.cpp
@@ -814,9 +814,8 @@ namespace {
 /// Retrieve the set of type declarations that are directly referenced from
 /// the given parsed type representation.
 static DirectlyReferencedTypeDecls
-directReferencesForTypeRepr(Evaluator &evaluator,
-                            ASTContext &ctx, TypeRepr *typeRepr,
-                            DeclContext *dc);
+directReferencesForTypeRepr(Evaluator &evaluator, ASTContext &ctx,
+                            TypeRepr *typeRepr, DeclContext *dc);
 
 /// Retrieve the set of type declarations that are directly referenced from
 /// the given type.
@@ -838,7 +837,8 @@ SelfBounds SelfBoundsFromWhereClauseRequest::evaluate(
   auto *protoDecl = dyn_cast_or_null<const ProtocolDecl>(typeDecl);
   auto *extDecl = decl.dyn_cast<const ExtensionDecl *>();
 
-  DeclContext *dc = protoDecl ? (DeclContext *)protoDecl : (DeclContext *)extDecl;
+  const DeclContext *dc =
+      protoDecl ? (const DeclContext *)protoDecl : (const DeclContext *)extDecl;
 
   // A protocol or extension 'where' clause can reference associated types of
   // the protocol itself, so we have to start unqualified lookup from 'dc'.
@@ -2192,7 +2192,7 @@ DirectlyReferencedTypeDecls InheritedDeclsReferencedRequest::evaluate(
       dc = (DeclContext *)decl.get<const ExtensionDecl *>();
 
     return directReferencesForTypeRepr(evaluator, dc->getASTContext(), typeRepr,
-                                       dc);
+                                       const_cast<DeclContext *>(dc));
   }
 
   // Fall back to semantic types.
diff --git a/lib/AST/UnqualifiedLookup.cpp b/lib/AST/UnqualifiedLookup.cpp
