Merge pull request #2914 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

include/swift/ABI/Task.h

@@ -519,17 +519,12 @@ class YieldingAsyncContext : public AsyncContext {
   TaskContinuationFunction * __ptrauth_swift_async_context_yield
     YieldToParent;
 
-  /// The executor that the parent context needs to be yielded to on.
-  ExecutorRef YieldToParentExecutor;
-
   YieldingAsyncContext(AsyncContextFlags flags,
                        TaskContinuationFunction *resumeParent,
                        TaskContinuationFunction *yieldToParent,
-                       ExecutorRef yieldToParentExecutor,
                        AsyncContext *parent)
     : AsyncContext(flags, resumeParent, parent),
-      YieldToParent(yieldToParent),
-      YieldToParentExecutor(yieldToParentExecutor) {}
+      YieldToParent(yieldToParent) {}
 
   static bool classof(const AsyncContext *context) {
     return context->Flags.getKind() == AsyncContextKind::Yielding;

include/swift/AST/DiagnosticsFrontend.def

@@ -36,6 +36,10 @@ ERROR(error_unsupported_target_os, none,
 ERROR(error_unsupported_target_arch, none,
       "unsupported target architecture: '%0'", (StringRef))
 
+ERROR(error_unknown_library_level, none,
+      "unknown library level '%0', "
+      "expected one of 'api', 'spi' or 'other'", (StringRef))
+
 ERROR(error_unsupported_opt_for_target, none,
       "unsupported option '%0' for target '%1'", (StringRef, StringRef))
 

include/swift/AST/DiagnosticsSema.def

@@ -2843,6 +2843,9 @@ WARNING(warn_implementation_only_conflict,none,
         (Identifier))
 NOTE(implementation_only_conflict_here,none,
      "imported as implementation-only here", ())
+WARNING(warn_public_import_of_private_module,none,
+        "private module %0 is imported publicly from the public module %1",
+        (Identifier, Identifier))
 
 ERROR(implementation_only_decl_non_override,none,
       "'@_implementationOnly' can only be used on overrides", ())

include/swift/AST/Module.h

@@ -56,6 +56,7 @@ namespace swift {
   class FileUnit;
   class FuncDecl;
   class InfixOperatorDecl;
+  enum class LibraryLevel : uint8_t;
   class LinkLibrary;
   class ModuleLoader;
   class NominalTypeDecl;
@@ -462,6 +463,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
     Bits.ModuleDecl.RawResilienceStrategy = unsigned(strategy);
   }
 
+  /// Distribution level of the module.
+  LibraryLevel getLibraryLevel() const;
+
   /// Returns true if this module was or is being compiled for testing.
   bool hasIncrementalInfo() const { return Bits.ModuleDecl.HasIncrementalInfo; }
   void setHasIncrementalInfo(bool enabled = true) {

include/swift/AST/TypeCheckRequests.h

@@ -2753,6 +2753,24 @@ class HasImplementationOnlyImportsRequest
   bool isCached() const { return true; }
 };
 
+/// Get the library level of a module.
+class ModuleLibraryLevelRequest
+    : public SimpleRequest<ModuleLibraryLevelRequest,
+                           LibraryLevel(const ModuleDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  LibraryLevel evaluate(Evaluator &evaluator, const ModuleDecl *module) const;
+
+public:
+  // Cached.
+  bool isCached() const { return true; }
+};
+
 class ResolveTypeRequest
     : public SimpleRequest<ResolveTypeRequest,
                            Type(const TypeResolution *, TypeRepr *,

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -126,6 +126,8 @@ SWIFT_REQUEST(TypeChecker, HasDynamicCallableAttributeRequest,
               bool(CanType), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, HasImplementationOnlyImportsRequest,
               bool(SourceFile *), Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ModuleLibraryLevelRequest,
+              LibraryLevel(ModuleDecl *), Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, InferredGenericSignatureRequest,
               GenericSignature (ModuleDecl *, const GenericSignatureImpl *,
                                  GenericParamSource,

include/swift/Basic/LangOptions.h

@@ -55,6 +55,20 @@ namespace swift {
     Complete,
   };
 
+  /// Access or distribution level of a library.
+  enum class LibraryLevel : uint8_t {
+    /// Application Programming Interface that is publicly distributed so
+    /// public decls are really public and only @_spi decls are SPI.
+    API,
+
+    /// System Programming Interface that has restricted distribution
+    /// all decls in the module are considered to be SPI including public ones.
+    SPI,
+
+    /// The library has some other undefined distribution.
+    Other
+  };
+
   /// A collection of options that affect the language dialect and
   /// provide compiler debugging facilities.
   class LangOptions final {
@@ -306,6 +320,9 @@ namespace swift {
     /// Objective-C-derived classes and 'dynamic' members.
     bool EnableSwift3ObjCInference = false;
 
+    /// Access or distribution level of the whole module being parsed.
+    LibraryLevel LibraryLevel = LibraryLevel::Other;
+
     /// Warn about cases where Swift 3 would infer @objc but later versions
     /// of Swift do not.
     Swift3ObjCInferenceWarnings WarnSwift3ObjCInference =

include/swift/Option/FrontendOptions.td

@@ -433,6 +433,11 @@ def disable_swift3_objc_inference :
   Flags<[FrontendOption, HelpHidden]>,
   HelpText<"Disable Swift 3's @objc inference rules for NSObject-derived classes and 'dynamic' members (emulates Swift 4 behavior)">;
 
+def library_level : Separate<["-"], "library-level">,
+  MetaVarName<"<level>">,
+  Flags<[FrontendOption]>,
+  HelpText<"Library distribution level 'api', 'spi' or 'other' (the default)">;
+
 def enable_implicit_dynamic : Flag<["-"], "enable-implicit-dynamic">,
   Flags<[FrontendOption, NoInteractiveOption, HelpHidden]>,
   HelpText<"Add 'dynamic' to all declarations">;

include/swift/Strings.h

@@ -124,7 +124,7 @@ constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_JOB = {
     "Builtin.Job"};
 /// The name of the Builtin type for ExecutorRef
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_EXECUTOR = {
-    "Builtin.ExecutorRef"};
+    "Builtin.Executor"};
 /// The name of the Builtin type for DefaultActorStorage
 constexpr static BuiltinNameStringLiteral BUILTIN_TYPE_NAME_DEFAULTACTORSTORAGE = {
     "Builtin.DefaultActorStorage"};

include/swift/Syntax/RawSyntax.h

@@ -218,31 +218,41 @@ class RawSyntax final
   }
 
   /// Constructor for creating layout nodes.
-  /// If the node has been allocated inside the bump allocator of a
-  /// \c SyntaxArena, that arena must be passed as \p Arena to retain the node's
-  /// underlying storage.
+  /// \p Children is an iterator that provides the child \c RawSyntax nodes.
+  /// It is only traversed once.
+  /// \p NumChildren is the number of elements provided by the \p Children
+  /// iterator.
   /// If \p NodeId is \c None, the next free NodeId is used, if it is passed,
   /// the caller needs to assure that the node ID has not been used yet.
-  RawSyntax(SyntaxKind Kind, ArrayRef<const RawSyntax *> Layout,
-            size_t TextLength, SourcePresence Presence,
+  template <typename ChildrenIteratorType>
+  RawSyntax(SyntaxKind Kind, ChildrenIteratorType ChildrenIt,
+            uint32_t NumChildren, SourcePresence Presence,
             const RC<SyntaxArena> &Arena, llvm::Optional<SyntaxNodeId> NodeId)
-      : Arena(Arena.get()), TextLength(uint32_t(TextLength)),
+      : Arena(Arena.get()), TextLength(0 /*computed in body*/),
         Presence(Presence), IsToken(false),
-        Bits(LayoutData{uint32_t(Layout.size()),
-                        /*TotalSubNodeCount=*/0, /*set in body*/
-                        Kind}) {
+        Bits(LayoutData{NumChildren,
+                        /*TotalSubNodeCount=*/0 /*computed in body*/, Kind}) {
     assert(Arena && "RawSyntax nodes must always be allocated in an arena");
     assert(
         Kind != SyntaxKind::Token &&
         "'token' syntax node must be constructed with dedicated constructor");
 
-    for (auto Child : Layout) {
+    const RawSyntax **TrailingChildren =
+        getTrailingObjects<const RawSyntax *>();
+    for (uint32_t I = 0; I < NumChildren;
+         ++I, ++ChildrenIt, ++TrailingChildren) {
+      const RawSyntax *Child = *ChildrenIt;
       if (Child) {
+        // Compute TextLength and TotalSubNodeCount of this node in place.
+        TextLength += Child->getTextLength();
         Bits.Layout.TotalSubNodeCount += Child->getTotalSubNodeCount() + 1;
+
         // If the child is stored in a different arena, it needs to stay alive
         // as long as this node's arena is alive.
         Arena->addChildArena(Child->Arena);
       }
+
+      *TrailingChildren = Child;
     }
 
     if (NodeId.hasValue()) {
@@ -251,10 +261,6 @@ class RawSyntax final
     } else {
       this->NodeId = NextFreeNodeId++;
     }
-
-    // Initialize layout data.
-    std::uninitialized_copy(Layout.begin(), Layout.end(),
-                            getTrailingObjects<const RawSyntax *>());
   }
 
   /// Constructor for creating token nodes
@@ -311,28 +317,26 @@ class RawSyntax final
   /// @{
 
   /// Make a raw "layout" syntax node.
+  template <typename ChildrenIteratorType>
   static const RawSyntax *
-  make(SyntaxKind Kind, ArrayRef<const RawSyntax *> Layout, size_t TextLength,
+  make(SyntaxKind Kind, ChildrenIteratorType ChildrenIt, size_t NumChildren,
        SourcePresence Presence, const RC<SyntaxArena> &Arena,
        llvm::Optional<SyntaxNodeId> NodeId = llvm::None) {
     assert(Arena && "RawSyntax nodes must always be allocated in an arena");
-    auto size = totalSizeToAlloc<const RawSyntax *>(Layout.size());
+    auto size = totalSizeToAlloc<const RawSyntax *>(NumChildren);
     void *data = Arena->Allocate(size, alignof(RawSyntax));
     return new (data)
-        RawSyntax(Kind, Layout, TextLength, Presence, Arena, NodeId);
+        RawSyntax(Kind, ChildrenIt, NumChildren, Presence, Arena, NodeId);
   }
 
+  /// Convenience constructor to create a raw "layout" syntax node from an
+  /// \c llvm::ArrayRef containing the children.
   static const RawSyntax *
-  makeAndCalcLength(SyntaxKind Kind, ArrayRef<const RawSyntax *> Layout,
-                    SourcePresence Presence, const RC<SyntaxArena> &Arena,
-                    llvm::Optional<SyntaxNodeId> NodeId = llvm::None) {
-    size_t TextLength = 0;
-    for (auto Child : Layout) {
-      if (Child) {
-        TextLength += Child->getTextLength();
-      }
-    }
-    return make(Kind, Layout, TextLength, Presence, Arena, NodeId);
+  make(SyntaxKind Kind, llvm::ArrayRef<const RawSyntax *> Children,
+       SourcePresence Presence, const RC<SyntaxArena> &Arena,
+       llvm::Optional<SyntaxNodeId> NodeId = llvm::None) {
+    return make(Kind, Children.begin(), Children.size(), Presence, Arena,
+                NodeId);
   }
 
   /// Make a raw "token" syntax node.
@@ -367,7 +371,7 @@ class RawSyntax final
   /// Make a missing raw "layout" syntax node.
   static const RawSyntax *missing(SyntaxKind Kind,
                                   const RC<SyntaxArena> &Arena) {
-    return make(Kind, {}, /*TextLength=*/0, SourcePresence::Missing, Arena);
+    return make(Kind, {}, SourcePresence::Missing, Arena);
   }
 
   /// Make a missing raw "token" syntax node.