Merge pull request #35288 from slavapestov/perf-fixes-5.4

Cherry-pick compiler performance fixes [5.4]

Author: DougGregor

include/swift/AST/ASTScope.h

@@ -136,18 +136,16 @@ class ASTScopeImpl {
   /// storage declaration or is directly descended from it.
 
 private:
-  /// Always set by the constructor, so that when creating a child
-  /// the parent chain is available.
-  ASTScopeImpl *parent = nullptr; // null at the root
+  /// The pointer:
+  /// - Always set by the constructor, so that when creating a child
+  ///   the parent chain is available. Null at the root.
+  /// The int:
+  /// - A flag indicating if the scope has been expanded yet or not.
+  llvm::PointerIntPair<ASTScopeImpl *, 1> parentAndWasExpanded;
 
   /// Child scopes, sorted by source range.
   Children storedChildren;
 
-  bool wasExpanded = false;
-
-  /// Can clear storedChildren, so must remember this
-  bool haveAddedCleanup = false;
-
   mutable Optional<CharSourceRange> cachedCharSourceRange;
 
 #pragma mark - constructor / destructor
@@ -177,8 +175,12 @@ class ASTScopeImpl {
 
 #pragma mark - tree declarations
 protected:
-  NullablePtr<ASTScopeImpl> getParent() { return parent; }
-  NullablePtr<const ASTScopeImpl> getParent() const { return parent; }
+  NullablePtr<ASTScopeImpl> getParent() {
+    return parentAndWasExpanded.getPointer();
+  }
+  NullablePtr<const ASTScopeImpl> getParent() const {
+    return parentAndWasExpanded.getPointer();
+  }
 
   const Children &getChildren() const { return storedChildren; }
 
@@ -247,19 +249,13 @@ class ASTScopeImpl {
 
 #pragma mark - Scope tree creation
 public:
-  /// expandScope me, sending deferred nodes to my descendants.
-  /// Return the scope into which to place subsequent decls
-  ASTScopeImpl *expandAndBeCurrentDetectingRecursion(ScopeCreator &);
-
-  /// Expand or reexpand the scope if unexpanded or if not current.
-  /// There are several places in the compiler that mutate the AST after the
-  /// fact, above and beyond adding Decls to the SourceFile.
+  /// Expand the scope if unexpanded.
   ASTScopeImpl *expandAndBeCurrent(ScopeCreator &);
 
-  bool getWasExpanded() const { return wasExpanded; }
+  bool getWasExpanded() const { return parentAndWasExpanded.getInt(); }
 
 protected:
-  void setWasExpanded() { wasExpanded = true; }
+  void setWasExpanded() { parentAndWasExpanded.setInt(1); }
   virtual ASTScopeImpl *expandSpecifically(ScopeCreator &) = 0;
 
 public:
@@ -360,7 +356,7 @@ class ASTScopeImpl {
   /// what obtaines for scoping. However, guards are different. The scope after
   /// the guard else must hop into the innermoset scope of the guard condition.
   virtual NullablePtr<const ASTScopeImpl> getLookupParent() const {
-    return parent;
+    return getParent();
   }
 
 #pragma mark - - lookup- local bindings
@@ -629,8 +625,6 @@ class IterableTypeScope : public GenericTypeScope {
 
 public:
   NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion() override;
-
-  void countBodies(ScopeCreator &) const;
 };
 
 class NominalTypeScope final : public IterableTypeScope {

include/swift/AST/AnyRequest.h

@@ -83,6 +83,7 @@ struct AnyRequestVTable {
   const std::function<void(const void *, DiagnosticEngine &)> noteCycleStep;
   const std::function<SourceLoc(const void *)> getNearestLoc;
   const std::function<bool(const void *)> isCached;
+  bool isDependencySource;
 
   template <typename Request,
             typename std::enable_if<Request::isEverCached>::type * = nullptr>
@@ -99,6 +100,7 @@ struct AnyRequestVTable {
         &Impl<Request>::noteCycleStep,
         &Impl<Request>::getNearestLoc,
         &Impl<Request>::isCached,
+        Request::isDependencySource,
     };
     return &vtable;
   }
@@ -118,6 +120,7 @@ struct AnyRequestVTable {
         &Impl<Request>::noteCycleStep,
         &Impl<Request>::getNearestLoc,
         [](auto){ return false; },
+        Request::isDependencySource,
     };
     return &vtable;
   }
@@ -224,6 +227,10 @@ class AnyRequestBase {
     return getVTable()->isCached(getRawStorage());
   }
 
+  bool isDependencySource() const {
+    return getVTable()->isDependencySource;
+  }
+
   /// Compare two instances for equality.
   friend bool operator==(const AnyRequestBase<Derived> &lhs,
                          const AnyRequestBase<Derived> &rhs) {

include/swift/AST/Decl.h

@@ -418,7 +418,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasNestedTypeDeclarations : 1
   );
 
-  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1,
+  SWIFT_INLINE_BITFIELD(FuncDecl, AbstractFunctionDecl, 1+1+2+1+1+2+1+1+1,
     /// Whether we've computed the 'static' flag yet.
     IsStaticComputed : 1,
 
@@ -437,21 +437,28 @@ class alignas(1 << DeclAlignInBits) Decl {
     /// Backing bits for 'self' access kind.
     SelfAccess : 2,
 
+    /// Whether we've computed the IsAsyncHandlerRequest.
+    IsAsyncHandlerComputed : 1,
+
+    /// The value of IsAsyncHandlerRequest.
+    IsAsyncHandler : 1,
+
     /// Whether this is a top-level function which should be treated
     /// as if it were in local context for the purposes of capture
     /// analysis.
     HasTopLevelLocalContextCaptures : 1
   );
 
   SWIFT_INLINE_BITFIELD(AccessorDecl, FuncDecl, 4 + 1 + 1,
-                        /// The kind of accessor this is.
-                        AccessorKind : 4,
+    /// The kind of accessor this is.
+    AccessorKind : 4,
 
-                        /// Whether the accessor is transparent.
-                        IsTransparent : 1,
+    /// Whether the accessor is transparent.
+    IsTransparent : 1,
 
-                        /// Whether we have computed the above.
-                        IsTransparentComputed : 1);
+    /// Whether we have computed the above.
+    IsTransparentComputed : 1
+  );
 
   SWIFT_INLINE_BITFIELD(ConstructorDecl, AbstractFunctionDecl, 1+1,
     /// Whether this constructor can fail, by building an Optional type.
@@ -5926,6 +5933,7 @@ class FuncDecl : public AbstractFunctionDecl {
   friend class SelfAccessKindRequest;
   friend class IsStaticRequest;
   friend class ResultTypeRequest;
+  friend class IsAsyncHandlerRequest;
 
   SourceLoc StaticLoc;  // Location of the 'static' token or invalid.
   SourceLoc FuncLoc;    // Location of the 'func' token.
@@ -5957,6 +5965,8 @@ class FuncDecl : public AbstractFunctionDecl {
     Bits.FuncDecl.SelfAccessComputed = false;
     Bits.FuncDecl.IsStaticComputed = false;
     Bits.FuncDecl.IsStatic = false;
+    Bits.FuncDecl.IsAsyncHandlerComputed = false;
+    Bits.FuncDecl.IsAsyncHandler = false;
     Bits.FuncDecl.HasTopLevelLocalContextCaptures = false;
   }
 
@@ -5987,6 +5997,18 @@ class FuncDecl : public AbstractFunctionDecl {
     return None;
   }
 
+  Optional<bool> getCachedIsAsyncHandler() const {
+    if (Bits.FuncDecl.IsAsyncHandlerComputed)
+      return Bits.FuncDecl.IsAsyncHandler;
+
+    return None;
+  }
+
+  void setIsAsyncHandler(bool value) {
+    Bits.FuncDecl.IsAsyncHandlerComputed = true;
+    Bits.FuncDecl.IsAsyncHandler = value;
+  }
+
 public:
   /// Factory function only for use by deserialization.
   static FuncDecl *createDeserialized(ASTContext &Context,

include/swift/AST/DependencyCollector.h

@@ -0,0 +1,159 @@
+//===--- DependencyCollector.h -------------------------------- -*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines a class for recording incremental dependencies.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_DEPENDENCY_COLLECTOR_H
+#define SWIFT_AST_DEPENDENCY_COLLECTOR_H
+
+#include "swift/AST/Identifier.h"
+#include "llvm/ADT/DenseMap.h"
+#include "llvm/ADT/DenseSet.h"
+
+namespace swift {
+
+class NominalTypeDecl;
+
+namespace evaluator {
+
+class DependencyRecorder;
+
+/// A \c DependencyCollector defines an abstract write-only buffer of
+/// \c Reference objects. References are added to a collector during the write
+/// phase of request evaluation (in \c writeDependencySink) with the various
+/// \c add* functions below.
+///
+/// A \c DependencyCollector should not be created directly; instances are
+/// vended by the request evaluator infrastructure itself.
+struct DependencyCollector {
+  friend DependencyRecorder;
+
+  struct Reference {
+  public:
+    enum class Kind {
+      Empty,
+      Tombstone,
+      UsedMember,
+      PotentialMember,
+      TopLevel,
+      Dynamic,
+    } kind;
+
+    NominalTypeDecl *subject;
+    DeclBaseName name;
+
+  private:
+    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
+        : kind(kind), subject(subject), name(name) {}
+
+  public:
+    static Reference empty() {
+      return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
+              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
+    }
+
+    static Reference tombstone() {
+      return {Kind::Tombstone,
+              llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
+              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
+    }
+
+  public:
+    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
+      return {Kind::UsedMember, subject, name};
+    }
+
+    static Reference potentialMember(NominalTypeDecl *subject) {
+      return {Kind::PotentialMember, subject, DeclBaseName()};
+    }
+
+    static Reference topLevel(DeclBaseName name) {
+      return {Kind::TopLevel, nullptr, name};
+    }
+
+    static Reference dynamic(DeclBaseName name) {
+      return {Kind::Dynamic, nullptr, name};
+    }
+
+  public:
+    struct Info {
+      static inline Reference getEmptyKey() { return Reference::empty(); }
+      static inline Reference getTombstoneKey() {
+        return Reference::tombstone();
+      }
+      static inline unsigned getHashValue(const Reference &Val) {
+        return llvm::hash_combine(Val.kind, Val.subject,
+                                  Val.name.getAsOpaquePointer());
+      }
+      static bool isEqual(const Reference &LHS, const Reference &RHS) {
+        return LHS.kind == RHS.kind && LHS.subject == RHS.subject &&
+               LHS.name == RHS.name;
+      }
+    };
+  };
+
+private:
+  DependencyRecorder &parent;
+
+public:
+  explicit DependencyCollector(DependencyRecorder &parent);
+  ~DependencyCollector();
+
+public:
+  /// Registers a named reference from the current dependency scope to a member
+  /// defined in the given \p subject type.
+  ///
+  /// Used member constraints are typically the by-product of direct lookups,
+  /// where the name being looked up and the target of the lookup are known
+  /// up front. A used member dependency causes the file to be rebuilt if the
+  /// definition of that member changes in any way - via
+  /// deletion, addition, or mutation of a member with that same name.
+  void addUsedMember(NominalTypeDecl *subject, DeclBaseName name);
+  /// Registers a reference from the current dependency scope to a
+  /// "potential member" of the given \p subject type.
+  ///
+  /// A single potential member dependency can be thought of as many used member
+  /// dependencies - one for each current member of the subject type, but also
+  /// one for every member that will be added or removed from the type in the
+  /// future. As such, these dependencies cause rebuilds when any members are
+  /// added, removed, or changed in the \p subject type. It also indicates a
+  /// dependency on the \p subject type's existence, so deleting the \p subject
+  /// type will also cause a rebuild.
+  ///
+  /// These dependencies are most appropriate for protocol conformances,
+  /// superclass constraints, and other requirements involving entire types.
+  void addPotentialMember(NominalTypeDecl *subject);
+  /// Registers a reference from the current dependency scope to a given
+  /// top-level \p name.
+  ///
+  /// A top level dependency causes a rebuild when another top-level entity with
+  /// that name is added, removed, or modified.
+  void addTopLevelName(DeclBaseName name);
+  /// Registers a reference from the current dependency scope to a given
+  /// dynamic member \p name.
+  ///
+  /// A dynamic lookup dependency is a special kind of member dependency on
+  /// a name that is found by \c AnyObject lookup.
+  void addDynamicLookupName(DeclBaseName name);
+
+public:
+  /// Retrieves the dependency recorder that created this dependency collector.
+  const DependencyRecorder &getRecorder() const { return parent; }
+};
+
+} // end namespace evaluator
+
+} // end namespace swift
+
+#endif // SWIFT_AST_DEPENDENCY_COLLECTOR_H