Merge pull request #4080 from swiftwasm/main

Author: MaxDesiatov

cmake/modules/StandaloneOverlay.cmake

@@ -92,10 +92,6 @@ set(SWIFT_DARWIN_MODULE_ARCHS "" CACHE STRING
 targets on Darwin platforms. These targets are in addition to the full \
 library targets.")
 
-option(SWIFT_STDLIB_HAS_LOCALE
-       "Build stdlib assuming the platform has locale support."
-       TRUE)
-
 # -----------------------------------------------------------------------------
 # Constants
 

include/swift/AST/ASTMangler.h

@@ -104,7 +104,7 @@ class ASTMangler : public Mangler {
     SwiftAsObjCThunk,
     ObjCAsSwiftThunk,
     DistributedThunk,
-    DistributedMethodAccessor,
+    DistributedAccessor,
     AccessibleFunctionRecord
   };
 

include/swift/AST/GenericEnvironment.h

@@ -33,6 +33,8 @@ namespace swift {
 class ArchetypeType;
 class ASTContext;
 class GenericTypeParamType;
+class OpaqueTypeDecl;
+class OpenedArchetypeType;
 class SILModule;
 class SILType;
 
@@ -57,11 +59,28 @@ class QueryInterfaceTypeSubstitutions {
 /// TypeBase::mapTypeOutOfContext().
 ///
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
-        : private llvm::TrailingObjects<GenericEnvironment, Type> {
-  GenericSignature Signature = GenericSignature();
+    : private llvm::TrailingObjects<
+        GenericEnvironment, OpaqueTypeDecl *, SubstitutionMap, Type> {
+public:
+  enum class Kind {
+    /// A normal generic environment, determined only by its generic
+    /// signature.
+    Normal,
+    /// A generic environment describing an opened existential archetype.
+    OpenedExistential,
+    /// A generic environment describing an opaque type archetype.
+    Opaque,
+  };
+
+private:
+  mutable llvm::PointerIntPair<GenericSignature, 2, Kind> SignatureAndKind{
+      GenericSignature(), Kind::Normal};
 
   friend TrailingObjects;
+  friend OpaqueTypeArchetypeType;
 
+  size_t numTrailingObjects(OverloadToken<OpaqueTypeDecl *>) const;
+  size_t numTrailingObjects(OverloadToken<SubstitutionMap>) const;
   size_t numTrailingObjects(OverloadToken<Type>) const;
 
   /// Retrieve the array containing the context types associated with the
@@ -74,7 +93,9 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// generic signature.
   ArrayRef<Type> getContextTypes() const;
 
-  explicit GenericEnvironment(GenericSignature signature);
+  explicit GenericEnvironment(GenericSignature signature, Kind kind);
+  explicit GenericEnvironment(
+      GenericSignature signature, OpaqueTypeDecl *opaque, SubstitutionMap subs);
 
   friend ArchetypeType;
   friend QueryInterfaceTypeSubstitutions;
@@ -86,18 +107,39 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// This is only useful when lazily populating a generic environment.
   Optional<Type> getMappingIfPresent(GenericParamKey key) const;
 
+  /// Get the "raw" generic signature, without substituting into opaque
+  /// type's signature.
+  GenericSignature getRawGenericSignature() const;
+
 public:
-  GenericSignature getGenericSignature() const {
-    return Signature;
-  }
+  GenericSignature getGenericSignature() const;
+
+  Kind getKind() const { return SignatureAndKind.getInt(); }
 
   TypeArrayView<GenericTypeParamType> getGenericParams() const;
 
+  /// Retrieve the opaque type declaration for a generic environment describing
+  /// opaque types.
+  OpaqueTypeDecl *getOpaqueTypeDecl() const;
+
+  /// Retrieve the substitutions applied to an opaque type declaration to
+  /// create a generic environment.
+  SubstitutionMap getOpaqueSubstitutions() const;
+
   /// Create a new, "incomplete" generic environment that will be populated
   /// by calls to \c addMapping().
   static
   GenericEnvironment *getIncomplete(GenericSignature signature);
 
+  /// Create a new generic environment for an opened existential.
+  static GenericEnvironment *forOpenedExistential(
+      GenericSignature signature, const OpenedArchetypeType *type);
+
+  /// Create a new generic environment for an opaque type with the given set of
+  /// outer substitutions.
+  static GenericEnvironment *forOpaqueType(
+      OpaqueTypeDecl *opaque, SubstitutionMap subs, AllocationArena arena);
+
   /// Add a mapping of a generic parameter to a specific type (which may be
   /// an archetype)
   void addMapping(GenericParamKey key, Type contextType);
@@ -112,6 +154,12 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
     return Mem; 
   }
 
+  /// For an opaque archetype environment, apply the substitutions.
+  Type maybeApplyOpaqueTypeSubstitutions(Type type) const;
+
+  /// Compute the canonical interface type within this environment.
+  Type getCanonicalInterfaceType(Type interfaceType);
+
   /// Map an interface type to a contextual type.
   static Type mapTypeIntoContext(GenericEnvironment *genericEnv,
                                  Type type);

include/swift/AST/Types.h

@@ -5548,48 +5548,49 @@ END_CAN_TYPE_WRAPPER(PrimaryArchetypeType, ArchetypeType)
 
 /// An archetype that represents an opaque type.
 class OpaqueTypeArchetypeType final : public ArchetypeType,
-    public llvm::FoldingSetNode,
     private ArchetypeTrailingObjects<OpaqueTypeArchetypeType>
 {
   friend TrailingObjects;
   friend ArchetypeType;
   friend GenericSignatureBuilder;
 
-  /// The declaration that defines the opaque type.
-  OpaqueTypeDecl *OpaqueDecl;
-  /// The substitutions into the interface signature of the opaque type.
-  SubstitutionMap Substitutions;
-  
   /// A GenericEnvironment with this opaque archetype bound to the interface
   /// type of the output type from the OpaqueDecl.
-  GenericEnvironment *Environment;
-  
+  GenericEnvironment *Environment = nullptr;
+
+  friend class GenericEnvironment;
+
+  static OpaqueTypeArchetypeType *getNew(
+      GenericEnvironment *environment, Type interfaceType,
+      ArrayRef<ProtocolDecl*> conformsTo, Type superclass,
+      LayoutConstraint layout);
+
 public:
   /// Get an opaque archetype representing the underlying type of the given
   /// opaque type decl's opaque param with ordinal `ordinal`. For example, in
   /// `(some P, some Q)`, `some P`'s type param would have ordinal 0 and `some
   /// Q`'s type param would have ordinal 1.
-  static OpaqueTypeArchetypeType *get(OpaqueTypeDecl *Decl, unsigned ordinal,
-                                      SubstitutionMap Substitutions);
+  static Type get(OpaqueTypeDecl *decl, unsigned ordinal, SubstitutionMap subs);
+
+  /// Retrieve the opaque type declaration.
+  OpaqueTypeDecl *getDecl() const;
+
+  /// Retrieve the set of substitutions applied to the opaque type.
+  SubstitutionMap getSubstitutions() const;
 
-  OpaqueTypeDecl *getDecl() const {
-    return OpaqueDecl;
-  }
-  SubstitutionMap getSubstitutions() const {
-    return Substitutions;
-  }
-  
   /// Get the generic signature used to build out this archetype. This is
   /// equivalent to the OpaqueTypeDecl's interface generic signature, with
   /// all of the generic parameters aside from the opaque type's interface
   /// type same-type-constrained to their substitutions for this type.
   GenericSignature getBoundSignature() const;
 
   /// Get a generic environment that has this opaque archetype bound within it.
-  GenericEnvironment *getGenericEnvironment() const {
-    return Environment;
-  }
-  
+  GenericEnvironment *getGenericEnvironment() const;
+
+  /// Compute the canonical interface type within the environment of this
+  /// opaque type archetype.
+  CanType getCanonicalInterfaceType(Type interfaceType);
+
   static bool classof(const TypeBase *T) {
     return T->getKind() == TypeKind::OpaqueTypeArchetype;
   }
@@ -5603,22 +5604,12 @@ class OpaqueTypeArchetypeType final : public ArchetypeType,
   /// then the underlying type of `some P` would be ordinal 0, and `some Q` would be ordinal 1.
   unsigned getOrdinal() const;
 
-  static void Profile(llvm::FoldingSetNodeID &ID,
-                      OpaqueTypeDecl *OpaqueDecl,
-                      unsigned ordinal,
-                      SubstitutionMap Substitutions);
-  
-  void Profile(llvm::FoldingSetNodeID &ID) {
-    Profile(ID, getDecl(), getOrdinal(), getSubstitutions());
-  };
-  
 private:
-  OpaqueTypeArchetypeType(OpaqueTypeDecl *OpaqueDecl,
-                          SubstitutionMap Substitutions,
-                          RecursiveTypeProperties Props,
-                          Type InterfaceType,
-                          ArrayRef<ProtocolDecl*> ConformsTo,
-                          Type Superclass, LayoutConstraint Layout);
+  OpaqueTypeArchetypeType(GenericEnvironment *environment,
+                          RecursiveTypeProperties properties,
+                          Type interfaceType,
+                          ArrayRef<ProtocolDecl*> conformsTo,
+                          Type superclass, LayoutConstraint layout);
 };
 BEGIN_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)
 END_CAN_TYPE_WRAPPER(OpaqueTypeArchetypeType, ArchetypeType)

include/swift/Demangling/DemangleNodes.def

@@ -71,7 +71,7 @@ CONTEXT_NODE(Destructor)
 CONTEXT_NODE(DidSet)
 NODE(Directness)
 NODE(DistributedThunk)
-NODE(DistributedMethodAccessor)
+NODE(DistributedAccessor)
 NODE(DynamicAttribute)
 NODE(DirectMethodReferenceAttribute)
 NODE(DynamicSelf)

include/swift/IRGen/Linking.h

@@ -483,10 +483,10 @@ class LinkEntity {
     KnownAsyncFunctionPointer,
 
     /// The pointer is SILFunction*
-    DistributedMethodAccessor,
-    /// An async function pointer for a distributed method accessor.
+    DistributedAccessor,
+    /// An async function pointer for a distributed accessor (method or property).
     /// The pointer is a SILFunction*.
-    DistributedMethodAccessorAsyncPointer,
+    DistributedAccessorAsyncPointer,
 
     /// Accessible function record, which describes a function that can be
     /// looked up by name by the runtime.
@@ -1246,10 +1246,10 @@ class LinkEntity {
           Kind, unsigned(LinkEntity::Kind::PartialApplyForwarderAsyncFunctionPointer));
       break;
 
-    case LinkEntity::Kind::DistributedMethodAccessor: {
+    case LinkEntity::Kind::DistributedAccessor: {
       entity.Data = LINKENTITY_SET_FIELD(
           Kind,
-          unsigned(LinkEntity::Kind::DistributedMethodAccessorAsyncPointer));
+          unsigned(LinkEntity::Kind::DistributedAccessorAsyncPointer));
       break;
     }
 
@@ -1280,12 +1280,12 @@ class LinkEntity {
     return entity;
   }
 
-  static LinkEntity forDistributedMethodAccessor(SILFunction *method) {
+  static LinkEntity forDistributedTargetAccessor(SILFunction *target) {
     LinkEntity entity;
-    entity.Pointer = method;
+    entity.Pointer = target;
     entity.SecondaryPointer = nullptr;
     entity.Data =
-        LINKENTITY_SET_FIELD(Kind, unsigned(Kind::DistributedMethodAccessor));
+        LINKENTITY_SET_FIELD(Kind, unsigned(Kind::DistributedAccessor));
     return entity;
   }
 
@@ -1329,9 +1329,9 @@ class LinkEntity {
           Kind, unsigned(LinkEntity::Kind::PartialApplyForwarder));
       break;
 
-    case LinkEntity::Kind::DistributedMethodAccessorAsyncPointer:
+    case LinkEntity::Kind::DistributedAccessorAsyncPointer:
       entity.Data = LINKENTITY_SET_FIELD(
-          Kind, unsigned(LinkEntity::Kind::DistributedMethodAccessor));
+          Kind, unsigned(LinkEntity::Kind::DistributedAccessor));
       break;
 
     default:
@@ -1382,7 +1382,7 @@ class LinkEntity {
            getKind() == Kind::DynamicallyReplaceableFunctionVariable ||
            getKind() == Kind::DynamicallyReplaceableFunctionKey ||
            getKind() == Kind::SILFunction ||
-           getKind() == Kind::DistributedMethodAccessor ||
+           getKind() == Kind::DistributedAccessor ||
            getKind() == Kind::AccessibleFunctionRecord;
   }
 

include/swift/Sema/ConstraintSystem.h

@@ -5292,6 +5292,10 @@ class ConstraintSystem {
   /// part of the constraint system.
   void forEachExpr(Expr *expr, llvm::function_ref<Expr *(Expr *)> callback);
 
+  /// Determine whether one of the parent closures the given one is nested
+  /// in (if any) has a result builder applied to its body.
+  bool isInResultBuilderContext(ClosureExpr *closure) const;
+
   SWIFT_DEBUG_DUMP;
   SWIFT_DEBUG_DUMPER(dump(Expr *));