Revert host toolchain build change, merge master

include/swift/AST/ASTContext.h

@@ -748,11 +748,13 @@ class ASTContext final {
   /// \param methods The list of @objc methods in this class that have this
   /// selector and are instance/class methods as requested. This list will be
   /// extended with any methods found in subsequent generations.
-  void loadObjCMethods(ClassDecl *classDecl,
-                       ObjCSelector selector,
-                       bool isInstanceMethod,
-                       unsigned previousGeneration,
-                       llvm::TinyPtrVector<AbstractFunctionDecl *> &methods);
+  ///
+  /// \param swiftOnly If true, only loads methods from imported Swift modules,
+  /// skipping the Clang importer.
+  void loadObjCMethods(ClassDecl *classDecl, ObjCSelector selector,
+                       bool isInstanceMethod, unsigned previousGeneration,
+                       llvm::TinyPtrVector<AbstractFunctionDecl *> &methods,
+                       bool swiftOnly = false);
 
   /// Load derivative function configurations for the given
   /// AbstractFunctionDecl.

include/swift/AST/Decl.h

@@ -4117,8 +4117,8 @@ class ClassDecl final : public NominalTypeDecl {
   ///
   /// \param isInstance Whether we are looking for an instance method
   /// (vs. a class method).
-  MutableArrayRef<AbstractFunctionDecl *> lookupDirect(ObjCSelector selector,
-                                                       bool isInstance);
+  TinyPtrVector<AbstractFunctionDecl *> lookupDirect(ObjCSelector selector,
+                                                     bool isInstance);
 
   /// Record the presence of an @objc method with the given selector.
   void recordObjCMethod(AbstractFunctionDecl *method, ObjCSelector selector);
@@ -5232,6 +5232,12 @@ class VarDecl : public AbstractStorageDecl {
   Optional<PropertyWrapperMutability>
       getPropertyWrapperMutability() const;
 
+  /// Returns whether this property is the backing storage property or a storage
+  /// wrapper for wrapper instance's projectedValue. If this property is
+  /// neither, then it returns `None`.
+  Optional<PropertyWrapperSynthesizedPropertyKind>
+  getPropertyWrapperSynthesizedPropertyKind() const;
+
   /// Retrieve the backing storage property for a property that has an
   /// attached property wrapper.
   ///

include/swift/AST/DiagnosticsSema.def

@@ -557,6 +557,9 @@ ERROR(expr_keypath_mutating_getter,none,
 ERROR(expr_keypath_static_member,none,
       "%select{key path|dynamic key path member lookup}1 cannot refer to static member %0",
       (DeclName, bool))
+ERROR(expr_keypath_enum_case,none,
+      "%select{key path|dynamic key path member lookup}1 cannot refer to enum case %0",
+      (DeclName, bool))
 ERROR(expr_keypath_empty,none,
       "empty key path does not refer to a property", ())
 ERROR(expr_unsupported_objc_key_path_component,none,
@@ -760,12 +763,20 @@ ERROR(invalid_redecl,none,"invalid redeclaration of %0", (DeclName))
 ERROR(invalid_redecl_init,none,
       "invalid redeclaration of synthesized %select{|memberwise }1%0",
       (DeclName, bool))
+ERROR(invalid_redecl_implicit,none,
+      "invalid redeclaration of synthesized "
+      "%select{%0|implementation for protocol requirement}1 %2",
+      (DescriptiveDeclKind, bool, DeclName))
 WARNING(invalid_redecl_swift5_warning,none,
         "redeclaration of %0 is deprecated and will be an error in Swift 5",
         (DeclName))
 
 NOTE(invalid_redecl_prev,none,
      "%0 previously declared here", (DeclName))
+NOTE(invalid_redecl_implicit_wrapper,none,
+     "%0 synthesized for property wrapper "
+     "%select{projected value|backing storage}1",
+     (DeclName, bool))
 
 ERROR(ambiguous_type_base,none,
       "%0 is ambiguous for type lookup in this context", (DeclNameRef))

include/swift/AST/Evaluator.h

@@ -262,6 +262,12 @@ class Evaluator {
   void registerRequestFunctions(Zone zone,
                                 ArrayRef<AbstractRequestFunction *> functions);
 
+  void enumerateReferencesInFile(
+      const SourceFile *SF,
+      evaluator::DependencyRecorder::ReferenceEnumerator f) const {
+    return recorder.enumerateReferencesInFile(SF, f);
+  }
+
   /// Retrieve the result produced by evaluating a request that can
   /// be cached.
   template<typename Request,

include/swift/AST/EvaluatorDependencies.h

@@ -110,6 +110,8 @@ using DependencySource = llvm::PointerIntPair<SourceFile *, 1, DependencyScope>;
 struct DependencyRecorder;
 
 struct DependencyCollector {
+  friend DependencyRecorder;
+
   struct Reference {
   public:
     enum class Kind {
@@ -123,38 +125,41 @@ struct DependencyCollector {
 
     NominalTypeDecl *subject;
     DeclBaseName name;
+    bool cascades;
 
   private:
-    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name)
-        : kind(kind), subject(subject), name(name) {}
+    Reference(Kind kind, NominalTypeDecl *subject, DeclBaseName name,
+              bool cascades)
+        : kind(kind), subject(subject), name(name), cascades(cascades) {}
 
   public:
     static Reference empty() {
       return {Kind::Empty, llvm::DenseMapInfo<NominalTypeDecl *>::getEmptyKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey()};
+              llvm::DenseMapInfo<DeclBaseName>::getEmptyKey(), false};
     }
 
     static Reference tombstone() {
-      return {Kind::Empty,
+      return {Kind::Tombstone,
               llvm::DenseMapInfo<NominalTypeDecl *>::getTombstoneKey(),
-              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey()};
+              llvm::DenseMapInfo<DeclBaseName>::getTombstoneKey(), false};
     }
 
   public:
-    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name) {
-      return {Kind::UsedMember, subject, name};
+    static Reference usedMember(NominalTypeDecl *subject, DeclBaseName name,
+                                bool cascades) {
+      return {Kind::UsedMember, subject, name, cascades};
     }
 
-    static Reference potentialMember(NominalTypeDecl *subject) {
-      return {Kind::PotentialMember, subject, DeclBaseName()};
+    static Reference potentialMember(NominalTypeDecl *subject, bool cascades) {
+      return {Kind::PotentialMember, subject, DeclBaseName(), cascades};
     }
 
-    static Reference topLevel(DeclBaseName name) {
-      return {Kind::TopLevel, nullptr, name};
+    static Reference topLevel(DeclBaseName name, bool cascades) {
+      return {Kind::TopLevel, nullptr, name, cascades};
     }
 
-    static Reference dynamic(DeclBaseName name) {
-      return {Kind::Dynamic, nullptr, name};
+    static Reference dynamic(DeclBaseName name, bool cascades) {
+      return {Kind::Dynamic, nullptr, name, cascades};
     }
 
   public:
@@ -174,8 +179,12 @@ struct DependencyCollector {
     };
   };
 
+public:
+  using ReferenceSet = llvm::DenseSet<Reference, Reference::Info>;
+
+private:
   DependencyRecorder &parent;
-  llvm::DenseSet<Reference, Reference::Info> scratch;
+  ReferenceSet scratch;
 
 public:
   explicit DependencyCollector(DependencyRecorder &parent) : parent(parent) {}
@@ -226,11 +235,7 @@ struct DependencyCollector {
 /// particular \c DependencyScope during the course of request evaluation.
 struct DependencyRecorder {
   friend DependencyCollector;
-private:
-  /// A stack of dependency sources in the order they were evaluated.
-  llvm::SmallVector<evaluator::DependencySource, 8> dependencySources;
 
-public:
   enum class Mode {
     // Enables the current "status quo" behavior of the dependency collector.
     //
@@ -244,14 +249,19 @@ struct DependencyRecorder {
     // the primary file being acted upon instead of to the destination file.
     ExperimentalPrivateDependencies,
   };
-  Mode mode;
-  llvm::DenseMap<AnyRequest, llvm::DenseSet<DependencyCollector::Reference,
-                                            DependencyCollector::Reference::Info>>
+
+private:
+  /// A stack of dependency sources in the order they were evaluated.
+  llvm::SmallVector<evaluator::DependencySource, 8> dependencySources;
+  llvm::DenseMap<SourceFile *, DependencyCollector::ReferenceSet>
+      fileReferences;
+  llvm::DenseMap<AnyRequest, DependencyCollector::ReferenceSet>
       requestReferences;
+  Mode mode;
   bool isRecording;
 
-  explicit DependencyRecorder(Mode mode)
-      : mode{mode}, requestReferences{}, isRecording{false} {};
+public:
+  explicit DependencyRecorder(Mode mode) : mode{mode}, isRecording{false} {};
 
 private:
   void realize(const DependencyCollector::Reference &ref);
@@ -261,6 +271,12 @@ struct DependencyRecorder {
   void record(const llvm::SetVector<swift::ActiveRequest> &stack,
               llvm::function_ref<void(DependencyCollector &)> rec);
 
+public:
+  using ReferenceEnumerator =
+      llvm::function_ref<void(const DependencyCollector::Reference &)>;
+  void enumerateReferencesInFile(const SourceFile *SF,
+                                 ReferenceEnumerator f) const ;
+
 public:
   /// Returns the scope of the current active scope.
   ///
@@ -323,25 +339,6 @@ struct DependencyRecorder {
     return dependencySources.front().getPointer();
   }
 
-  /// If there is an active dependency source, returns its
-  /// \c ReferencedNameTracker. Else, returns \c nullptr.
-  ReferencedNameTracker *getActiveDependencyTracker() const {
-    SourceFile *source = nullptr;
-    switch (mode) {
-    case Mode::StatusQuo:
-      source = getActiveDependencySourceOrNull();
-      break;
-    case Mode::ExperimentalPrivateDependencies:
-      source = getFirstDependencySourceOrNull();
-      break;
-    }
-
-    if (!source)
-      return nullptr;
-
-    return source->getRequestBasedReferencedNameTracker();
-  }
-
   /// Returns \c true if the scope of the current active source cascades.
   ///
   /// If there is no active scope, the result always cascades.

include/swift/AST/GenericSignature.h

@@ -329,12 +329,12 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Determine whether the given dependent type is equal to a concrete type.
   bool isConcreteType(Type type) const;
 
-  /// Return the concrete type that the given dependent type is constrained to,
+  /// Return the concrete type that the given type parameter is constrained to,
   /// or the null Type if it is not the subject of a concrete same-type
   /// constraint.
   Type getConcreteType(Type type) const;
 
-  /// Return the layout constraint that the given dependent type is constrained
+  /// Return the layout constraint that the given type parameter is constrained
   /// to, or the null LayoutConstraint if it is not the subject of layout
   /// constraint.
   LayoutConstraint getLayoutConstraint(Type type) const;

include/swift/AST/IRGenOptions.h

@@ -191,6 +191,7 @@ class IRGenOptions {
   unsigned DisableLLVMSLPVectorizer : 1;
 
   /// Disable frame pointer elimination?
+  unsigned DisableFPElimLeaf : 1;
   unsigned DisableFPElim : 1;
 
   /// Special codegen for playgrounds.
@@ -319,6 +320,7 @@ class IRGenOptions {
         DisableClangModuleSkeletonCUs(false), UseJIT(false),
         DisableLLVMOptzns(false),
         DisableSwiftSpecificLLVMOptzns(false), DisableLLVMSLPVectorizer(false),
+        DisableFPElimLeaf(false),
         DisableFPElim(true), Playground(false), EmitStackPromotionChecks(false),
         FunctionSections(false), PrintInlineTree(false), EmbedMode(IRGenEmbedMode::None),
         HasValueNamesSetting(false), ValueNames(false),

include/swift/AST/Module.h

@@ -22,7 +22,6 @@
 #include "swift/AST/Identifier.h"
 #include "swift/AST/LookupKinds.h"
 #include "swift/AST/RawComment.h"
-#include "swift/AST/ReferencedNameTracker.h"
 #include "swift/AST/Type.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/OptionSet.h"
@@ -69,7 +68,6 @@ namespace swift {
   class ProtocolConformance;
   class ProtocolDecl;
   struct PrintOptions;
-  class ReferencedNameTracker;
   class Token;
   class TupleType;
   class Type;