Merge pull request #1829 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/AST/ASTScope.h

@@ -344,9 +344,6 @@ class ASTScopeImpl {
   virtual NullablePtr<ASTScopeImpl> insertionPointForDeferredExpansion();
   virtual SourceRange sourceRangeForDeferredExpansion() const;
 
-public:
-  bool isATypeDeclScope() const;
-
 private:
   virtual ScopeCreator &getScopeCreator();
 
@@ -435,6 +432,7 @@ class ASTScopeImpl {
     return p->getParent().isNonNull() ? p : nullptr;
   }
 
+public:
   /// The tree is organized by source location and for most nodes this is also
   /// what obtaines for scoping. However, guards are different. The scope after
   /// the guard else must hop into the innermoset scope of the guard condition.
@@ -1079,6 +1077,7 @@ class PatternEntryDeclScope final : public AbstractPatternEntryScope {
 
 protected:
   bool lookupLocalsOrMembers(DeclConsumer) const override;
+  bool isLabeledStmtLookupTerminator() const override;
 };
 
 class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
@@ -1093,6 +1092,7 @@ class PatternEntryInitializerScope final : public AbstractPatternEntryScope {
 
 protected:
   ASTScopeImpl *expandSpecifically(ScopeCreator &scopeCreator) override;
+  NullablePtr<const ASTScopeImpl> getLookupParent() const override;
 
 private:
   void expandAScopeThatDoesNotCreateANewInsertionPoint(ScopeCreator &);

include/swift/AST/Decl.h

@@ -578,7 +578,7 @@ class alignas(1 << DeclAlignInBits) Decl {
     HasAnyUnavailableValues : 1
   );
 
-  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1,
+  SWIFT_INLINE_BITFIELD(ModuleDecl, TypeDecl, 1+1+1+1+1+1+1+1+1+1,
     /// If the module was or is being compiled with `-enable-testing`.
     TestingEnabled : 1,
 
@@ -607,7 +607,10 @@ class alignas(1 << DeclAlignInBits) Decl {
     IsNonSwiftModule : 1,
 
     /// Whether this module is the main module.
-    IsMainModule : 1
+    IsMainModule : 1,
+
+    /// Whether this module has incremental dependency information available.
+    HasIncrementalInfo : 1
   );
 
   SWIFT_INLINE_BITFIELD(PrecedenceGroupDecl, Decl, 1+2,
@@ -4121,12 +4124,14 @@ struct SelfReferenceKind {
     return SelfReferenceKind(false, false, false, false);
   }
 
-  /// The type refers to 'Self', but only as the result type of a method.
+  /// The type refers to 'Self', but only as the type of a property or
+  /// the result type of a method/subscript.
   static SelfReferenceKind Result() {
     return SelfReferenceKind(true, false, false, false);
   }
 
-  /// The type refers to 'Self', but only as the parameter type of a method.
+  /// The type refers to 'Self', but only as the parameter type
+  /// of a method/subscript.
   static SelfReferenceKind Parameter() {
     return SelfReferenceKind(false, true, false, false);
   }
@@ -5948,6 +5953,10 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// Returns true if the function is an @asyncHandler.
   bool isAsyncHandler() const;
 
+  /// Returns true if the function if the signature matches the form of an
+  /// @asyncHandler.
+  bool canBeAsyncHandler() const;
+
   /// Returns true if the function body throws.
   bool hasThrows() const { return Bits.AbstractFunctionDecl.Throws; }
 

include/swift/AST/DiagnosticsSema.def

@@ -1992,14 +1992,15 @@ NOTE(witness_self_weaken_same_type,none,
       "consider weakening the same-type requirement %0 == %1 to a superclass "
       "requirement", (Type, Type))
 ERROR(witness_requires_dynamic_self,none,
-      "method %0 in non-final class %1 must return 'Self' to conform to "
-      "protocol %2",
-      (DeclName, Type, Type))
+      "%select{%error|method|property|subscript}0 %1 in non-final class %2 "
+      "must %select{%error|return|specify type|return}0 'Self' "
+      "to conform to protocol %3",
+      (RequirementKind, DeclName, Type, Type))
 ERROR(witness_requires_class_implementation,none,
-      "method %0 in non-final class %1 cannot be implemented in a "
-      "protocol extension because it returns 'Self' and has associated type "
-      "requirements",
-      (DeclName, Type))
+      "%select{%error|method|%error|subscript}0 %1 in non-final class %2 "
+      "cannot be implemented in a protocol extension because it returns 'Self' "
+      "and has associated type requirements",
+      (RequirementKind, DeclName, Type))
 ERROR(witness_not_accessible_proto,none,
       "%select{initializer %1|method %1|%select{|setter for }2property %1"
       "|subscript%select{| setter}2}0 must be declared "

include/swift/AST/FineGrainedDependencies.h

@@ -59,11 +59,14 @@ namespace swift {
 class DependencyTracker;
 class DiagnosticEngine;
 class FrontendOptions;
+class ModuleDecl;
 class SourceFile;
 
 /// Use a new namespace to help keep the experimental code from clashing.
 namespace fine_grained_dependencies {
 
+class SourceFileDepGraph;
+
 using StringVec = std::vector<std::string>;
 
 template <typename Element> using ConstPtrVec = std::vector<const Element *>;
@@ -343,11 +346,11 @@ class BiIndexedTwoStageMap {
 // MARK: Start of fine-grained-dependency-specific code
 //==============================================================================
 
-/// The entry point into this system from the frontend:
-/// Write out the .swiftdeps file for a frontend compilation of a primary file.
-bool emitReferenceDependencies(DiagnosticEngine &diags, SourceFile *SF,
-                               const DependencyTracker &depTracker,
-                               StringRef outputPath, bool alsoEmitDotFile);
+bool withReferenceDependencies(
+    llvm::PointerUnion<ModuleDecl *, SourceFile *> MSF,
+    const DependencyTracker &depTracker, StringRef outputPath,
+    bool alsoEmitDotFile, llvm::function_ref<bool(SourceFileDepGraph &&)>);
+
 //==============================================================================
 // MARK: Enums
 //==============================================================================

include/swift/AST/FineGrainedDependencyFormat.h

@@ -124,7 +124,11 @@ bool readFineGrainedDependencyGraph(llvm::StringRef path,
 
 /// Tries to write the dependency graph to the given path name.
 /// Returns true if there was an error.
-bool writeFineGrainedDependencyGraph(DiagnosticEngine &diags, llvm::StringRef path,
+bool writeFineGrainedDependencyGraphToPath(DiagnosticEngine &diags,
+                                           llvm::StringRef path,
+                                           const SourceFileDepGraph &g);
+
+void writeFineGrainedDependencyGraph(llvm::BitstreamWriter &Out,
                                      const SourceFileDepGraph &g);
 
 } // namespace fine_grained_dependencies

include/swift/AST/Module.h

@@ -517,6 +517,12 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     Bits.ModuleDecl.RawResilienceStrategy = unsigned(strategy);
   }
 
+  /// Returns true if this module was or is being compiled for testing.
+  bool hasIncrementalInfo() const { return Bits.ModuleDecl.HasIncrementalInfo; }
+  void setHasIncrementalInfo(bool enabled = true) {
+    Bits.ModuleDecl.HasIncrementalInfo = enabled;
+  }
+
   /// \returns true if this module is a system module; note that the StdLib is
   /// considered a system module.
   bool isSystemModule() const {

include/swift/AST/TypeCheckRequests.h

@@ -797,6 +797,25 @@ class IsAsyncHandlerRequest :
   bool isCached() const { return true; }
 };
 
+/// Determine whether the given function can be an @asyncHandler, without
+/// producing any diagnostics.
+class CanBeAsyncHandlerRequest :
+    public SimpleRequest<CanBeAsyncHandlerRequest,
+                         bool(FuncDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  bool evaluate(Evaluator &evaluator, FuncDecl *func) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Determine whether the given class is an actor.
 class IsActorRequest :
     public SimpleRequest<IsActorRequest,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -83,6 +83,8 @@ SWIFT_REQUEST(TypeChecker, FunctionBuilderTypeRequest, Type(ValueDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsAsyncHandlerRequest, bool(FuncDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, CanBeAsyncHandlerRequest, bool(FuncDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, IsActorRequest, bool(ClassDecl *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ActorIsolationRequest,

include/swift/Driver/Compilation.h

@@ -206,15 +206,6 @@ class Compilation {
   /// of date.
   bool EnableIncrementalBuild;
 
-  /// When true, emit duplicated compilation record file whose filename is
-  /// suffixed with '~moduleonly'.
-  ///
-  /// This compilation record is used by '-emit-module'-only incremental builds
-  /// so that module-only builds do not affect compilation record file for
-  /// normal builds, while module-only incremental builds are able to use
-  /// artifacts of normal builds if they are already up to date.
-  bool OutputCompilationRecordForModuleOnlyBuild = false;
-
   /// Indicates whether groups of parallel frontend jobs should be merged
   /// together and run in composite "batch jobs" when possible, to reduce
   /// redundant work.
@@ -290,6 +281,9 @@ class Compilation {
   /// Experiment with source-range-based dependencies
   const bool EnableSourceRangeDependencies;
 
+  /// (experimental) Enable cross-module incremental build scheduling.
+  const bool EnableCrossModuleIncrementalBuild;
+
 public:
   /// Will contain a comparator if an argument demands it.
   Optional<IncrementalSchemeComparator> IncrementalComparator;
@@ -313,7 +307,6 @@ class Compilation {
               std::unique_ptr<llvm::opt::DerivedArgList> TranslatedArgs,
               InputFileList InputsWithTypes,
               std::string CompilationRecordPath,
-              bool OutputCompilationRecordForModuleOnlyBuild,
               StringRef ArgsHash, llvm::sys::TimePoint<> StartTime,
               llvm::sys::TimePoint<> LastBuildTime,
               size_t FilelistThreshold,
@@ -333,7 +326,8 @@ class Compilation {
               bool FineGrainedDependenciesIncludeIntrafileOnes = false,
               bool EnableSourceRangeDependencies = false,
               bool CompareIncrementalSchemes = false,
-              StringRef CompareIncrementalSchemesPath = "");
+              StringRef CompareIncrementalSchemesPath = "",
+              bool EnableCrossModuleIncrementalBuild = false);
   // clang-format on
   ~Compilation();
 
@@ -439,6 +433,10 @@ class Compilation {
     return ShowDriverTimeCompilation;
   }
 
+  bool getEnableCrossModuleIncrementalBuild() const {
+    return EnableCrossModuleIncrementalBuild;
+  }
+
   size_t getFilelistThreshold() const {
     return FilelistThreshold;
   }

include/swift/Frontend/FrontendOptions.h

@@ -276,6 +276,14 @@ class FrontendOptions {
   /// of the main Swift module's source files.
   bool ImportPrescan = false;
 
+  /// When performing an incremental build, ensure that cross-module incremental
+  /// build metadata is available in any swift modules emitted by this frontend
+  /// job.
+  ///
+  /// This flag is currently only propagated from the driver to
+  /// any merge-modules jobs.
+  bool EnableExperimentalCrossModuleIncrementalBuild = false;
+
   /// The different modes for validating TBD against the LLVM IR.
   enum class TBDValidationMode {
     Default,        ///< Do the default validation for the current platform.

include/swift/Option/Options.td

@@ -584,6 +584,11 @@ def experimental_cxx_stdlib :
   Separate<["-"], "experimental-cxx-stdlib">,
   HelpText<"C++ standard library to use; forwarded to Clang's -stdlib flag">;
 
+def enable_experimental_cross_module_incremental_build :
+  Flag<["-"], "enable-experimental-cross-module-incremental-build">,
+  HelpText<"(experimental) Enable cross-module incremental build metadata and "
+           "driver scheduling">;
+
 
 // Diagnostic control options
 def suppress_warnings : Flag<["-"], "suppress-warnings">,

include/swift/SIL/SILCloner.h

@@ -1542,6 +1542,13 @@ template <typename ImplClass>
 void SILCloner<ImplClass>::visitUncheckedValueCastInst(
     UncheckedValueCastInst *Inst) {
   getBuilder().setCurrentDebugScope(getOpScope(Inst->getDebugScope()));
+  if (!getBuilder().hasOwnership()) {
+    recordClonedInstruction(Inst, getBuilder().createUncheckedBitwiseCast(
+                                      getOpLocation(Inst->getLoc()),
+                                      getOpValue(Inst->getOperand()),
+                                      getOpType(Inst->getType())));
+    return;
+  }
   recordClonedInstruction(Inst, getBuilder().createUncheckedValueCast(
                                     getOpLocation(Inst->getLoc()),
                                     getOpValue(Inst->getOperand()),

include/swift/SIL/SILModule.h

@@ -263,6 +263,15 @@ class SILModule {
   /// to ensure that the module is serialized only once.
   bool serialized;
 
+  /// Set if we have registered a deserialization notification handler for
+  /// lowering ownership in non transparent functions.
+  /// This gets set in NonTransparent OwnershipModelEliminator pass.
+  bool regDeserializationNotificationHandlerForNonTransparentFuncOME;
+  /// Set if we have registered a deserialization notification handler for
+  /// lowering ownership in transparent functions.
+  /// This gets set in OwnershipModelEliminator pass.
+  bool regDeserializationNotificationHandlerForAllFuncOME;
+
   /// Action to be executed for serializing the SILModule.
   ActionCallback SerializeSILAction;
 
@@ -301,6 +310,19 @@ class SILModule {
     deserializationNotificationHandlers.erase(handler);
   }
 
+  bool hasRegisteredDeserializationNotificationHandlerForNonTransparentFuncOME() {
+    return regDeserializationNotificationHandlerForNonTransparentFuncOME;
+  }
+  bool hasRegisteredDeserializationNotificationHandlerForAllFuncOME() {
+    return regDeserializationNotificationHandlerForAllFuncOME;
+  }
+  void setRegisteredDeserializationNotificationHandlerForNonTransparentFuncOME() {
+    regDeserializationNotificationHandlerForNonTransparentFuncOME = true;
+  }
+  void setRegisteredDeserializationNotificationHandlerForAllFuncOME() {
+    regDeserializationNotificationHandlerForAllFuncOME = true;
+  }
+
   /// Add a delete notification handler \p Handler to the module context.
   void registerDeleteNotificationHandler(DeleteNotificationHandler* Handler);
 

include/swift/SILOptimizer/PassManager/PassManager.h

@@ -281,6 +281,11 @@ class SILPassManager {
   /// Run the passes in Transform from \p FromTransIdx to \p ToTransIdx.
   void runFunctionPasses(unsigned FromTransIdx, unsigned ToTransIdx);
 
+  /// Helper function to check if the function pass should be run mandatorily
+  /// All passes in mandatory pass pipeline and ownership model elimination are
+  /// mandatory function passes.
+  bool isMandatoryFunctionPass(SILFunctionTransform *);
+
   /// A helper function that returns (based on SIL stage and debug
   /// options) whether we should continue running passes.
   bool continueTransforming();

include/swift/Serialization/SerializationOptions.h

@@ -131,6 +131,7 @@ namespace swift {
     bool SerializeAllSIL = false;
     bool SerializeOptionsForDebugging = false;
     bool IsSIB = false;
+    bool ExperimentalCrossModuleIncrementalInfo = false;
   };
 
 } // end namespace swift

include/swift/Serialization/SerializedModuleLoader.h

@@ -153,7 +153,7 @@ class SerializedModuleLoaderBase : public ModuleLoader {
   ///
   /// If the AST cannot be loaded and \p diagLoc is present, a diagnostic is
   /// printed. (Note that \p diagLoc is allowed to be invalid.)
-  FileUnit *
+  LoadedFile *
   loadAST(ModuleDecl &M, Optional<SourceLoc> diagLoc,
           StringRef moduleInterfacePath,
           std::unique_ptr<llvm::MemoryBuffer> moduleInputBuffer,

include/swift/Subsystems.h

@@ -75,6 +75,10 @@ namespace swift {
     class TypeConverter;
   }
 
+  namespace fine_grained_dependencies {
+    class SourceFileDepGraph;
+  }
+
   /// @{
 
   /// \returns true if the declaration should be verified.  This can return
@@ -174,8 +178,10 @@ namespace swift {
   using ModuleOrSourceFile = PointerUnion<ModuleDecl *, SourceFile *>;
 
   /// Serializes a module or single source file to the given output file.
-  void serialize(ModuleOrSourceFile DC, const SerializationOptions &options,
-                 const SILModule *M = nullptr);
+  void
+  serialize(ModuleOrSourceFile DC, const SerializationOptions &options,
+            const SILModule *M = nullptr,
+            const fine_grained_dependencies::SourceFileDepGraph *DG = nullptr);
 
   /// Serializes a module or single source file to the given output file and
   /// returns back the file's contents as a memory buffer.