Merge pull request #1884 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

docs/README.md

@@ -113,7 +113,7 @@ documentation, please create a thread on the Swift forums under the
     Describes how the "Omit Needless Words" algorithm works,
     making imported names more idiomatic.
 - Type-checking and inference:
-  - [TypeChecker.rst](/docs/TypeChecker.rst):
+  - [TypeChecker.md](/docs/TypeChecker.md):
     Provides an overview of how type-checking and inference work.
   - [RequestEvaluator.md](/docs/RequestEvaluator.md):
     Describes the request evaluator architecture, which is used for

docs/contents.rst

@@ -12,7 +12,6 @@ Contents
    Generics
    StoredAndComputedVariables
    SIL
-   TypeChecker
    OptimizationTips
    ABI: TypeMetadata <ABI/TypeMetadata>
    ABI: TypeLayout <ABI/TypeLayout>

include/swift/AST/ASTContext.h

@@ -762,6 +762,12 @@ class ASTContext final {
                        bool isClang = false, bool isDWARF = false,
                        bool IsInterface = false);
 
+  /// Add a module interface checker to use for this AST context.
+  void addModuleInterfaceChecker(std::unique_ptr<ModuleInterfaceChecker> checker);
+
+  /// Retrieve the module interface checker associated with this AST context.
+  ModuleInterfaceChecker *getModuleInterfaceChecker() const;
+
   /// Retrieve the module dependencies for the module with the given name.
   ///
   /// \param isUnderlyingClangModule When true, only look for a Clang module
@@ -839,9 +845,6 @@ class ASTContext final {
   /// If there is no Clang module loader, returns a null pointer.
   /// The loader is owned by the AST context.
   ClangModuleLoader *getDWARFModuleLoader() const;
-
-  /// Retrieve the module interface loader for this ASTContext.
-  ModuleLoader *getModuleInterfaceLoader() const;
 public:
   namelookup::ImportCache &getImportCache() const;
 

include/swift/AST/Decl.h

@@ -4842,6 +4842,14 @@ class VarDecl : public AbstractStorageDecl {
   /// property wrapper with a \c projectedValue .
   VarDecl *getPropertyWrapperProjectionVar() const;
 
+  /// Visit all auxiliary declarations to this VarDecl.
+  ///
+  /// An auxiliary declaration is a declaration synthesized by the compiler to support
+  /// this VarDecl, such as synthesized property wrapper variables.
+  ///
+  /// \note this function only visits auxiliary decls that are not part of the AST.
+  void visitAuxiliaryDecls(llvm::function_ref<void(VarDecl *)>) const;
+
   /// Retrieve the backing storage property for a lazy property.
   VarDecl *getLazyStorageProperty() const;
 

include/swift/AST/DiagnosticsSema.def

@@ -5216,8 +5216,6 @@ ERROR(property_wrapper_mutating_get_composed_to_get_only,none,
       "property wrapper %0 with a mutating getter cannot be composed inside "
       "get-only property wrapper %1", (TypeLoc, TypeLoc))
 
-ERROR(property_wrapper_local,none,
-      "property wrappers are not yet supported on local properties", ())
 ERROR(property_wrapper_top_level,none,
       "property wrappers are not yet supported in top-level code", ())
 ERROR(property_wrapper_let, none,

include/swift/AST/ModuleLoader.h

@@ -116,6 +116,23 @@ struct SubCompilerInstanceInfo {
   ArrayRef<StringRef> ExtraPCMArgs;
 };
 
+/// Abstract interface for a checker of module interfaces and prebuilt modules.
+class ModuleInterfaceChecker {
+public:
+  virtual std::vector<std::string>
+  getCompiledModuleCandidatesForInterface(StringRef moduleName,
+                                          StringRef interfacePath) = 0;
+
+  /// Given a list of potential ready-to-use compiled modules for \p interfacePath,
+  /// check if any one of them is up-to-date. If so, emit a forwarding module
+  /// to the candidate binary module to \p outPath.
+  virtual bool tryEmitForwardingModule(StringRef moduleName,
+                               StringRef interfacePath,
+                               ArrayRef<std::string> candidates,
+                               StringRef outPath) = 0;
+  virtual ~ModuleInterfaceChecker() = default;
+};
+
 /// Abstract interface to run an action in a sub ASTContext.
 struct InterfaceSubContextDelegate {
   virtual std::error_code runInSubContext(StringRef moduleName,

include/swift/Basic/STLExtras.h

@@ -217,6 +217,47 @@ inline Iterator prev_or_begin(Iterator it, Iterator begin) {
 
 /// @}
 
+/// An iterator that walks a linked list of objects until it reaches
+/// a null pointer.
+template <class T, T* (&getNext)(T*)>
+class LinkedListIterator {
+  T *Pointer;
+public:
+  using iterator_category = std::forward_iterator_tag;
+  using value_type = T *;
+  using reference = T *;
+  using pointer = void;
+
+  /// Returns an iterator range starting from the given pointer and
+  /// running until it reaches a null pointer.
+  static llvm::iterator_range<LinkedListIterator> rangeBeginning(T *pointer) {
+    return {pointer, nullptr};
+  }
+
+  constexpr LinkedListIterator(T *pointer) : Pointer(pointer) {}
+
+  T *operator*() const {
+    assert(Pointer && "dereferencing a null iterator");
+    return Pointer;
+  }
+
+  LinkedListIterator &operator++() {
+    Pointer = getNext(Pointer);
+    return *this;
+  }
+  LinkedListIterator operator++(int) {
+    auto copy = *this;
+    Pointer = getNext(Pointer);
+    return copy;
+  }
+
+  friend bool operator==(LinkedListIterator lhs, LinkedListIterator rhs) {
+    return lhs.Pointer == rhs.Pointer;
+  }
+  friend bool operator!=(LinkedListIterator lhs, LinkedListIterator rhs) {
+    return lhs.Pointer != rhs.Pointer;
+  }
+};
 
 /// An iterator that transforms the result of an underlying bidirectional
 /// iterator with a given operation.

include/swift/Frontend/ModuleInterfaceLoader.h

@@ -309,27 +309,52 @@ struct ModuleInterfaceLoaderOptions {
   ModuleInterfaceLoaderOptions() = default;
 };
 
+class ModuleInterfaceCheckerImpl: public ModuleInterfaceChecker {
+  friend class ModuleInterfaceLoader;
+  ASTContext &Ctx;
+  std::string CacheDir;
+  std::string PrebuiltCacheDir;
+  ModuleInterfaceLoaderOptions Opts;
+
+public:
+  explicit ModuleInterfaceCheckerImpl(ASTContext &Ctx,
+                                      StringRef cacheDir,
+                                      StringRef prebuiltCacheDir,
+                                      ModuleInterfaceLoaderOptions Opts)
+  : Ctx(Ctx), CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
+    Opts(Opts) {}
+
+  std::vector<std::string>
+  getCompiledModuleCandidatesForInterface(StringRef moduleName,
+                                          StringRef interfacePath) override;
+
+  /// Given a list of potential ready-to-use compiled modules for \p interfacePath,
+  /// check if any one of them is up-to-date. If so, emit a forwarding module
+  /// to the candidate binary module to \p outPath.
+  bool tryEmitForwardingModule(StringRef moduleName,
+                               StringRef interfacePath,
+                               ArrayRef<std::string> candidates,
+                               StringRef outPath) override;
+  bool isCached(StringRef DepPath);
+};
+
 /// A ModuleLoader that runs a subordinate \c CompilerInvocation and
 /// \c CompilerInstance to convert .swiftinterface files to .swiftmodule
 /// files on the fly, caching the resulting .swiftmodules in the module cache
 /// directory, and loading the serialized .swiftmodules from there.
 class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
   friend class unittest::ModuleInterfaceLoaderTest;
   explicit ModuleInterfaceLoader(
-      ASTContext &ctx, StringRef cacheDir, StringRef prebuiltCacheDir,
+      ASTContext &ctx, ModuleInterfaceCheckerImpl &InterfaceChecker,
       DependencyTracker *tracker, ModuleLoadingMode loadMode,
       ArrayRef<std::string> PreferInterfaceForModules,
-      bool IgnoreSwiftSourceInfoFile, ModuleInterfaceLoaderOptions Opts)
-  : SerializedModuleLoaderBase(ctx, tracker, loadMode,
-                               IgnoreSwiftSourceInfoFile),
-  CacheDir(cacheDir), PrebuiltCacheDir(prebuiltCacheDir),
-  PreferInterfaceForModules(PreferInterfaceForModules),
-  Opts(Opts) {}
+      bool IgnoreSwiftSourceInfoFile)
+  : SerializedModuleLoaderBase(ctx, tracker, loadMode, IgnoreSwiftSourceInfoFile),
+    InterfaceChecker(InterfaceChecker),
+    PreferInterfaceForModules(PreferInterfaceForModules){}
 
-  std::string CacheDir;
-  std::string PrebuiltCacheDir;
+  ModuleInterfaceCheckerImpl &InterfaceChecker;
   ArrayRef<std::string> PreferInterfaceForModules;
-  ModuleInterfaceLoaderOptions Opts;
 
   std::error_code findModuleFilesInDirectory(
      ImportPath::Element ModuleID,
@@ -343,17 +368,14 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
   bool isCached(StringRef DepPath) override;
 public:
   static std::unique_ptr<ModuleInterfaceLoader>
-  create(ASTContext &ctx, StringRef cacheDir, StringRef prebuiltCacheDir,
+  create(ASTContext &ctx, ModuleInterfaceCheckerImpl &InterfaceChecker,
          DependencyTracker *tracker, ModuleLoadingMode loadMode,
          ArrayRef<std::string> PreferInterfaceForModules = {},
-         ModuleInterfaceLoaderOptions Opts = ModuleInterfaceLoaderOptions(),
          bool IgnoreSwiftSourceInfoFile = false) {
     return std::unique_ptr<ModuleInterfaceLoader>(
-      new ModuleInterfaceLoader(ctx, cacheDir, prebuiltCacheDir,
-                                         tracker, loadMode,
-                                         PreferInterfaceForModules,
-                                         IgnoreSwiftSourceInfoFile,
-                                         Opts));
+      new ModuleInterfaceLoader(ctx, InterfaceChecker, tracker, loadMode,
+                                PreferInterfaceForModules,
+                                IgnoreSwiftSourceInfoFile));
   }
 
   /// Append visible module names to \p names. Note that names are possibly
@@ -373,18 +395,6 @@ class ModuleInterfaceLoader : public SerializedModuleLoaderBase {
     StringRef ModuleName, StringRef InPath, StringRef OutPath,
     bool SerializeDependencyHashes, bool TrackSystemDependencies,
     ModuleInterfaceLoaderOptions Opts);
-
-  std::vector<std::string>
-  getCompiledModuleCandidatesForInterface(StringRef moduleName,
-                                          StringRef interfacePath) override;
-
-  /// Given a list of potential ready-to-use compiled modules for \p interfacePath,
-  /// check if any one of them is up-to-date. If so, emit a forwarding module
-  /// to the candidate binary module to \p outPath.
-  bool tryEmitForwardingModule(StringRef moduleName,
-                               StringRef interfacePath,
-                               ArrayRef<std::string> candidates,
-                               StringRef outPath) override;
 };
 
 struct InterfaceSubContextDelegateImpl: InterfaceSubContextDelegate {

include/swift/SILOptimizer/Utils/InstOptUtils.h

@@ -357,6 +357,11 @@ void getConsumedPartialApplyArgs(PartialApplyInst *pai,
                                  SmallVectorImpl<Operand *> &argOperands,
                                  bool includeTrivialAddrArgs);
 
+/// Emit destroy operation for \p operand, and call appropriate functions from
+/// \p callbacks for newly created instructions and deleted instructions.
+void emitDestroyOperation(SILBuilder &builder, SILLocation loc,
+                          SILValue operand, InstModCallbacks callbacks);
+
 /// Collect all (transitive) users of \p inst which just copy or destroy \p
 /// inst.
 ///
@@ -366,6 +371,7 @@ void getConsumedPartialApplyArgs(PartialApplyInst *pai,
 /// destroys, i.e. if \p inst can be considered as "dead".
 bool collectDestroys(SingleValueInstruction *inst,
                      SmallVectorImpl<SILInstruction *> &destroys);
+
 /// If Closure is a partial_apply or thin_to_thick_function with only local
 /// ref count users and a set of post-dominating releases:
 ///

include/swift/Serialization/SerializedModuleLoader.h

@@ -201,18 +201,6 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   virtual Optional<ModuleDependencies> getModuleDependencies(
       StringRef moduleName, ModuleDependenciesCache &cache,
       InterfaceSubContextDelegate &delegate) override;
-
-  virtual std::vector<std::string>
-  getCompiledModuleCandidatesForInterface(StringRef moduleName,
-                                          StringRef interfacePath) {
-    return std::vector<std::string>();
-  }
-  virtual bool tryEmitForwardingModule(StringRef moduleName,
-                                       StringRef interfacePath,
-                                       ArrayRef<std::string> candidates,
-                                       StringRef outPath) {
-    return false;
-  }
 };
 
 /// Imports serialized Swift modules into an ASTContext.