Merge pull request #62426 from xedin/runtime-discoverable-attrs

[Sema/SILGen/IRGen] Implement runtime discoverable attributes (under flag)

Author: xedin

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

include/swift/ABI/Metadata.h

@@ -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/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/DiagnosticsSema.def

@@ -6803,6 +6803,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/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

include/swift/AST/KnownIdentifiers.def

@@ -333,6 +333,9 @@ IDENTIFIER(unsafe)
 // The singleton instance of TupleTypeDecl in the Builtin module
 IDENTIFIER(TheTupleType)
 
+// Runtime attributes
+IDENTIFIER(attachedTo)
+
 #undef IDENTIFIER
 #undef IDENTIFIER_
 #undef IDENTIFIER_WITH_NAME

include/swift/AST/SourceFile.h

@@ -150,6 +150,10 @@ class SourceFile final : public FileUnit {
   /// been validated.
   llvm::SetVector<ValueDecl *> UnvalidatedDeclsWithOpaqueReturnTypes;
 
+  /// The set of declarations with valid runtime discoverable attributes
+  /// located in the source file.
+  llvm::SetVector<ValueDecl *> DeclsWithRuntimeDiscoverableAttrs;
+
   /// The list of top-level items in the source file. This is \c None if
   /// they have not yet been parsed.
   /// FIXME: Once addTopLevelDecl/prependTopLevelDecl
@@ -209,6 +213,10 @@ class SourceFile final : public FileUnit {
   /// Add a hoisted declaration. See Decl::isHoisted().
   void addHoistedDecl(Decl *d);
 
+  /// Add a declaration with any number of runtime disoverable attributes
+  /// associated with it.
+  void addDeclWithRuntimeDiscoverableAttrs(ValueDecl *);
+
   /// Retrieves an immutable view of the list of top-level items in this file.
   ArrayRef<ASTNode> getTopLevelItems() const;
 
@@ -221,6 +229,10 @@ class SourceFile final : public FileUnit {
   /// See Decl::isHoisted().
   ArrayRef<Decl *> getHoistedDecls() const;
 
+  /// Retrieves an immutable view of the set of all declaration with runtime
+  /// discoverable attributes located in this file.
+  ArrayRef<ValueDecl *> getDeclsWithRuntimeDiscoverableAttrs() const;
+
   /// Retrieves an immutable view of the top-level items if they have already
   /// been parsed, or \c None if they haven't. Should only be used for dumping.
   Optional<ArrayRef<ASTNode>> getCachedTopLevelItems() const {

include/swift/AST/TypeCheckRequests.h

@@ -3374,6 +3374,10 @@ enum class CustomAttrTypeKind {
   /// Global actors are represented as custom type attributes. They don't
   /// have any particularly interesting semantics.
   GlobalActor,
+
+  /// Attributes that are discoverable/constructable at runtime given a name.
+  /// They allow unbound generic types.
+  RuntimeMetadata,
 };
 
 void simple_display(llvm::raw_ostream &out, CustomAttrTypeKind value);
@@ -3792,6 +3796,57 @@ class MacroDefinitionRequest
   bool isCached() const { return true; }
 };
 
+class GetRuntimeDiscoverableAttributes
+    : public SimpleRequest<GetRuntimeDiscoverableAttributes,
+                           ArrayRef<CustomAttr *>(ValueDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  ArrayRef<CustomAttr *> evaluate(Evaluator &evaluator, ValueDecl *decl) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
+class SynthesizeRuntimeMetadataAttrGenerator
+    : public SimpleRequest<SynthesizeRuntimeMetadataAttrGenerator,
+                           Expr *(CustomAttr *, ValueDecl *),
+                           RequestFlags::Cached> {
+
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  Expr *evaluate(Evaluator &evaluator, CustomAttr *attr,
+                 ValueDecl *attachedTo) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
+class SynthesizeRuntimeMetadataAttrGeneratorBody
+    : public SimpleRequest<SynthesizeRuntimeMetadataAttrGeneratorBody,
+                           BraceStmt *(CustomAttr *, ValueDecl *),
+                           RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  BraceStmt *evaluate(Evaluator &evaluator, CustomAttr *attr,
+                      ValueDecl *attachedTo) const;
+
+public:
+  bool isCached() const { return true; }
+};
+
 /// Compute the local discriminators for the given declaration context.
 ///
 /// This is a state-changing operation for closures within the context, which

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -449,6 +449,15 @@ SWIFT_REQUEST(TypeChecker, UsesTypeWrapperFeature,
 SWIFT_REQUEST(TypeChecker, MacroDefinitionRequest,
               MacroDefinition(MacroDecl *),
               Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGenerator,
+              Expr *(CustomAttr *, ValueDecl *),
+              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, SynthesizeRuntimeMetadataAttrGeneratorBody,
+              BraceStmt *(CustomAttr *, ValueDecl *),
+              Cached, NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, GetRuntimeDiscoverableAttributes,
+              ArrayRef<CustomAttr *>(ValueDecl *),
+              Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, LocalDiscriminatorsRequest,
               unsigned(DeclContext *),
               Cached, NoLocationInfo)

include/swift/Demangling/DemangleNodes.def

@@ -351,6 +351,8 @@ NODE(SymbolicExtendedExistentialType)
 // Added in Swift 5.8
 NODE(MetatypeParamsRemoved)
 NODE(HasSymbolQuery)
+NODE(RuntimeDiscoverableAttributeRecord)
+CONTEXT_NODE(RuntimeAttributeGenerator)
 
 #undef CONTEXT_NODE
 #undef NODE

include/swift/IRGen/Linking.h

@@ -341,6 +341,11 @@ class LinkEntity {
     /// the metadata cache once.
     CanonicalPrespecializedGenericTypeCachingOnceToken,
 
+    /// The record that describes an attribute that could be looked
+    /// up at runtime together with all types it's attached to and
+    /// generator functions.
+    RuntimeDiscoverableAttributeRecord,
+
     /// The same as AsyncFunctionPointer but with a different stored value, for
     /// use by TBDGen.
     /// The pointer is an AbstractFunctionDecl*.
@@ -1380,6 +1385,12 @@ class LinkEntity {
     return entity;
   }
 
+  static LinkEntity forRuntimeDiscoverableAttributeRecord(NominalTypeDecl *attr) {
+    LinkEntity entity;
+    entity.setForDecl(Kind::RuntimeDiscoverableAttributeRecord, attr);
+    return entity;
+  }
+
   void mangle(llvm::raw_ostream &out) const;
   void mangle(SmallVectorImpl<char> &buffer) const;
   std::string mangleAsString() const;