Merge pull request #2859 from swiftwasm/katei/merge-main-2021-03-14

Merge main 2021-03-14

Author: kateinoigakukun

CHANGELOG.md

@@ -6,6 +6,7 @@ CHANGELOG
 
 | Version                | Released   | Toolchain   |
 | :--------------------- | :--------- | :---------- |
+| [Swift 5.5](#swift-55) |            |             |
 | [Swift 5.4](#swift-54) |            |             |
 | [Swift 5.3](#swift-53) | 2020-09-16 | Xcode 12.0  |
 | [Swift 5.2](#swift-52) | 2020-03-24 | Xcode 11.4  |
@@ -25,8 +26,8 @@ CHANGELOG
 
 </details>
 
-Swift Next
-----------
+Swift 5.5
+---------
 
 * [SE-0299][]:
 
@@ -8383,6 +8384,7 @@ Swift 1.0
 [SE-0296]: <https://github.com/apple/swift-evolution/blob/main/proposals/0296-async-await.md>
 [SE-0297]: <https://github.com/apple/swift-evolution/blob/main/proposals/0297-concurrency-objc.md>
 [SE-0298]: <https://github.com/apple/swift-evolution/blob/main/proposals/0298-asyncsequence.md>
+[SE-0299]: <https://github.com/apple/swift-evolution/blob/main/proposals/0299-extend-generic-static-member-lookup.md>
 
 [SR-75]: <https://bugs.swift.org/browse/SR-75>
 [SR-106]: <https://bugs.swift.org/browse/SR-106>

docs/SIL.rst

@@ -3466,7 +3466,7 @@ debug_value
 
 ::
 
-  sil-instruction ::= debug_value sil-operand (',' debug-var-attr)*
+  sil-instruction ::= debug_value '[poison]'? sil-operand (',' debug-var-attr)*
 
   debug_value %1 : $Int
 
@@ -3488,6 +3488,15 @@ variable that is being described, including the name of the
 variable. For function and closure arguments ``argno`` is the number
 of the function argument starting with 1.
 
+If the '[poison]' flag is set, then all references within this debug
+value will be overwritten with a sentinel at this point in the
+program. This is used in debug builds when shortening non-trivial
+value lifetimes to ensure the debugger cannot inspect invalid
+memory. `debug_value` instructions with the poison flag are not
+generated until OSSA islowered. They are not expected to be serialized
+within the module, and the pipeline is not expected to do any
+significant code motion after lowering.
+
 debug_value_addr
 ````````````````
 

include/swift/ABI/Metadata.h

@@ -1333,6 +1333,26 @@ struct TargetClassMetadata : public TargetAnyClassMetadata<Runtime> {
 };
 using ClassMetadata = TargetClassMetadata<InProcess>;
 
+/// The structure of class metadata that's compatible with dispatch objects.
+/// This includes Swift heap metadata, followed by the vtable entries that
+/// dispatch expects to see, with padding to place them at the expected offsets.
+template <typename Runtime>
+struct TargetDispatchClassMetadata : public TargetHeapMetadata<Runtime> {
+  using DummyVTableCall = void (*)(void);
+
+  TargetDispatchClassMetadata(MetadataKind Kind,
+                              DummyVTableCall DummyVTableEntry)
+      : TargetHeapMetadata<Runtime>(Kind), DummyVTableEntry(DummyVTableEntry) {}
+
+  TargetPointer<Runtime, void> Opaque;
+#if SWIFT_OBJC_INTEROP
+  TargetPointer<Runtime, void> OpaqueObjC[3];
+#endif
+
+  TargetSignedPointer<Runtime, DummyVTableCall> DummyVTableEntry;
+};
+using DispatchClassMetadata = TargetDispatchClassMetadata<InProcess>;
+
 /// The structure of metadata for heap-allocated local variables.
 /// This is non-type metadata.
 template <typename Runtime>

include/swift/ABI/MetadataKind.def

@@ -89,6 +89,10 @@ METADATAKIND(ErrorObject,
 METADATAKIND(Task,
              2 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
 
+/// A non-task async job.
+METADATAKIND(Job,
+             3 | MetadataKindIsNonType | MetadataKindIsRuntimePrivate)
+
 // getEnumeratedMetadataKind assumes that all the enumerated values here
 // will be <= LastEnumeratedMetadataKind.
 

include/swift/ABI/Task.h

@@ -36,8 +36,10 @@ struct SwiftError;
 class TaskStatusRecord;
 class TaskGroup;
 
+extern FullMetadata<DispatchClassMetadata> jobHeapMetadata;
+
 /// A schedulable job.
-class alignas(2 * alignof(void*)) Job {
+class alignas(2 * alignof(void*)) Job : public HeapObject {
 protected:
   // Indices into SchedulerPrivate, for use by the runtime.
   enum {
@@ -62,13 +64,15 @@ class alignas(2 * alignof(void*)) Job {
     TaskContinuationFunction * __ptrauth_swift_task_resume_function ResumeTask;
   };
 
-  Job(JobFlags flags, JobInvokeFunction *invoke)
-      : Flags(flags), RunJob(invoke) {
+  Job(JobFlags flags, JobInvokeFunction *invoke,
+      const HeapMetadata *metadata = &jobHeapMetadata)
+      : HeapObject(metadata), Flags(flags), RunJob(invoke) {
     assert(!isAsyncTask() && "wrong constructor for a task");
   }
 
-  Job(JobFlags flags, TaskContinuationFunction *invoke)
-      : Flags(flags), ResumeTask(invoke) {
+  Job(JobFlags flags, TaskContinuationFunction *invoke,
+      const HeapMetadata *metadata = &jobHeapMetadata)
+      : HeapObject(metadata), Flags(flags), ResumeTask(invoke) {
     assert(isAsyncTask() && "wrong constructor for a non-task job");
   }
 
@@ -94,7 +98,7 @@ class alignas(2 * alignof(void*)) Job {
 };
 
 // The compiler will eventually assume these.
-static_assert(sizeof(Job) == 4 * sizeof(void*),
+static_assert(sizeof(Job) == 6 * sizeof(void*),
               "Job size is wrong");
 static_assert(alignof(Job) == 2 * alignof(void*),
               "Job alignment is wrong");
@@ -154,7 +158,7 @@ class ActiveTaskStatus {
 ///
 /// * The future fragment is dynamic in size, based on the future result type
 ///   it can hold, and thus must be the *last* fragment.
-class AsyncTask : public HeapObject, public Job {
+class AsyncTask : public Job {
 public:
   /// The context for resuming the job.  When a task is scheduled
   /// as a job, the next continuation should be installed as the
@@ -178,7 +182,7 @@ class AsyncTask : public HeapObject, public Job {
   AsyncTask(const HeapMetadata *metadata, JobFlags flags,
             TaskContinuationFunction *run,
             AsyncContext *initialContext)
-    : HeapObject(metadata), Job(flags, run),
+    : Job(flags, run, metadata),
       ResumeContext(initialContext),
       Status(ActiveTaskStatus()),
       Local(TaskLocal::Storage()) {
@@ -444,7 +448,6 @@ class AsyncTask : public HeapObject, public Job {
     return reinterpret_cast<AsyncTask *&>(
         SchedulerPrivate[NextWaitingTaskIndex]);
   }
-
 };
 
 // The compiler will eventually assume these.

include/swift/AST/ASTPrinter.h

@@ -37,7 +37,7 @@ namespace swift {
   class NominalTypeDecl;
   class ValueDecl;
   class SourceLoc;
-  enum class tok;
+  enum class tok : uint8_t;
   enum class AccessorKind;
 
 /// Describes the context in which a name is being printed, which

include/swift/AST/ActorIsolation.h

@@ -65,12 +65,14 @@ class ActorIsolation {
 private:
   Kind kind;
   union {
-    ClassDecl *actor;
+    NominalTypeDecl *actor;
     Type globalActor;
     void *pointer;
   };
 
-  ActorIsolation(Kind kind, ClassDecl *actor) : kind(kind), actor(actor) { }
+  ActorIsolation(Kind kind, NominalTypeDecl *actor)
+      : kind(kind), actor(actor) { }
+
   ActorIsolation(Kind kind, Type globalActor)
       : kind(kind), globalActor(globalActor) { }
 
@@ -93,7 +95,7 @@ class ActorIsolation {
     return ActorIsolation(isoKind, nullptr);
   }
 
-  static ActorIsolation forActorInstance(ClassDecl *actor) {
+  static ActorIsolation forActorInstance(NominalTypeDecl *actor) {
     return ActorIsolation(ActorInstance, actor);
   }
 
@@ -108,7 +110,7 @@ class ActorIsolation {
 
   bool isUnspecified() const { return kind == Unspecified; }
 
-  ClassDecl *getActor() const {
+  NominalTypeDecl *getActor() const {
     assert(getKind() == ActorInstance);
     return actor;
   }

include/swift/AST/Decl.h

@@ -3159,6 +3159,11 @@ class NominalTypeDecl : public GenericTypeDecl, public IterableDeclContext {
   /// with placeholders for unimportable stored properties.
   ArrayRef<Decl *> getStoredPropertiesAndMissingMemberPlaceholders() const;
 
+  /// Whether this nominal type qualifies as an actor, meaning that it is
+  /// either an actor type or a protocol whose `Self` type conforms to the
+  /// `Actor` protocol.
+  bool isActor() const;
+
   /// Return the range of semantics attributes attached to this NominalTypeDecl.
   auto getSemanticsAttrs() const
       -> decltype(getAttrs().getSemanticsAttrs()) {
@@ -3699,9 +3704,6 @@ class ClassDecl final : public NominalTypeDecl {
     return getForeignClassKind() != ForeignKind::Normal;
   }
 
-  /// Whether the class is an actor.
-  bool isActor() const;
-
   /// Whether the class is (known to be) a default actor.
   bool isDefaultActor() const;
 
@@ -6975,6 +6977,11 @@ class PrecedenceGroupDecl : public Decl {
     return HigherThanLoc;
   }
 
+  /// Retrieve the array of \c Relation objects containing those precedence
+  /// groups with higher precedence than this precedence group.
+  ///
+  /// The elements of this array may be invalid, in which case they will have
+  /// null \c PrecedenceGroupDecl elements.
   ArrayRef<Relation> getHigherThan() const {
     return { getHigherThanBuffer(), NumHigherThan };
   }
@@ -6992,6 +6999,11 @@ class PrecedenceGroupDecl : public Decl {
     return LowerThanLoc;
   }
 
+  /// Retrieve the array of \c Relation objects containing those precedence
+  /// groups with lower precedence than this precedence group.
+  ///
+  /// The elements of this array may be invalid, in which case they will have
+  /// null \c PrecedenceGroupDecl elements.
   ArrayRef<Relation> getLowerThan() const {
     return { getLowerThanBuffer(), NumLowerThan };
   }

include/swift/AST/DiagnosticsSema.def

@@ -2964,7 +2964,7 @@ ERROR(dynamic_self_non_method,none,
       "%select{global|local}0 function cannot return 'Self'", (bool))
 
 ERROR(dynamic_self_invalid,none,
-      "covariant 'Self' can only appear as the possibly optional type of a "
+      "covariant 'Self' or 'Self?' can only appear as the type of a "
       "property, subscript or method result; did you mean '%0'?", (StringRef))
 ERROR(dynamic_self_in_mutable_property,none,
       "mutable property cannot have covariant 'Self' type", ())
@@ -2973,11 +2973,14 @@ ERROR(dynamic_self_in_stored_property,none,
 ERROR(dynamic_self_in_mutable_subscript,none,
       "mutable subscript cannot have covariant 'Self' type", ())
 ERROR(dynamic_self_invalid_property,none,
-      "covariant 'Self' can only appear at the top level of property type", ())
+      "covariant 'Self' or 'Self?' can only appear at the top level of "
+      "property type", ())
 ERROR(dynamic_self_invalid_subscript,none,
-      "covariant 'Self' can only appear at the top level of subscript element type", ())
+      "covariant 'Self' or 'Self?' can only appear at the top level of "
+      "subscript element type", ())
 ERROR(dynamic_self_invalid_method,none,
-      "covariant 'Self' can only appear at the top level of method result type", ())
+      "covariant 'Self' or 'Self?' can only appear at the top level of "
+      "method result type", ())
 ERROR(dynamic_self_stored_property_init,none,
       "covariant 'Self' type cannot be referenced from a stored property initializer", ())
 ERROR(dynamic_self_default_arg,none,
@@ -4331,6 +4334,9 @@ ERROR(actor_isolated_from_async_let,none,
 ERROR(actor_isolated_from_escaping_closure,none,
         "actor-isolated %0 %1 cannot be %select{referenced|mutated|used 'inout'}2 from an '@escaping' closure",
         (DescriptiveDeclKind, DeclName, unsigned))
+ERROR(actor_isolated_keypath_component,none,
+      "cannot form key path to actor-isolated %0 %1",
+      (DescriptiveDeclKind, DeclName))
 ERROR(local_function_executed_concurrently,none,
       "concurrently-executed %0 %1 must be marked as '@concurrent'",
       (DescriptiveDeclKind, DeclName))
@@ -4377,6 +4383,9 @@ WARNING(non_concurrent_property_type,none,
 WARNING(non_concurrent_keypath_capture,none,
         "cannot form key path that captures non-concurrent-value type %0",
         (Type))
+WARNING(non_concurrent_keypath_access,none,
+        "cannot form key path that accesses non-concurrent-value type %0",
+        (Type))
 ERROR(non_concurrent_type_member,none,
       "%select{stored property %1|associated value %1}0 of "
       "'ConcurrentValue'-conforming %2 %3 has non-concurrent-value type %4",

include/swift/AST/Expr.h

@@ -5654,6 +5654,26 @@ class KeyPathExpr : public Expr {
       llvm_unreachable("unhandled kind");
     }
 
+    bool hasDeclRef() const {
+      switch (getKind()) {
+      case Kind::Property:
+      case Kind::Subscript:
+        return true;
+
+      case Kind::Invalid:
+      case Kind::UnresolvedProperty:
+      case Kind::UnresolvedSubscript:
+      case Kind::OptionalChain:
+      case Kind::OptionalWrap:
+      case Kind::OptionalForce:
+      case Kind::Identity:
+      case Kind::TupleElement:
+      case Kind::DictionaryKey:
+        return false;
+      }
+      llvm_unreachable("unhandled kind");
+    }
+
     ConcreteDeclRef getDeclRef() const {
       switch (getKind()) {
       case Kind::Property:

include/swift/AST/GenericSignature.h

@@ -175,7 +175,7 @@ class CanGenericSignature : public GenericSignature {
   /// requirements, first canonicalizing the types.
   static CanGenericSignature
   getCanonical(TypeArrayView<GenericTypeParamType> params,
-               ArrayRef<Requirement> requirements, bool skipValidation = false);
+               ArrayRef<Requirement> requirements);
 
 public:
   CanGenericSignature(std::nullptr_t) : GenericSignature(nullptr) {}
@@ -342,6 +342,8 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   ///
   /// The type parameters must be known to not be concrete within the context.
   bool areSameTypeParameterInContext(Type type1, Type type2) const;
+  bool areSameTypeParameterInContext(Type type1, Type type2,
+                                     GenericSignatureBuilder &builder) const;
 
   /// Determine if \c sig can prove \c requirement, meaning that it can deduce
   /// T: Foo or T == U (etc.) with the information it knows. This includes
@@ -360,12 +362,10 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
   /// Return the canonical version of the given type under this generic
   /// signature.
   CanType getCanonicalTypeInContext(Type type) const;
-  bool isCanonicalTypeInContext(Type type) const;
-
-  /// Return the canonical version of the given type under this generic
-  /// signature.
   CanType getCanonicalTypeInContext(Type type,
                                     GenericSignatureBuilder &builder) const;
+
+  bool isCanonicalTypeInContext(Type type) const;
   bool isCanonicalTypeInContext(Type type,
                                 GenericSignatureBuilder &builder) const;
 

include/swift/AST/Module.h

@@ -166,6 +166,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   friend class DirectOperatorLookupRequest;
   friend class DirectPrecedenceGroupLookupRequest;
 
+  /// The ABI name of the module, if it differs from the module name.
+  mutable Identifier ModuleABIName;
+
 public:
   /// Produces the components of a given module's full name in reverse order.
   ///
@@ -343,6 +346,15 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   void getDeclaredCrossImportBystanders(
       SmallVectorImpl<Identifier> &bystanderNames);
 
+  /// Retrieve the ABI name of the module, which is used for metadata and
+  /// mangling.
+  Identifier getABIName() const;
+
+  /// Set the ABI name of the module;
+  void setABIName(Identifier name) {
+    ModuleABIName = name;
+  }
+
 private:
   /// A cache of this module's underlying module and required bystander if it's
   /// an underscored cross-import overlay.