Merge pull request #4601 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

README.md

@@ -28,15 +28,13 @@ to track the status of our builds, please refer to our [GitHub Actions page](htt
 | **macOS**        | x86_64 |[![Build Status](https://ci.swift.org/job/oss-swift-incremental-RA-macos/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-incremental-RA-macos)|[![Build Status](https://ci.swift.org/job/oss-swift-package-macos/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-macos)|
 | **Ubuntu 18.04** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-package-ubuntu-18_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-ubuntu-18_04)|[![Build Status](https://ci.swift.org/job/oss-swift-package-ubuntu-18_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-ubuntu-18_04)|
 | **Ubuntu 20.04** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-package-ubuntu-20_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-ubuntu-20_04)|[![Build Status](https://ci.swift.org/job/oss-swift-package-ubuntu-20_04/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-ubuntu-20_04)|
-| **CentOS 8** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-package-centos-8/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-centos-8)|[![Build Status](https://ci.swift.org/job/oss-swift-package-centos-8/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-centos-8)|
 | **CentOS 7** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-package-centos-7/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-centos-7)|[![Build Status](https://ci.swift.org/job/oss-swift-package-centos-7/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-centos-7)|
 | **Amazon Linux 2** | x86_64 | [![Build Status](https://ci.swift.org/job/oss-swift-package-amazon-linux-2/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-amazon-linux-2)|[![Build Status](https://ci.swift.org/job/oss-swift-package-amazon-linux-2/lastCompletedBuild/badge/icon)](https://ci.swift.org/job/oss-swift-package-amazon-linux-2)|
 
 **Swift Community-Hosted CI Platforms**
 
 | **OS** | **Architecture** | **Build** |
 |---|:---:|:---:|
-|**[Ubuntu 16.04 ](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/ppc64le_ubuntu_16_04.json)** | PPC64LE |[![Build Status](https://ci-external.swift.org/job/oss-swift-5.1-RA-linux-ubuntu-16.04-ppc64le/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-5.1-RA-linux-ubuntu-16.04-ppc64le)|
 |**[Ubuntu 20.04](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/wasm32_ubuntu_20.04.json)** | wasm32 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-20.04-webassembly/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-20.04-webassembly)|
 |**[Android](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_ubuntu_16_04_LTS_android.json)** | ARMv7 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android)|
 |**[Android](https://github.com/apple/swift-community-hosted-continuous-integration/blob/main/nodes/x86_64_ubuntu_16_04_LTS_android.json)** | AArch64 |[![Build Status](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android-arm64/lastCompletedBuild/badge/icon)](https://ci-external.swift.org/job/oss-swift-RA-linux-ubuntu-16.04-android-arm64)|

docs/LibraryEvolution.rst

@@ -366,7 +366,7 @@ the following changes are permitted:
 - Adding or removing a conformance to a non-ABI-public protocol.
 - Adding ``@dynamicCallable`` to the struct.
 
-The important most aspect of a Swift struct is its value semantics, not its
+The most important aspect of a Swift struct is its value semantics, not its
 layout. Note that adding a stored property to a struct is *not* a breaking
 change even with Swift's synthesis of memberwise and no-argument initializers;
 these initializers are always ``internal`` and thus not exposed to clients

include/swift/AST/DiagnosticsFrontend.def

@@ -36,6 +36,10 @@ ERROR(error_unsupported_target_os, none,
 ERROR(error_unsupported_target_arch, none,
       "unsupported target architecture: '%0'", (StringRef))
 
+ERROR(error_experimental_feature_not_available, none,
+      "experimental feature '%0' cannot be enabled in a production compiler",
+      (StringRef))
+
 ERROR(error_unknown_library_level, none,
       "unknown library level '%0', "
       "expected one of 'api', 'spi' or 'other'", (StringRef))

include/swift/AST/DiagnosticsSema.def

@@ -6330,5 +6330,19 @@ ERROR(attr_incompatible_with_back_deploy,none,
       "'%0' cannot be applied to a back deployed %1",
       (DeclAttribute, DescriptiveDeclKind))
 
+//------------------------------------------------------------------------------
+// MARK: Implicit opening of existential types
+//------------------------------------------------------------------------------
+
+ERROR(result_requires_explicit_coercion,none,
+      "inferred result type %0 requires explicit coercion due to "
+      "loss of generic requirements",
+      (Type))
+
+NOTE(candidate_result_requires_explicit_coercion,none,
+     "inferred result type %0 requires explicit coercion due to "
+     "loss of generic requirements",
+     (Type))
+
 #define UNDEFINE_DIAGNOSTIC_MACROS
 #include "DefineDiagnosticMacros.h"

include/swift/Basic/Feature.h

@@ -18,18 +18,18 @@
 namespace swift {
 
 class LangOptions;
-  
+
 /// Enumeration describing all of the named features.
 enum class Feature {
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option) \
-  FeatureName,
-  #include "swift/Basic/Features.def"
+FeatureName,
+#include "swift/Basic/Features.def"
 };
 
 constexpr unsigned numFeatures() {
   enum Features {
 #define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option) \
-    FeatureName,
+FeatureName,
 #include "swift/Basic/Features.def"
     NumFeatures
   };
@@ -51,6 +51,10 @@ inline bool featureImpliesFeature(Feature feature, Feature implied) {
   return (unsigned) feature < (unsigned) implied;
 }
 
+/// Get the feature corresponding to this "experimental" feature, if there is
+/// one.
+llvm::Optional<Feature> getExperimentalFeature(llvm::StringRef name);
+
 }
 
 #endif // SWIFT_BASIC_FEATURES_H

include/swift/Basic/Features.def

@@ -48,7 +48,12 @@
   LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)
 #endif
 
-LANGUAGE_FEATURE(StaticAssert, 0, "#assert", langOpts.EnableExperimentalStaticAssert)
+#ifndef EXPERIMENTAL_FEATURE
+#  define EXPERIMENTAL_FEATURE(FeatureName)  \
+     LANGUAGE_FEATURE(FeatureName, 0, #FeatureName, \
+                      langOpts.hasFeature(#FeatureName))
+#endif
+
 LANGUAGE_FEATURE(AsyncAwait, 296, "async/await", true)
 LANGUAGE_FEATURE(EffectfulProp, 310, "Effectful properties", true)
 LANGUAGE_FEATURE(MarkerProtocol, 0, "@_marker protocol", true)
@@ -78,5 +83,14 @@ SUPPRESSIBLE_LANGUAGE_FEATURE(PrimaryAssociatedTypes2, 346, "Primary associated
 SUPPRESSIBLE_LANGUAGE_FEATURE(UnavailableFromAsync, 0, "@_unavailableFromAsync", true)
 SUPPRESSIBLE_LANGUAGE_FEATURE(NoAsyncAvailability, 340, "@available(*, noasync)", true)
 
+EXPERIMENTAL_FEATURE(StaticAssert)
+EXPERIMENTAL_FEATURE(VariadicGenerics)
+EXPERIMENTAL_FEATURE(NamedOpaqueTypes)
+EXPERIMENTAL_FEATURE(FlowSensitiveConcurrencyCaptures)
+EXPERIMENTAL_FEATURE(MoveOnly)
+EXPERIMENTAL_FEATURE(OneWayClosureParameters)
+EXPERIMENTAL_FEATURE(TypeWitnessSystemInference)
+
+#undef EXPERIMENTAL_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE
 #undef LANGUAGE_FEATURE

include/swift/Basic/LangOptions.h

@@ -18,13 +18,15 @@
 #ifndef SWIFT_BASIC_LANGOPTIONS_H
 #define SWIFT_BASIC_LANGOPTIONS_H
 
+#include "swift/Basic/Feature.h"
 #include "swift/Basic/FunctionBodySkipping.h"
 #include "swift/Basic/LLVM.h"
 #include "swift/Basic/Version.h"
 #include "swift/Config.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Hashing.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
@@ -312,23 +314,13 @@ namespace swift {
     /// Specifies how strict concurrency checking will be.
     StrictConcurrency StrictConcurrencyLevel = StrictConcurrency::Targeted;
 
-    /// Enable experimental #assert feature.
-    bool EnableExperimentalStaticAssert = false;
-
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
 
-    /// Enable experimental support for named opaque result types, e.g.
-    /// `func f() -> <T> T`.
-    bool EnableExperimentalNamedOpaqueTypes = false;
-
     /// Enable support for implicitly opening existential argument types
     /// in calls to generic functions.
     bool EnableOpenedExistentialTypes = false;
 
-    /// Enable experimental flow-sensitive concurrent captures.
-    bool EnableExperimentalFlowSensitiveConcurrentCaptures = false;
-
     /// Disable experimental ClangImporter diagnostics.
     bool DisableExperimentalClangImporterDiagnostics = false;
 
@@ -338,16 +330,6 @@ namespace swift {
     /// Enable inference of Sendable conformances for public types.
     bool EnableInferPublicSendable = false;
 
-    /// Enable experimental 'move only' features.
-    bool EnableExperimentalMoveOnly = false;
-
-    /// Enable variadic generics.
-    bool EnableExperimentalVariadicGenerics = false;
-
-    /// Enable experimental associated type inference using type witness
-    /// systems.
-    bool EnableExperimentalAssociatedTypeInference = false;
-
     /// Disable the implicit import of the _Concurrency module.
     bool DisableImplicitConcurrencyModuleImport =
         !SWIFT_IMPLICIT_CONCURRENCY_IMPORT;
@@ -369,6 +351,9 @@ namespace swift {
     /// behavior. This is a staging flag, and will be removed in the future.
     bool EnableNewOperatorLookup = false;
 
+    /// The set of features that have been enabled.
+    llvm::SmallSet<Feature, 2> Features;
+
     /// Use Clang function types for computing canonical types.
     /// If this option is false, the clang function types will still be computed
     /// but will not be used for checking type equality.
@@ -616,6 +601,13 @@ namespace swift {
       return EffectiveLanguageVersion.isVersionAtLeast(major, minor);
     }
 
+    /// Determine whether the given feature is enabled.
+    bool hasFeature(Feature feature) const;
+
+    /// Determine whether the given feature is enabled, looking up the feature
+    /// by name.
+    bool hasFeature(llvm::StringRef featureName) const;
+
     /// Returns true if the given platform condition argument represents
     /// a supported target operating system.
     ///
@@ -725,10 +717,6 @@ namespace swift {
     /// Disable constraint system performance hacks.
     bool DisableConstraintSolverPerformanceHacks = false;
 
-    /// Enable experimental support for one-way constraints for the
-    /// parameters of closures.
-    bool EnableOneWayClosureParameters = false;
-
     /// See \ref FrontendOptions.PrintFullConvention
     bool PrintFullConvention = false;
   };

include/swift/Option/Options.td

@@ -691,6 +691,11 @@ def strict_concurrency : Joined<["-"], "strict-concurrency=">,
            "concurrency model, or 'complete' ('Sendable' and other checking is "
            "enabled for all code in the module)">;
 
+def enable_experimental_feature :
+  Separate<["-"], "enable-experimental-feature">,
+  Flags<[FrontendOption]>,
+  HelpText<"Enable an experimental feature">;
+
 def Rpass_EQ : Joined<["-"], "Rpass=">,
   Flags<[FrontendOption]>,
   HelpText<"Report performed transformations by optimization passes whose "

include/swift/Sema/CSFix.h

@@ -394,6 +394,10 @@ enum class FixKind : uint8_t {
   /// Ignore a type mismatch while trying to infer generic parameter type
   /// from default expression.
   IgnoreDefaultExprTypeMismatch,
+
+  /// Coerce a result type of a call to a particular existential type
+  /// by adding `as any <#Type#>`.
+  AddExplicitExistentialCoercion,
 };
 
 class ConstraintFix {
@@ -2981,6 +2985,37 @@ class IgnoreDefaultExprTypeMismatch : public AllowArgumentMismatch {
   }
 };
 
+class AddExplicitExistentialCoercion final : public ConstraintFix {
+  Type ErasedResultType;
+
+  AddExplicitExistentialCoercion(ConstraintSystem &cs, Type erasedResultTy,
+                                 ConstraintLocator *locator)
+      : ConstraintFix(cs, FixKind::AddExplicitExistentialCoercion, locator),
+        ErasedResultType(erasedResultTy) {}
+
+public:
+  std::string getName() const override {
+    return "add explicit existential type coercion";
+  }
+
+  bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  static bool
+  isRequired(ConstraintSystem &cs, Type resultTy,
+             ArrayRef<std::pair<TypeVariableType *, OpenedArchetypeType *>>
+                 openedExistentials,
+             ConstraintLocatorBuilder locator);
+
+  static bool isRequired(ConstraintSystem &cs, Type resultTy,
+                         llvm::function_ref<Optional<Type>(TypeVariableType *)>
+                             findExistentialType,
+                         ConstraintLocatorBuilder locator);
+
+  static AddExplicitExistentialCoercion *create(ConstraintSystem &cs,
+                                                Type resultTy,
+                                                ConstraintLocator *locator);
+};
+
 } // end namespace constraints
 } // end namespace swift
 

lib/AST/ASTPrinter.cpp

@@ -2999,6 +2999,30 @@ static bool usesFeatureNoAsyncAvailability(Decl *decl) {
    return decl->getAttrs().getNoAsync(decl->getASTContext()) != nullptr;
 }
 
+static bool usesFeatureVariadicGenerics(Decl *decl) {
+  return false;
+}
+
+static bool usesFeatureNamedOpaqueTypes(Decl *decl) {
+  return false;
+}
+
+static bool usesFeatureFlowSensitiveConcurrencyCaptures(Decl *decl) {
+  return false;
+}
+
+static bool usesFeatureMoveOnly(Decl *decl) {
+  return false;
+}
+
+static bool usesFeatureOneWayClosureParameters(Decl *decl) {
+  return false;
+}
+
+static bool usesFeatureTypeWitnessSystemInference(Decl *decl) {
+  return false;
+}
+
 static void
 suppressingFeatureNoAsyncAvailability(PrintOptions &options,
                                       llvm::function_ref<void()> action) {

lib/Basic/LangOptions.cpp

@@ -224,6 +224,20 @@ bool LangOptions::isCustomConditionalCompilationFlagSet(StringRef Name) const {
       != CustomConditionalCompilationFlags.end();
 }
 
+bool LangOptions::hasFeature(Feature feature) const {
+  if (Features.contains(feature))
+    return true;
+
+  return false;
+}
+
+bool LangOptions::hasFeature(llvm::StringRef featureName) const {
+  if (auto feature = getExperimentalFeature(featureName))
+    return hasFeature(*feature);
+
+  return false;
+}
+
 std::pair<bool, bool> LangOptions::setTarget(llvm::Triple triple) {
   clearAllPlatformConditionValues();
 
@@ -409,6 +423,15 @@ bool swift::isSuppressibleFeature(Feature feature) {
   llvm_unreachable("covered switch");
 }
 
+llvm::Optional<Feature> swift::getExperimentalFeature(llvm::StringRef name) {
+  return llvm::StringSwitch<Optional<Feature>>(name)
+#define LANGUAGE_FEATURE(FeatureName, SENumber, Description, Option)
+#define EXPERIMENTAL_FEATURE(FeatureName) \
+                   .Case(#FeatureName, Feature::FeatureName)
+#include "swift/Basic/Features.def"
+                   .Default(None);
+}
+
 DiagnosticBehavior LangOptions::getAccessNoteFailureLimit() const {
   switch (AccessNoteBehavior) {
   case AccessNoteDiagnosticBehavior::Ignore:

lib/Driver/ToolChains.cpp

@@ -236,6 +236,7 @@ void ToolChain::addCommonFrontendArgs(const OutputInfo &OI,
                        options::OPT_disable_actor_data_race_checks);
   inputArgs.AddLastArg(arguments, options::OPT_warn_concurrency);
   inputArgs.AddLastArg(arguments, options::OPT_strict_concurrency);
+  inputArgs.AddAllArgs(arguments, options::OPT_enable_experimental_feature);
   inputArgs.AddLastArg(arguments, options::OPT_warn_implicit_overrides);
   inputArgs.AddLastArg(arguments, options::OPT_typo_correction_limit);
   inputArgs.AddLastArg(arguments, options::OPT_enable_app_extension);