Merge pull request #3581 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

docs/StandardLibraryProgrammersManual.md

@@ -72,17 +72,28 @@ For historical reasons, the existing codebase generally uses `internal` as the c
 
 Every entry point in the standard library that has an ABI impact must be applied an `@available` attribute that describes the earliest ABI-stable OS releases that it can be deployed on. (Currently this only applies to macOS, iOS, watchOS and tvOS, since Swift isn't ABI stable on other platforms yet.)
 
-Unlike access control modifiers, we prefer to put `@available` attributes on the extension context rather than duplicating them on every individual entry point. This is an effort to fight against information overload: the `@available` attribute is information dense and it's generally easier to review/maintain if applied to a group of entry points all at once.
+Just like access control modifiers, we prefer to put `@available` attributes on each individual access point, rather than just the extension in which they are defined. 
 
 ```swift
-// 👍
+// 😢👎
 @available(macOS 10.6, iOS 10, watchOS 3, tvOS 12, *)
 extension String {
   public func blanch() { ... }
   public func roast() { ... }
 }
+
+// 🥲👍
+extension String {
+  @available(macOS 10.6, iOS 10, watchOS 3, tvOS 12, *)
+  public func blanch() { ... }
+
+  @available(macOS 10.6, iOS 10, watchOS 3, tvOS 12, *)
+  public func roast() { ... }
+}
 ```
 
+This coding style is enforced by the ABI checker -- it will complain if an extension member declaration that needs an availability doesn't have it directly attached.
+
 Features under development that haven't been released yet must be marked with the placeholder version number `9999`. This special version is always considered available in custom builds of the Swift toolchain (including development snapshots), but not in any ABI-stable production release.
 
 ```swift

include/swift/AST/ClangModuleLoader.h

@@ -33,6 +33,8 @@ namespace swift {
 
 class Decl;
 class DeclContext;
+class EffectiveClangContext;
+class SwiftLookupTable;
 class VisibleDeclConsumer;
 
 /// Represents the different namespaces for types in C.
@@ -177,6 +179,9 @@ class ClangModuleLoader : public ModuleLoader {
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) = 0;
 
+  /// Imports a clang decl directly, rather than looking up its name.
+  virtual Decl *importDeclDirectly(const clang::NamedDecl *decl) = 0;
+
   /// Instantiate and import class template using given arguments.
   ///
   /// This method will find the clang::ClassTemplateSpecialization decl if
@@ -241,6 +246,21 @@ class ClangModuleLoader : public ModuleLoader {
 
   virtual Type importFunctionReturnType(const clang::FunctionDecl *clangDecl,
                                         DeclContext *dc) = 0;
+
+  /// Find the lookup table that corresponds to the given Clang module.
+  ///
+  /// \param clangModule The module, or null to indicate that we're talking
+  /// about the directly-parsed headers.
+  virtual SwiftLookupTable *
+  findLookupTable(const clang::Module *clangModule) = 0;
+
+  virtual DeclName
+  importName(const clang::NamedDecl *D,
+             clang::DeclarationName givenName = clang::DeclarationName()) = 0;
+
+  /// Determine the effective Clang context for the given Swift nominal type.
+  EffectiveClangContext virtual getEffectiveClangContext(
+      const NominalTypeDecl *nominal) = 0;
 };
 
 /// Describes a C++ template instantiation error.

include/swift/Basic/LangOptions.h

@@ -463,7 +463,7 @@ namespace swift {
 
     /// Whether the new experimental generics implementation is enabled.
     RequirementMachineMode EnableRequirementMachine =
-        RequirementMachineMode::Disabled;
+        RequirementMachineMode::Enabled;
 
     /// Enables dumping rewrite systems from the requirement machine.
     bool DumpRequirementMachine = false;
@@ -670,6 +670,10 @@ namespace swift {
   /// Options for controlling the behavior of the Clang importer.
   class ClangImporterOptions final {
   public:
+    /// The path to the Clang compiler executable.
+    /// Used to detect the default include paths.
+    std::string clangPath = "clang";
+
     /// The module cache path which the Clang importer should use.
     std::string ModuleCachePath;
 

include/swift/ClangImporter/ClangImporter.h

@@ -62,12 +62,14 @@ class ClangModuleUnit;
 class ClangNode;
 class Decl;
 class DeclContext;
+class EffectiveClangContext;
 class EnumDecl;
 class ImportDecl;
 class IRGenOptions;
 class ModuleDecl;
 class NominalTypeDecl;
 class StructDecl;
+class SwiftLookupTable;
 class TypeDecl;
 class VisibleDeclConsumer;
 enum class SelectorSplitKind;
@@ -457,11 +459,12 @@ class ClangImporter final : public ClangModuleLoader {
   /// Given a Clang module, decide whether this module is imported already.
   static bool isModuleImported(const clang::Module *M);
 
-  DeclName importName(const clang::NamedDecl *D,
-                      clang::DeclarationName givenName);
+  DeclName importName(
+      const clang::NamedDecl *D,
+      clang::DeclarationName givenName = clang::DeclarationName()) override;
 
   Type importFunctionReturnType(const clang::FunctionDecl *clangDecl,
-                                DeclContext *dc) override;
+                                 DeclContext *dc) override;
 
   Optional<std::string>
   getOrCreatePCH(const ClangImporterOptions &ImporterOptions,
@@ -493,6 +496,19 @@ class ClangImporter final : public ClangModuleLoader {
                                  SubstitutionMap subst) override;
 
   bool isCXXMethodMutating(const clang::CXXMethodDecl *method) override;
+
+  /// Find the lookup table that corresponds to the given Clang module.
+  ///
+  /// \param clangModule The module, or null to indicate that we're talking
+  /// about the directly-parsed headers.
+  SwiftLookupTable *findLookupTable(const clang::Module *clangModule) override;
+
+  /// Determine the effective Clang context for the given Swift nominal type.
+  EffectiveClangContext
+  getEffectiveClangContext(const NominalTypeDecl *nominal) override;
+
+  /// Imports a clang decl directly, rather than looking up it's name.
+  Decl *importDeclDirectly(const clang::NamedDecl *decl) override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

include/swift/SIL/SILBridging.h

@@ -50,6 +50,10 @@ typedef struct {
   const void * _Nonnull opaqueCtxt;
 } BridgedPassContext;
 
+typedef struct {
+  void * _Nonnull streamAddr;
+} BridgedOStream;
+
 typedef struct {
   void * _Null_unspecified word0;
   void * _Null_unspecified word1;
@@ -139,6 +143,8 @@ typedef long SwiftInt;
 
 void registerBridgedClass(BridgedStringRef className, SwiftMetatype metatype);
 
+void OStream_write(BridgedOStream os, BridgedStringRef str);
+
 void freeBridgedStringRef(BridgedStringRef str);
 
 void PassContext_notifyChanges(BridgedPassContext passContext,
@@ -155,6 +161,8 @@ BridgedStringRef SILFunction_getName(BridgedFunction function);
 std::string SILFunction_debugDescription(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_firstBlock(BridgedFunction function);
 OptionalBridgedBasicBlock SILFunction_lastBlock(BridgedFunction function);
+SwiftInt SILFunction_numIndirectResultArguments(BridgedFunction function);
+SwiftInt SILFunction_getSelfArgumentIndex(BridgedFunction function);
 
 BridgedStringRef SILGlobalVariable_getName(BridgedGlobalVar global);
 std::string SILGlobalVariable_debugDescription(BridgedGlobalVar global);
@@ -175,12 +183,14 @@ BridgedInstruction SILSuccessor_getContainingInst(BridgedSuccessor succ);
 BridgedValue Operand_getValue(BridgedOperand);
 OptionalBridgedOperand Operand_nextUse(BridgedOperand);
 BridgedInstruction Operand_getUser(BridgedOperand);
+SwiftInt Operand_isTypeDependent(BridgedOperand);
 
 std::string SILNode_debugDescription(BridgedNode node);
 OptionalBridgedOperand SILValue_firstUse(BridgedValue value);
 BridgedType SILValue_getType(BridgedValue value);
 
 SwiftInt SILType_isAddress(BridgedType);
+SwiftInt SILType_isTrivial(BridgedType, BridgedFunction);
 
 BridgedBasicBlock SILArgument_getParent(BridgedArgument argument);
 
@@ -216,6 +226,7 @@ SwiftInt TryApplyInst_numArguments(BridgedInstruction ai);
 BridgedBasicBlock BranchInst_getTargetBlock(BridgedInstruction bi);
 SwiftInt SwitchEnumInst_getNumCases(BridgedInstruction se);
 SwiftInt SwitchEnumInst_getCaseIndex(BridgedInstruction se, SwiftInt idx);
+SwiftInt StoreInst_getStoreOwnership(BridgedInstruction store);
 
 BridgedInstruction SILBuilder_createBuiltinBinaryFunction(
           BridgedInstruction insertionPoint,

include/swift/SIL/SILNodes.def

@@ -449,8 +449,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
     SINGLE_VALUE_INST_RANGE(AllocationInst, AllocStackInst, AllocExistentialBoxInst)
 
   ABSTRACT_SINGLE_VALUE_INST(IndexingInst, SingleValueInstruction)
-    SINGLE_VALUE_INST(IndexAddrInst, index_addr,
-                      IndexingInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(IndexAddrInst, index_addr,
+                              IndexingInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(TailAddrInst, tail_addr,
                       IndexingInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(IndexRawPointerInst, index_raw_pointer,
@@ -481,16 +481,16 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
 
   // Dynamic Dispatch
   ABSTRACT_SINGLE_VALUE_INST(MethodInst, SingleValueInstruction)
-    SINGLE_VALUE_INST(ClassMethodInst, class_method,
-                      MethodInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(SuperMethodInst, super_method,
-                      MethodInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(ObjCMethodInst, objc_method,
-                      MethodInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(ObjCSuperMethodInst, objc_super_method,
-                      MethodInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(WitnessMethodInst, witness_method,
-                      MethodInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(ClassMethodInst, class_method,
+                              MethodInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(SuperMethodInst, super_method,
+                              MethodInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(ObjCMethodInst, objc_method,
+                              MethodInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(ObjCSuperMethodInst, objc_super_method,
+                              MethodInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(WitnessMethodInst, witness_method,
+                              MethodInst, None, DoesNotRelease)
     SINGLE_VALUE_INST_RANGE(MethodInst, ClassMethodInst, WitnessMethodInst)
 
   // Conversions
@@ -499,7 +499,7 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                       ConversionInst, None, DoesNotRelease)
     BRIDGED_SINGLE_VALUE_INST(AddressToPointerInst, address_to_pointer,
                       ConversionInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(PointerToAddressInst, pointer_to_address,
+    BRIDGED_SINGLE_VALUE_INST(PointerToAddressInst, pointer_to_address,
                       ConversionInst, None, DoesNotRelease)
     BRIDGED_SINGLE_VALUE_INST(UncheckedRefCastInst, unchecked_ref_cast,
                       ConversionInst, None, DoesNotRelease)
@@ -531,8 +531,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                       ConversionInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(RefToBridgeObjectInst, ref_to_bridge_object,
                       ConversionInst, None, DoesNotRelease)
-    SINGLE_VALUE_INST(BridgeObjectToRefInst, bridge_object_to_ref,
-                      ConversionInst, None, DoesNotRelease)
+    BRIDGED_SINGLE_VALUE_INST(BridgeObjectToRefInst, bridge_object_to_ref,
+                              ConversionInst, None, DoesNotRelease)
     SINGLE_VALUE_INST(BridgeObjectToWordInst, bridge_object_to_word,
                       ConversionInst, None, DoesNotRelease)
     BRIDGED_SINGLE_VALUE_INST(ThinToThickFunctionInst, thin_to_thick_function,
@@ -599,8 +599,8 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
   SINGLE_VALUE_INST(IsUniqueInst, is_unique,
                     SingleValueInstruction, MayHaveSideEffects, DoesNotRelease)
 
-  SINGLE_VALUE_INST(EndCOWMutationInst, end_cow_mutation,
-                    SingleValueInstruction, None, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(EndCOWMutationInst, end_cow_mutation,
+                            SingleValueInstruction, None, DoesNotRelease)
 
   SINGLE_VALUE_INST(IsEscapingClosureInst, is_escaping_closure,
                     SingleValueInstruction, MayRead, DoesNotRelease)
@@ -687,26 +687,26 @@ ABSTRACT_VALUE_AND_INST(SingleValueInstruction, ValueBase, SILInstruction)
                     SingleValueInstruction, None, DoesNotRelease)
 
   // Protocol and Protocol Composition Types
-  SINGLE_VALUE_INST(InitExistentialAddrInst, init_existential_addr,
-                    SingleValueInstruction, MayWrite, DoesNotRelease)
-  SINGLE_VALUE_INST(InitExistentialValueInst, init_existential_value,
-                    SingleValueInstruction, MayWrite, DoesNotRelease)
-  SINGLE_VALUE_INST(OpenExistentialAddrInst, open_existential_addr,
-                    SingleValueInstruction, MayRead, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(InitExistentialAddrInst, init_existential_addr,
+                            SingleValueInstruction, MayWrite, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(InitExistentialValueInst, init_existential_value,
+                            SingleValueInstruction, MayWrite, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(OpenExistentialAddrInst, open_existential_addr,
+                            SingleValueInstruction, MayRead, DoesNotRelease)
   BRIDGED_SINGLE_VALUE_INST(InitExistentialRefInst, init_existential_ref,
-                    SingleValueInstruction, None, DoesNotRelease)
+                            SingleValueInstruction, None, DoesNotRelease)
   BRIDGED_SINGLE_VALUE_INST(OpenExistentialRefInst, open_existential_ref,
-                    SingleValueInstruction, None, DoesNotRelease)
+                            SingleValueInstruction, None, DoesNotRelease)
   BRIDGED_SINGLE_VALUE_INST(InitExistentialMetatypeInst, init_existential_metatype,
-                    SingleValueInstruction, None, DoesNotRelease)
+                            SingleValueInstruction, None, DoesNotRelease)
   BRIDGED_SINGLE_VALUE_INST(OpenExistentialMetatypeInst, open_existential_metatype,
-                    SingleValueInstruction, None, DoesNotRelease)
-  SINGLE_VALUE_INST(OpenExistentialBoxInst, open_existential_box,
-                    SingleValueInstruction, MayRead, DoesNotRelease)
-  SINGLE_VALUE_INST(OpenExistentialValueInst, open_existential_value,
-                    SingleValueInstruction, MayRead, DoesNotRelease)
-  SINGLE_VALUE_INST(OpenExistentialBoxValueInst, open_existential_box_value,
-                    SingleValueInstruction, MayRead, DoesNotRelease)
+                            SingleValueInstruction, None, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(OpenExistentialBoxInst, open_existential_box,
+                            SingleValueInstruction, MayRead, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(OpenExistentialValueInst, open_existential_value,
+                            SingleValueInstruction, MayRead, DoesNotRelease)
+  BRIDGED_SINGLE_VALUE_INST(OpenExistentialBoxValueInst, open_existential_box_value,
+                            SingleValueInstruction, MayRead, DoesNotRelease)
 
   // Blocks
   SINGLE_VALUE_INST(ProjectBlockStorageInst, project_block_storage,

include/swift/Sema/ConstraintSystem.h

@@ -4527,60 +4527,8 @@ class ConstraintSystem {
   // Build a disjunction that attempts both T? and T for a particular
   // type binding. The choice of T? is preferred, and we will not
   // attempt T if we can type check with T?
-  void
-  buildDisjunctionForOptionalVsUnderlying(Type boundTy, Type type,
-                                          ConstraintLocator *locator) {
-    // NOTE: If we use other locator kinds for these disjunctions, we
-    // need to account for it in solution scores for forced-unwraps.
-    assert(locator->getPath().back().getKind() ==
-               ConstraintLocator::ImplicitlyUnwrappedDisjunctionChoice ||
-           locator->getPath().back().getKind() ==
-               ConstraintLocator::DynamicLookupResult);
-
-    // Create the constraint to bind to the optional type and make it
-    // the favored choice.
-    auto *bindToOptional =
-      Constraint::create(*this, ConstraintKind::Bind, boundTy, type, locator);
-    bindToOptional->setFavored();
-
-    Type underlyingType;
-    if (auto *fnTy = type->getAs<AnyFunctionType>())
-      underlyingType = replaceFinalResultTypeWithUnderlying(fnTy);
-    else if (auto *typeVar =
-                 type->getWithoutSpecifierType()->getAs<TypeVariableType>()) {
-      auto *locator = typeVar->getImpl().getLocator();
-
-      // If `type` hasn't been resolved yet, we need to allocate a type
-      // variable to represent an object type of a future optional, and
-      // add a constraint beetween `type` and `underlyingType` to model it.
-      underlyingType = createTypeVariable(
-          getConstraintLocator(locator, LocatorPathElt::GenericArgument(0)),
-          TVO_PrefersSubtypeBinding | TVO_CanBindToLValue |
-              TVO_CanBindToNoEscape);
-
-      // Using a `typeVar` here because l-value is going to be applied
-      // to the underlying type below.
-      addConstraint(ConstraintKind::OptionalObject, typeVar, underlyingType,
-                    locator);
-    } else {
-      underlyingType = type->getWithoutSpecifierType()->getOptionalObjectType();
-    }
-
-    assert(underlyingType);
-
-    if (type->is<LValueType>())
-      underlyingType = LValueType::get(underlyingType);
-    assert(!type->is<InOutType>());
-
-    auto *bindToUnderlying = Constraint::create(
-        *this, ConstraintKind::Bind, boundTy, underlyingType, locator);
-
-    llvm::SmallVector<Constraint *, 2> choices = {bindToOptional,
-                                                  bindToUnderlying};
-
-    // Create the disjunction
-    addDisjunctionConstraint(choices, locator, RememberChoice);
-  }
+  void buildDisjunctionForOptionalVsUnderlying(Type boundTy, Type ty,
+                                               ConstraintLocator *locator);
 
   // Build a disjunction for types declared IUO.
   void

lib/AST/Availability.cpp

@@ -259,7 +259,7 @@ AvailabilityContext ASTContext::getSwift50Availability() {
     return AvailabilityContext(
                             VersionRange::allGTE(llvm::VersionTuple(12,2)));
   } else if (target.isWatchOS()) {
-    if (target.getArch() == llvm::Triple::ArchType::x86_64)
+    if (target.isArch64Bit())
       return AvailabilityContext::alwaysAvailable();
 
     return AvailabilityContext(
@@ -297,6 +297,9 @@ AvailabilityContext ASTContext::getSwift51Availability() {
     return AvailabilityContext(
                             VersionRange::allGTE(llvm::VersionTuple(13,0,0)));
   } else if (target.isWatchOS()) {
+    if (target.isArch64Bit())
+      return AvailabilityContext::alwaysAvailable();
+
     return AvailabilityContext(
                             VersionRange::allGTE(llvm::VersionTuple(6,0,0)));
   } else {

lib/AST/CMakeLists.txt

@@ -74,6 +74,7 @@ add_swift_host_library(swiftAST STATIC
   ProtocolConformance.cpp
   RawComment.cpp
   RequirementEnvironment.cpp
+  RequirementMachine/HomotopyReduction.cpp
   RequirementMachine/GenericSignatureQueries.cpp
   RequirementMachine/PropertyMap.cpp
   RequirementMachine/ProtocolGraph.cpp