Merge pull request #4120 from swiftwasm/main

[pull] swiftwasm from main

Author: MaxDesiatov

CMakeLists.txt

@@ -534,7 +534,12 @@ include(CMakePushCheckState)
 
 # Print out path and version of any installed commands
 message(STATUS "CMake (${CMAKE_COMMAND}) Version: ${CMAKE_VERSION}")
-execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} --version
+if(XCODE)
+  set(version_flag -version)
+else()
+  set(version_flag --version)
+endif()
+execute_process(COMMAND ${CMAKE_MAKE_PROGRAM} ${version_flag}
   OUTPUT_VARIABLE _CMAKE_MAKE_PROGRAM_VERSION
   OUTPUT_STRIP_TRAILING_WHITESPACE)
 message(STATUS "CMake Make Program (${CMAKE_MAKE_PROGRAM}) Version: ${_CMAKE_MAKE_PROGRAM_VERSION}")

docs/Lexicon.md

@@ -137,6 +137,19 @@ the AST level. See also [witness table](#witness-table).
 An edge in a control flow graph where the destination has multiple predecessors
 and the source has multiple successors.
 
+## currency type
+
+A type that's meant to be commonly passed around and stored, like `Array`, as
+opposed to a type that's useful for temporary/internal purposes but which you
+wouldn't normally use in an external interface, like `ArraySlice`. Having broad
+agreement about the currency type you use for a particular kind of data (e.g.
+using `Array` to pass around sequential collections) generally makes the whole
+ecosystem better by reducing artificial barriers to passing data from one system 
+to another, and it gives algorithm writers an obvious target to ensure they
+optimize for. That's where the analogy to currency comes from: agreeing on a
+currency type improves the flow of information in a program in some of the same
+ways that agreeing on a currency improves the flow of trade in an economy.
+
 ## customization point
 
 Informal term for a protocol requirement that has a default implementation,

docs/README.md

@@ -131,7 +131,8 @@ documentation, please create a thread on the Swift forums under the
     Describes the design of the optimizer pipeline.
   - [HighLevelSILOptimizations.rst](/docs/HighLevelSILOptimizations.rst):
     Describes how the optimizer understands the semantics of high-level
-    operations on currency data types and optimizes accordingly.
+    operations on [currency](/docs/Lexicon.md#currency-type) data types and 
+    optimizes accordingly.
     Includes a thorough discussion of the `@_semantics` attribute.
 
 ### SourceKit subsystems

include/swift/AST/ASTMangler.h

@@ -365,6 +365,11 @@ class ASTMangler : public Mangler {
                                      ModuleDecl *fromModule);
   void appendImplFunctionType(SILFunctionType *fn, GenericSignature sig,
                               const ValueDecl *forDecl = nullptr);
+  void appendOpaqueTypeArchetype(ArchetypeType *archetype,
+                                 OpaqueTypeDecl *opaqueDecl,
+                                 SubstitutionMap subs,
+                                 GenericSignature sig,
+                                 const ValueDecl *forDecl);
 
   void appendContextOf(const ValueDecl *decl);
 

include/swift/AST/GenericEnvironment.h

@@ -23,6 +23,7 @@
 #include "swift/AST/GenericSignature.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/Debug.h"
+#include "swift/Basic/UUID.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/TrailingObjects.h"
@@ -50,6 +51,12 @@ class QueryInterfaceTypeSubstitutions {
   Type operator()(SubstitutableType *type) const;
 };
 
+/// Extra data in a generic environment for an opened existentiak.
+struct OpenedGenericEnvironmentData {
+  Type existential;
+  UUID uuid;
+};
+
 /// Describes the mapping between archetypes and interface types for the
 /// generic parameters of a DeclContext.
 ///
@@ -60,7 +67,8 @@ class QueryInterfaceTypeSubstitutions {
 ///
 class alignas(1 << DeclAlignInBits) GenericEnvironment final
     : private llvm::TrailingObjects<
-        GenericEnvironment, OpaqueTypeDecl *, SubstitutionMap, Type> {
+        GenericEnvironment, OpaqueTypeDecl *, SubstitutionMap,
+        OpenedGenericEnvironmentData, Type> {
 public:
   enum class Kind {
     /// A normal generic environment, determined only by its generic
@@ -72,16 +80,20 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
     Opaque,
   };
 
+  class NestedTypeStorage;
+
 private:
   mutable llvm::PointerIntPair<GenericSignature, 2, Kind> SignatureAndKind{
       GenericSignature(), Kind::Normal};
+  NestedTypeStorage *nestedTypeStorage = nullptr;
 
   friend TrailingObjects;
   friend OpaqueTypeArchetypeType;
 
   size_t numTrailingObjects(OverloadToken<OpaqueTypeDecl *>) const;
   size_t numTrailingObjects(OverloadToken<SubstitutionMap>) const;
   size_t numTrailingObjects(OverloadToken<Type>) const;
+  size_t numTrailingObjects(OverloadToken<OpenedGenericEnvironmentData>) const;
 
   /// Retrieve the array containing the context types associated with the
   /// generic parameters, stored in parallel with the generic parameters of the
@@ -93,7 +105,12 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   /// generic signature.
   ArrayRef<Type> getContextTypes() const;
 
-  explicit GenericEnvironment(GenericSignature signature, Kind kind);
+  /// Get the nested type storage, allocating it if required.
+  NestedTypeStorage &getOrCreateNestedTypeStorage();
+
+  explicit GenericEnvironment(GenericSignature signature);
+  explicit GenericEnvironment(
+      GenericSignature signature, Type existential, UUID uuid);
   explicit GenericEnvironment(
       GenericSignature signature, OpaqueTypeDecl *opaque, SubstitutionMap subs);
 
@@ -102,6 +119,10 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   Type getOrCreateArchetypeFromInterfaceType(Type depType);
 
+  /// Add a mapping of a generic parameter to a specific type (which may be
+  /// an archetype)
+  void addMapping(GenericParamKey key, Type contextType);
+
   /// Retrieve the mapping for the given generic parameter, if present.
   ///
   /// This is only useful when lazily populating a generic environment.
@@ -116,6 +137,12 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
 
   TypeArrayView<GenericTypeParamType> getGenericParams() const;
 
+  /// Retrieve the existential type for an opened existential environment.
+  Type getOpenedExistentialType() const;
+
+  /// Retrieve the UUID for an opened existential environment.
+  UUID getOpenedExistentialUUID() const;
+
   /// Retrieve the opaque type declaration for a generic environment describing
   /// opaque types.
   OpaqueTypeDecl *getOpaqueTypeDecl() const;
@@ -130,18 +157,13 @@ class alignas(1 << DeclAlignInBits) GenericEnvironment final
   GenericEnvironment *getIncomplete(GenericSignature signature);
 
   /// Create a new generic environment for an opened existential.
-  static GenericEnvironment *forOpenedExistential(
-      GenericSignature signature, const OpenedArchetypeType *type);
+  static GenericEnvironment *forOpenedExistential(Type existential, UUID uuid);
 
   /// 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);
-
   /// Make vanilla new/delete illegal.
   void *operator new(size_t Bytes) = delete;
   void operator delete(void *Data) = delete;

include/swift/AST/GenericSignature.h

@@ -390,6 +390,8 @@ class alignas(1 << TypeAlignInBits) GenericSignatureImpl final
 
   bool isCanonicalTypeInContext(Type type) const;
 
+  bool isValidTypeInContext(Type type) const;
+
   /// Retrieve the conformance access path used to extract the conformance of
   /// interface \c type to the given \c protocol.
   ///

include/swift/AST/TypeNodes.def

@@ -147,7 +147,6 @@ ABSTRACT_TYPE(Substitutable, Type)
     ALWAYS_CANONICAL_TYPE(PrimaryArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpaqueTypeArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(OpenedArchetype, ArchetypeType)
-    ALWAYS_CANONICAL_TYPE(NestedArchetype, ArchetypeType)
     ALWAYS_CANONICAL_TYPE(SequenceArchetype, ArchetypeType)
     TYPE_RANGE(Archetype, PrimaryArchetype, SequenceArchetype)
   TYPE(GenericTypeParam, SubstitutableType)