Merge branch 'main' into es-pkg-err

Author: elsh

SwiftCompilerSources/Sources/_RegexParser/CMakeLists.txt

@@ -7,13 +7,13 @@
 # See http://swift.org/CONTRIBUTORS.txt for Swift project authors
 
 file(GLOB_RECURSE _LIBSWIFT_REGEX_PARSER_SOURCES
-  "${EXPERIMENTAL_STRING_PROCESSING_SOURCE_DIR}/Sources/_RegexParser/*.swift")
+  "${SWIFT_PATH_TO_STRING_PROCESSING_SOURCE}/Sources/_RegexParser/*.swift")
 set(LIBSWIFT_REGEX_PARSER_SOURCES)
 foreach(source ${_LIBSWIFT_REGEX_PARSER_SOURCES})
   file(TO_CMAKE_PATH "${source}" source)
   list(APPEND LIBSWIFT_REGEX_PARSER_SOURCES ${source})
 endforeach()
-message(STATUS "Using Experimental String Processing library for libswift _RegexParser (${EXPERIMENTAL_STRING_PROCESSING_SOURCE_DIR}).")
+message(STATUS "Using Experimental String Processing library for libswift _RegexParser (${SWIFT_PATH_TO_STRING_PROCESSING_SOURCE}).")
 
 add_swift_compiler_module(_CompilerRegexParser
   SOURCES

docs/ABI/Mangling.rst

@@ -149,6 +149,7 @@ Globals
   #endif
   global ::= protocol-conformance 'Hc'   // protocol conformance runtime record
   global ::= global 'HF'                 // accessible function runtime record
+  global ::= global 'Ha'                 // runtime discoverable attribute record
 
   global ::= nominal-type 'Mo'           // class metadata immediate member base offset
 
@@ -346,6 +347,7 @@ Entities
   entity-spec ::= type 'fU' INDEX            // explicit anonymous closure expression
   entity-spec ::= type 'fu' INDEX            // implicit anonymous closure
   entity-spec ::= 'fA' INDEX                 // default argument N+1 generator
+  entity-spec ::= 'fa'                       // runtime discoverable attribute generator
   entity-spec ::= 'fi'                       // non-local variable initializer
   entity-spec ::= 'fP'                       // property wrapper backing initializer
   entity-spec ::= 'fW'                       // property wrapper init from projected value
@@ -653,6 +655,7 @@ Types
   type ::= assoc-type-name 'Qz'                      // shortcut for 'Qyz'
   type ::= assoc-type-list 'QY' GENERIC-PARAM-INDEX  // associated type at depth
   type ::= assoc-type-list 'QZ'                      // shortcut for 'QYz'
+  type ::= opaque-type-decl-name bound-generic-args 'Qo' INDEX // opaque type
   
   type ::= pattern-type count-type 'Qp'      // pack expansion type
   type ::= pack-element-list 'QP'            // pack type

include/swift/ABI/Metadata.h

@@ -648,9 +648,9 @@ struct TargetClassMetadataBounds : TargetMetadataBounds<Runtime> {
   /// Return the basic bounds of all Swift class metadata.
   /// The immediate members offset will not be meaningful.
   static constexpr TargetClassMetadataBounds<Runtime> forSwiftRootClass() {
-    using Metadata = FullMetadata<TargetClassMetadataType<Runtime>>;
-    return forAddressPointAndSize(sizeof(typename Metadata::HeaderType),
-                                  sizeof(Metadata));
+    using MetadataTy = FullMetadata<TargetClassMetadataType<Runtime>>;
+    return forAddressPointAndSize(sizeof(typename MetadataTy::HeaderType),
+                                  sizeof(MetadataTy));
   }
 
   /// Return the bounds of a Swift class metadata with the given address
@@ -4736,6 +4736,45 @@ struct TargetAccessibleFunctionRecord final {
 
 using AccessibleFunctionRecord = TargetAccessibleFunctionRecord<InProcess>;
 
+/// A single entry in an runtine discoverable attribute record
+/// that relates a type attribute is attached to a generator function.
+template <typename Runtime>
+struct TargetRuntimeDiscoverableAttributeEntry {
+  ConstTargetMetadataPointer<Runtime, TargetMetadata> Type;
+  RelativeDirectPointer<TargetAccessibleFunctionRecord<Runtime>> Generator;
+};
+
+/// A record that relates a runtime discoverable attribute to all of the
+/// types (i.e. a nominal type, method, property etc.) it's attached to.
+template <typename Runtime>
+class RuntimeDiscoverableAttributeRecord
+    : private swift::ABI::TrailingObjects<
+          RuntimeDiscoverableAttributeRecord<Runtime>,
+          TargetRuntimeDiscoverableAttributeEntry<Runtime>> {
+  using TrailingObjects = swift::ABI::TrailingObjects<
+      RuntimeDiscoverableAttributeRecord<Runtime>,
+      ConstTargetMetadataPointer<Runtime, TargetMetadata>>;
+  friend TrailingObjects;
+
+  uint32_t flags;
+
+  /// The nominal type that describes the attribute.
+  TargetSignedContextPointer<Runtime, TargetTypeContextDescriptor> Attribute;
+
+  /// The number of types this attribute is associated with.
+  uint32_t numEntries;
+
+public:
+  uint32_t getFlags() { return flags; }
+
+  llvm::ArrayRef<TargetRuntimeDiscoverableAttributeEntry<Runtime>>
+  getEntries() const {
+    return {this->template getTrailingObjects<
+                TargetRuntimeDiscoverableAttributeEntry<Runtime>>(),
+            numEntries};
+  }
+};
+
 } // end namespace swift
 
 #pragma clang diagnostic pop

include/swift/AST/ASTContext.h

@@ -87,7 +87,7 @@ namespace swift {
   class LazyContextData;
   class LazyIterableDeclContextData;
   class LazyMemberLoader;
-  class ModuleDependencies;
+  class ModuleDependencyInfo;
   class PatternBindingDecl;
   class PatternBindingInitializer;
   class SourceFile;
@@ -993,16 +993,16 @@ class ASTContext final {
   ///
   /// \param isUnderlyingClangModule When true, only look for a Clang module
   /// with the given name, ignoring any Swift modules.
-  Optional<ModuleDependencies> getModuleDependencies(
+  Optional<ModuleDependencyInfo> getModuleDependencies(
       StringRef moduleName,
       bool isUnderlyingClangModule,
       ModuleDependenciesCache &cache,
       InterfaceSubContextDelegate &delegate,
       bool cacheOnly = false,
-      llvm::Optional<std::pair<std::string, swift::ModuleDependenciesKind>> dependencyOf = None);
+      llvm::Optional<std::pair<std::string, swift::ModuleDependencyKind>> dependencyOf = None);
 
   /// Retrieve the module dependencies for the Swift module with the given name.
-  Optional<ModuleDependencies> getSwiftModuleDependencies(
+  Optional<ModuleDependencyInfo> getSwiftModuleDependencies(
       StringRef moduleName,
       ModuleDependenciesCache &cache,
       InterfaceSubContextDelegate &delegate);

include/swift/AST/ASTMangler.h

@@ -158,6 +158,7 @@ class ASTMangler : public Mangler {
     BackDeploymentThunk,
     BackDeploymentFallback,
     HasSymbolQuery,
+    RuntimeDiscoverableAttributeRecord,
   };
 
   /// lldb overrides the defaulted argument to 'true'.
@@ -360,6 +361,10 @@ class ASTMangler : public Mangler {
 
   std::string mangleHasSymbolQuery(const ValueDecl *decl);
 
+  std::string
+  mangleRuntimeAttributeGeneratorEntity(const ValueDecl *decl, CustomAttr *attr,
+                                        SymbolKind SKind = SymbolKind::Default);
+
   enum SpecialContext {
     ObjCContext,
     ClangImporterContext,
@@ -584,6 +589,9 @@ class ASTMangler : public Mangler {
 
   void appendConstrainedExistential(Type base, GenericSignature sig,
                                     const ValueDecl *forDecl);
+
+  void appendRuntimeAttributeGeneratorEntity(const ValueDecl *decl,
+                                             CustomAttr *attr);
 };
 
 } // end namespace Mangle

include/swift/AST/Decl.h

@@ -2794,6 +2794,22 @@ class ValueDecl : public Decl {
   /// 'func foo(Int) -> () -> Self?'.
   GenericParameterReferenceInfo findExistentialSelfReferences(
       Type baseTy, bool treatNonResultCovariantSelfAsInvariant) const;
+
+  /// Retrieve runtime discoverable attributes (if any) associated
+  /// with this declaration.
+  ArrayRef<CustomAttr *> getRuntimeDiscoverableAttrs() const;
+  /// Retrieve a nominal type declaration backing given runtime discoverable
+  /// attribute.
+  ///
+  /// FIXME: This should be a more general facility but its unclear where
+  ///        to place it for maximum impact.
+  NominalTypeDecl *getRuntimeDiscoverableAttrTypeDecl(CustomAttr *attr) const;
+
+  /// Given a runtime discoverable attribute, return a generator
+  /// which could be used to instantiate it for this declaration
+  /// together with its result type.
+  std::pair<BraceStmt *, Type>
+  getRuntimeDiscoverableAttributeGenerator(CustomAttr *) const;
 };
 
 /// This is a common base class for declarations which declare a type.

include/swift/AST/DiagnosticsParse.def

@@ -2014,9 +2014,9 @@ ERROR(macro_expansion_decl_expected_macro_identifier,none,
       "expected a macro identifier for a pound literal declaration", ())
 
 ERROR(parser_round_trip_error,none,
-      "source file did not round-trip through the Swift Swift parser", ())
+      "source file did not round-trip through the new Swift parser", ())
 ERROR(parser_new_parser_errors,none,
-      "Swift Swift parser generated errors for code that C++ parser accepted",
+      "new Swift parser generated errors for code that C++ parser accepted",
        ())
 
 #define UNDEFINE_DIAGNOSTIC_MACROS

include/swift/AST/DiagnosticsSema.def

@@ -5164,6 +5164,9 @@ ERROR(multiple_ellipsis_in_tuple,none,
 ERROR(expansion_not_same_shape,none,
       "variadic expansion %0 requires that %1 and %2 have the same shape",
       (Type, Type, Type))
+ERROR(expansion_expr_not_same_shape,none,
+      "pack expansion requires that %0 and %1 have the same shape",
+      (Type, Type))
 
 ERROR(enum_element_ellipsis,none,
       "variadic enum cases are not supported", ())
@@ -6803,6 +6806,28 @@ ERROR(moveonly_cannot_conform_to_protocol_with_name, none,
 ERROR(runtime_discoverable_attrs_are_experimental,none,
       "runtime discoverable attributes are an experimental feature", ())
 
+ERROR(invalid_decl_for_runtime_discoverable_attr,none,
+      "@%0 can only be applied to non-generic types, methods, "
+      "instance properties, and global functions", (StringRef))
+
+ERROR(duplicate_runtime_discoverable_attr,none,
+      "duplicate runtime discoverable attribute", ())
+
+ERROR(runtime_attribute_requires_init,none,
+      "runtime attribute type %0 does not contain a required initializer"
+      " - init(attachedTo:)",
+      (DeclName))
+
+ERROR(runtime_attribute_type_failable_init,none,
+      "runtime attribute type initializer %0 cannot be failable", (DeclName))
+
+ERROR(runtime_attribute_type_requirement_not_accessible,none,
+      "%select{private|fileprivate|internal|public|open}0 %1 %2 cannot have "
+      "more restrictive access than its enclosing runtime attribute type %3 "
+      "(which is %select{private|fileprivate|internal|public|open}4)",
+      (AccessLevel, DescriptiveDeclKind, DeclName, Type, AccessLevel))
+
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"
 

include/swift/AST/Expr.h

@@ -3584,10 +3584,6 @@ class PackExpansionExpr final : public Expr,
     : Expr(ExprKind::PackExpansion, implicit, type),
       PatternExpr(patternExpr), DotsLoc(dotsLoc), Environment(environment) {
     Bits.PackExpansionExpr.NumBindings = packElements.size();
-
-    assert(Bits.PackExpansionExpr.NumBindings > 0 &&
-           "PackExpansionExpr must have pack references");
-
     std::uninitialized_copy(packElements.begin(), packElements.end(),
                             getTrailingObjects<PackElementExpr *>());
   }
@@ -3623,9 +3619,7 @@ class PackExpansionExpr final : public Expr,
     return {getTrailingObjects<PackElementExpr *>(), getNumBindings()};
   }
 
-  void setBinding(unsigned i, PackElementExpr *e) {
-    getMutableBindings()[i] = e;
-  }
+  void getExpandedPacks(SmallVectorImpl<ASTNode> &packs);
 
   GenericEnvironment *getGenericEnvironment() {
     return Environment;
@@ -3791,11 +3785,11 @@ class AbstractClosureExpr : public DeclContext, public Expr {
 
 public:
   AbstractClosureExpr(ExprKind Kind, Type FnType, bool Implicit,
-                      unsigned Discriminator, DeclContext *Parent)
+                      DeclContext *Parent)
       : DeclContext(DeclContextKind::AbstractClosureExpr, Parent),
         Expr(Kind, Implicit, FnType),
         parameterList(nullptr) {
-    Bits.AbstractClosureExpr.Discriminator = Discriminator;
+    Bits.AbstractClosureExpr.Discriminator = InvalidDiscriminator;
   }
 
   CaptureInfo getCaptureInfo() const { return Captures; }
@@ -3824,11 +3818,18 @@ class AbstractClosureExpr : public DeclContext, public Expr {
   /// optimization and therefore make it into e.g. stack traces.
   /// Having their symbol names be stable across minor code changes is
   /// therefore pretty useful for debugging.)
-  unsigned getDiscriminator() const {
+  unsigned getDiscriminator() const;
+
+  /// Retrieve the raw discriminator, which may not have been computed yet.
+  ///
+  /// Only use this for queries that are checking for (e.g.) reentrancy or
+  /// intentionally do not want to initiate verification.
+  unsigned getRawDiscriminator() const {
     return Bits.AbstractClosureExpr.Discriminator;
   }
+
   void setDiscriminator(unsigned discriminator) {
-    assert(getDiscriminator() == InvalidDiscriminator);
+    assert(getRawDiscriminator() == InvalidDiscriminator);
     assert(discriminator != InvalidDiscriminator);
     Bits.AbstractClosureExpr.Discriminator = discriminator;
   }
@@ -3987,9 +3988,9 @@ class ClosureExpr : public AbstractClosureExpr {
               SourceRange bracketRange, VarDecl *capturedSelfDecl,
               ParameterList *params, SourceLoc asyncLoc, SourceLoc throwsLoc,
               SourceLoc arrowLoc, SourceLoc inLoc, TypeExpr *explicitResultType,
-              unsigned discriminator, DeclContext *parent)
+              DeclContext *parent)
     : AbstractClosureExpr(ExprKind::Closure, Type(), /*Implicit=*/false,
-                          discriminator, parent),
+                          parent),
       Attributes(attributes), BracketRange(bracketRange),
       CapturedSelfDecl(capturedSelfDecl),
       AsyncLoc(asyncLoc), ThrowsLoc(throwsLoc), ArrowLoc(arrowLoc),
@@ -4185,10 +4186,9 @@ class AutoClosureExpr : public AbstractClosureExpr {
     AsyncLet = 3,
   };
 
-  AutoClosureExpr(Expr *Body, Type ResultTy, unsigned Discriminator,
-                  DeclContext *Parent)
+  AutoClosureExpr(Expr *Body, Type ResultTy, DeclContext *Parent)
       : AbstractClosureExpr(ExprKind::AutoClosure, ResultTy, /*Implicit=*/true,
-                            Discriminator, Parent) {
+                            Parent) {
     if (Body != nullptr)
       setBody(Body);
 

include/swift/AST/Initializer.h

@@ -36,6 +36,9 @@ enum class InitializerKind : uint8_t {
 
   /// A property wrapper initialization expression.
   PropertyWrapper,
+
+  /// A runtime discoverable attribute initialization expression.
+  RuntimeAttribute,
 };
 
 /// An Initializer is a kind of DeclContext used for expressions that
@@ -232,7 +235,36 @@ class PropertyWrapperInitializer : public Initializer {
     return I->getInitializerKind() == InitializerKind::PropertyWrapper;
   }
 };
-  
+
+/// A runtime discoverable attribute initialization expression context.
+///
+/// The parent context is context of the file/module this generator is
+/// synthesized in.
+class RuntimeAttributeInitializer : public Initializer {
+  CustomAttr *Attr;
+  ValueDecl *AttachedTo;
+
+public:
+  explicit RuntimeAttributeInitializer(CustomAttr *attr, ValueDecl *attachedTo)
+      : Initializer(InitializerKind::RuntimeAttribute,
+                    attachedTo->getDeclContext()->getModuleScopeContext()),
+        Attr(attr), AttachedTo(attachedTo) {}
+
+  CustomAttr *getAttr() const { return Attr; }
+
+  ValueDecl *getAttachedToDecl() const { return AttachedTo; }
+
+  static bool classof(const DeclContext *DC) {
+    if (auto init = dyn_cast<Initializer>(DC))
+      return classof(init);
+    return false;
+  }
+
+  static bool classof(const Initializer *I) {
+    return I->getInitializerKind() == InitializerKind::RuntimeAttribute;
+  }
+};
+
 } // end namespace swift
 
 #endif