Merge pull request #4420 from swiftwasm/katei/merge-main-2022-04-05

Merge main 2022-04-05

Author: kateinoigakukun

SwiftCompilerSources/Package.swift

@@ -28,9 +28,16 @@ let package = Package(
     .target(
       name: "_RegexParser",
       dependencies: [],
-      swiftSettings: [SwiftSetting.unsafeFlags([
+      swiftSettings: [
+        .unsafeFlags([
           "-I", "../include/swift",
-          "-cross-module-optimization"
+          "-cross-module-optimization",
+        ]),
+        // Workaround until `_RegexParser` is imported as implementation-only
+        // by `_StringProcessing`.
+        .unsafeFlags([
+          "-Xfrontend",
+          "-disable-implicit-string-processing-module-import"
         ])]),
     .target(
       name: "Optimizer",

docs/RequirementMachine/RequirementMachine.tex

@@ -3053,7 +3053,7 @@ \chapter{The Requirement Machine}\label{requirementmachine}
 
 \section{Generic Parameters}\label{genericparamsym}
 \index{generic parameter symbol}
-So far, I've only shown you how to build rewrite rules from requirements in the requirement signature of some protocol $\proto{P}$. When lowering a type parameter, the protocol $\genericparam{Self}$ type lowers to the protocol symbol $\protosym{P}$. Once such a rewrite system is built, queries can be performed against the protocol generic signature $\gensig{\genericparam{Self}}{\genericparam{Self}\colon\proto{P}}$. When lowering parameters and requirements in an arbitary generic signature, generic parameter types instead become generic parameter symbols.
+So far, I've only shown you how to build rewrite rules from requirements in the requirement signature of some protocol $\proto{P}$. When lowering a type parameter, the protocol $\genericparam{Self}$ type lowers to the protocol symbol $\protosym{P}$. Once such a rewrite system is built, queries can be performed against the protocol generic signature $\gensig{\genericparam{Self}}{\genericparam{Self}\colon\proto{P}}$. When lowering parameters and requirements in an arbitrary generic signature, generic parameter types instead become generic parameter symbols.
 
 Generic parameter symbols should only ever appear as the initial symbol in a term. While the rewrite system would have no trouble with terms where generic parameter symbols appear elsewhere in the abstract, they don't actually make sense semantically, since they do not correspond to valid Swift type parameter types.
 

include/swift/AST/Decl.h

@@ -506,11 +506,6 @@ class alignas(1 << DeclAlignInBits) Decl : public ASTAllocated<Decl> {
     IsOpaqueType : 1
   );
 
-  SWIFT_INLINE_BITFIELD_FULL(AssociatedTypeDecl, AbstractTypeParamDecl, 1,
-    /// Whether this is a primary associated type.
-    IsPrimary : 1
-  );
-
   SWIFT_INLINE_BITFIELD_EMPTY(GenericTypeDecl, TypeDecl);
 
   SWIFT_INLINE_BITFIELD(TypeAliasDecl, GenericTypeDecl, 1+1,
@@ -3272,14 +3267,6 @@ class AssociatedTypeDecl : public AbstractTypeParamDecl {
                      LazyMemberLoader *definitionResolver,
                      uint64_t resolverData);
 
-  bool isPrimary() const {
-    return Bits.AssociatedTypeDecl.IsPrimary;
-  }
-
-  void setPrimary() {
-    Bits.AssociatedTypeDecl.IsPrimary = true;
-  }
-
   /// Get the protocol in which this associated type is declared.
   ProtocolDecl *getProtocol() const {
     return cast<ProtocolDecl>(getDeclContext());
@@ -4358,11 +4345,14 @@ enum class KnownDerivableProtocolKind : uint8_t {
   Decodable,
   AdditiveArithmetic,
   Differentiable,
+  Identifiable,
   Actor,
   DistributedActor,
   DistributedActorSystem,
 };
 
+using PrimaryAssociatedTypeName = std::pair<Identifier, SourceLoc>;
+
 /// ProtocolDecl - A declaration of a protocol, for example:
 ///
 ///   protocol Drawable {
@@ -4379,6 +4369,7 @@ enum class KnownDerivableProtocolKind : uint8_t {
 class ProtocolDecl final : public NominalTypeDecl {
   SourceLoc ProtocolLoc;
 
+  ArrayRef<PrimaryAssociatedTypeName> PrimaryAssociatedTypeNames;
   ArrayRef<ProtocolDecl *> InheritedProtocols;
   ArrayRef<AssociatedTypeDecl *> AssociatedTypes;
 
@@ -4460,7 +4451,9 @@ class ProtocolDecl final : public NominalTypeDecl {
 
 public:
   ProtocolDecl(DeclContext *DC, SourceLoc ProtocolLoc, SourceLoc NameLoc,
-               Identifier Name, ArrayRef<InheritedEntry> Inherited,
+               Identifier Name,
+               ArrayRef<PrimaryAssociatedTypeName> PrimaryAssociatedTypeNames,
+               ArrayRef<InheritedEntry> Inherited,
                TrailingWhereClause *TrailingWhere);
 
   using Decl::getASTContext;
@@ -4486,6 +4479,13 @@ class ProtocolDecl final : public NominalTypeDecl {
   /// a protocol having nested types (ObjC protocols).
   ArrayRef<AssociatedTypeDecl *> getAssociatedTypeMembers() const;
 
+  /// Returns the list of primary associated type names. These are the associated
+  /// types that is parametrized with same-type requirements in a
+  /// parametrized protocol type of the form SomeProtocol<Arg1, Arg2...>.
+  ArrayRef<PrimaryAssociatedTypeName> getPrimaryAssociatedTypeNames() const {
+    return PrimaryAssociatedTypeNames;
+  }
+
   /// Returns the list of primary associated types. These are the associated
   /// types that is parametrized with same-type requirements in a
   /// parametrized protocol type of the form SomeProtocol<Arg1, Arg2...>.

include/swift/AST/DiagnosticsSema.def

@@ -3770,14 +3770,19 @@ ERROR(not_a_generic_definition,none,
       "cannot specialize a non-generic definition", ())
 ERROR(not_a_generic_type,none,
       "cannot specialize non-generic type %0", (Type))
+ERROR(protocol_declares_unknown_primary_assoc_type,none,
+      "an associated type named %0 must be declared in the protocol %1 or a protocol it inherits",
+      (Identifier, Type))
+ERROR(protocol_declares_duplicate_primary_assoc_type,none,
+      "duplicate primary associated type name %0", (Identifier))
 ERROR(parameterized_protocol_not_supported,none,
-      "protocol type with generic arguments can only be used as a generic constraint", ())
+      "protocol type with type arguments can only be used as a generic constraint", ())
 ERROR(protocol_does_not_have_primary_assoc_type,none,
       "cannot specialize protocol type %0", (Type))
-ERROR(parameterized_protocol_too_many_type_arguments,none,
-      "protocol type %0 can specialized with too many type parameters "
-      "(got %1, but expected at most %2)",
-      (Type, unsigned, unsigned))
+ERROR(parameterized_protocol_type_argument_count_mismatch,none,
+      "protocol type %0 specialized with %select{too many|too few}3 type arguments "
+      "(got %1, but expected %2)",
+      (Type, unsigned, unsigned, unsigned))
 ERROR(cannot_specialize_self,none,
       "cannot specialize 'Self'", ())
 NOTE(specialize_explicit_type_instead,none,
@@ -6128,9 +6133,6 @@ WARNING(result_builder_missing_limited_availability, none,
         "result builder %0 does not implement 'buildLimitedAvailability'; "
         "this code may crash on earlier versions of the OS",
         (Type))
-ERROR(result_builder_static_buildblock, none,
-      "result builder must provide at least one static 'buildBlock' "
-      "method", ())
 ERROR(result_builder_static_buildblock_or_buildpartialblock, none,
       "result builder must provide at least one static 'buildBlock' "
       "method, or both 'buildPartialBlock(first:)' and "

include/swift/AST/EducationalNotes.def

@@ -73,7 +73,7 @@ EDUCATIONAL_NOTES(type_cannot_conform, "protocol-type-non-conformance.md")
 EDUCATIONAL_NOTES(unlabeled_trailing_closure_deprecated,
                   "trailing-closure-matching.md")
 
-EDUCATIONAL_NOTES(result_builder_static_buildblock,
+EDUCATIONAL_NOTES(result_builder_static_buildblock_or_buildpartialblock,
                   "result-builder-methods.md")
 EDUCATIONAL_NOTES(result_builder_missing_limited_availability,
                   "result-builder-methods.md")

include/swift/AST/KnownProtocols.def

@@ -60,6 +60,7 @@
 
 PROTOCOL(Actor)
 PROTOCOL(Sequence)
+PROTOCOL(Identifiable)
 PROTOCOL(IteratorProtocol)
 PROTOCOL(RawRepresentable)
 PROTOCOL(Equatable)

include/swift/Basic/LangOptions.h

@@ -209,6 +209,9 @@ namespace swift {
     /// Emit a remark after loading a module.
     bool EnableModuleLoadingRemarks = false;
 
+    /// Resolve main function as though it were called from an async context
+    bool EnableAsyncMainResolution = false;
+
     ///
     /// Support for alternate usage modes
     ///
@@ -346,9 +349,6 @@ namespace swift {
     /// Enable experimental 'move only' features.
     bool EnableExperimentalMoveOnly = false;
 
-    /// Enable experimental pairwise `buildBlock` for result builders.
-    bool EnableExperimentalPairwiseBuildBlock = false;
-
     /// Enable variadic generics.
     bool EnableExperimentalVariadicGenerics = false;
 
@@ -360,6 +360,9 @@ namespace swift {
     bool DisableImplicitConcurrencyModuleImport =
         !SWIFT_IMPLICIT_CONCURRENCY_IMPORT;
 
+    /// Disable the implicit import of the _StringProcessing module.
+    bool DisableImplicitStringProcessingModuleImport = false;
+
     /// Should we check the target OSs of serialized modules to see that they're
     /// new enough?
     bool EnableTargetOSChecking = true;

include/swift/Option/FrontendOptions.td

@@ -422,6 +422,10 @@ def disable_implicit_distributed_module_import : Flag<["-"],
   "disable-implicit-distributed-module-import">,
   HelpText<"Disable the implicit import of the Distributed module.">;
 
+def disable_implicit_string_processing_module_import : Flag<["-"],
+  "disable-implicit-string-processing-module-import">,
+  HelpText<"Disable the implicit import of the _StringProcessing module.">;
+
 def disable_arc_opts : Flag<["-"], "disable-arc-opts">,
   HelpText<"Don't run SIL ARC optimization passes.">;
 def disable_ossa_opts : Flag<["-"], "disable-ossa-opts">,

include/swift/Option/Options.td

@@ -270,6 +270,10 @@ def pch_output_dir: Separate<["-"], "pch-output-dir">,
   Flags<[FrontendOption, HelpHidden, ArgumentIsPath]>,
   HelpText<"Directory to persist automatically created precompiled bridging headers">;
 
+def async_main: Flag<["-"], "async-main">,
+    Flags<[FrontendOption]>,
+    HelpText<"Resolve main function as if it were called from an asynchronous context">;
+
 // FIXME: Unhide this once it doesn't depend on an output file map.
 def incremental : Flag<["-"], "incremental">,
   Flags<[NoInteractiveOption, HelpHidden, DoesNotAffectIncrementalBuild]>,

include/swift/Parse/Parser.h

@@ -1213,9 +1213,9 @@ class Parser {
   parseAbstractFunctionBodyDelayed(AbstractFunctionDecl *AFD);
 
   ParserStatus parsePrimaryAssociatedTypes(
-      SmallVectorImpl<AssociatedTypeDecl *> &AssocTypes);
+      SmallVectorImpl<PrimaryAssociatedTypeName> &AssocTypeNames);
   ParserStatus parsePrimaryAssociatedTypeList(
-      SmallVectorImpl<AssociatedTypeDecl *> &AssocTypes);
+      SmallVectorImpl<PrimaryAssociatedTypeName> &AssocTypeNames);
   ParserResult<ProtocolDecl> parseDeclProtocol(ParseDeclOptions Flags,
                                                DeclAttributes &Attributes);
 

include/swift/Sema/ConstraintSystem.h

@@ -1515,6 +1515,10 @@ enum class ConstraintSystemFlags {
   /// calling conventions, say due to Clang attributes such as
   /// `__attribute__((ns_consumed))`.
   UseClangFunctionTypes = 0x80,
+
+  /// When set, nominal typedecl contexts are asynchronous contexts.
+  /// This is set while searching for the main function
+  ConsiderNominalTypeContextsAsync = 0x100,
 };
 
 /// Options that affect the constraint system as a whole.

include/swift/Sema/IDETypeChecking.h

@@ -21,6 +21,7 @@
 
 #include "swift/AST/Identifier.h"
 #include "swift/Basic/SourceLoc.h"
+#include "swift/Basic/OptionSet.h"
 #include <memory>
 #include <tuple>
 
@@ -50,6 +51,8 @@ namespace swift {
   class ConstraintSystem;
   class Solution;
   class SolutionApplicationTarget;
+  enum class ConstraintSystemFlags;
+  using ConstraintSystemOptions = OptionSet<ConstraintSystemFlags>;
   }
 
   /// Typecheck binding initializer at \p bindingIndex.
@@ -93,8 +96,9 @@ namespace swift {
   /// Unlike other member lookup functions, \c swift::resolveValueMember()
   /// should be used when you want to look up declarations with the same name as
   /// one you already have.
-  ResolvedMemberResult resolveValueMember(DeclContext &DC, Type BaseTy,
-                                         DeclName Name);
+  ResolvedMemberResult
+  resolveValueMember(DeclContext &DC, Type BaseTy, DeclName Name,
+                     constraints::ConstraintSystemOptions Options = {});
 
   /// Given a type and an extension to the original type decl of that type,
   /// decide if the extension has been applied, i.e. if the requirements of the

lib/AST/ASTPrinter.cpp

@@ -1381,8 +1381,7 @@ struct RequirementPrintLocation {
 /// function does: asking "where should this requirement be printed?" and then
 /// callers check if the location is the ATD.
 static RequirementPrintLocation
-bestRequirementPrintLocation(ProtocolDecl *proto, const Requirement &req,
-                             PrintOptions opts, bool inheritanceClause) {
+bestRequirementPrintLocation(ProtocolDecl *proto, const Requirement &req) {
   auto protoSelf = proto->getProtocolSelfType();
   // Returns the most relevant decl within proto connected to outerType (or null
   // if one doesn't exist), and whether the type is an "direct use",
@@ -1415,16 +1414,6 @@ bestRequirementPrintLocation(ProtocolDecl *proto, const Requirement &req,
     // desired.
     auto directUse = foundType && outerType->isEqual(foundType);
 
-    // Prefer to attach requirements to associated type declarations,
-    // unless the associated type is a primary associated type and
-    // we're printing primary associated types using the new syntax.
-    if (!directUse &&
-        relevantDecl &&
-        opts.PrintPrimaryAssociatedTypes &&
-        isa<AssociatedTypeDecl>(relevantDecl) &&
-        cast<AssociatedTypeDecl>(relevantDecl)->isPrimary())
-      relevantDecl = proto;
-
     return std::make_pair(relevantDecl, directUse);
   };
 
@@ -1495,8 +1484,7 @@ void PrintAST::printInheritedFromRequirementSignature(ProtocolDecl *proto,
           return false;
         }
 
-        auto location = bestRequirementPrintLocation(proto, req, Options,
-                                                     /*inheritanceClause=*/true);
+        auto location = bestRequirementPrintLocation(proto, req);
         return location.AttachedTo == attachingTo && !location.InWhereClause;
       });
 }
@@ -1511,8 +1499,7 @@ void PrintAST::printWhereClauseFromRequirementSignature(ProtocolDecl *proto,
                             proto->getRequirementSignature().getRequirements()),
       flags,
       [&](const Requirement &req) {
-        auto location = bestRequirementPrintLocation(proto, req, Options,
-                                                     /*inheritanceClause=*/false);
+        auto location = bestRequirementPrintLocation(proto, req);
         return location.AttachedTo == attachingTo && location.InWhereClause;
       });
 }
@@ -3557,14 +3544,6 @@ void PrintAST::printPrimaryAssociatedTypes(ProtocolDecl *decl) {
                                       assocType);
         Printer.printName(assocType->getName(),
                           PrintNameContext::GenericParameter);
-
-        printInheritedFromRequirementSignature(decl, assocType);
-
-        if (assocType->hasDefaultDefinitionType()) {
-          Printer << " = ";
-          assocType->getDefaultDefinitionType().print(Printer, Options);
-        }
-
         Printer.printStructurePost(PrintStructureKind::GenericParameter,
                                    assocType);
       },
@@ -5092,14 +5071,6 @@ bool Decl::shouldPrintInContext(const PrintOptions &PO) const {
     return PO.PrintIfConfig;
   }
 
-  if (auto *ATD = dyn_cast<AssociatedTypeDecl>(this)) {
-    // If PO.PrintPrimaryAssociatedTypes is on, primary associated
-    // types are printed as part of the protocol declaration itself,
-    // so skip them here.
-    if (ATD->isPrimary() && PO.PrintPrimaryAssociatedTypes)
-      return false;
-  }
-
   // Print everything else.
   return true;
 }

lib/AST/Decl.cpp

@@ -4557,9 +4557,7 @@ AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
                                        TrailingWhereClause *trailingWhere)
     : AbstractTypeParamDecl(DeclKind::AssociatedType, dc, name, nameLoc),
       KeywordLoc(keywordLoc), DefaultDefinition(defaultDefinition),
-      TrailingWhere(trailingWhere) {
-  Bits.AssociatedTypeDecl.IsPrimary = 0;
-}
+      TrailingWhere(trailingWhere) {}
 
 AssociatedTypeDecl::AssociatedTypeDecl(DeclContext *dc, SourceLoc keywordLoc,
                                        Identifier name, SourceLoc nameLoc,
@@ -5305,11 +5303,13 @@ bool EnumDecl::hasCircularRawValue() const {
 
 ProtocolDecl::ProtocolDecl(DeclContext *DC, SourceLoc ProtocolLoc,
                            SourceLoc NameLoc, Identifier Name,
+                           ArrayRef<PrimaryAssociatedTypeName> PrimaryAssociatedTypeNames,
                            ArrayRef<InheritedEntry> Inherited,
                            TrailingWhereClause *TrailingWhere)
     : NominalTypeDecl(DeclKind::Protocol, DC, Name, NameLoc, Inherited,
                       nullptr),
-      ProtocolLoc(ProtocolLoc) {
+      ProtocolLoc(ProtocolLoc),
+      PrimaryAssociatedTypeNames(PrimaryAssociatedTypeNames) {
   Bits.ProtocolDecl.RequiresClassValid = false;
   Bits.ProtocolDecl.RequiresClass = false;
   Bits.ProtocolDecl.ExistentialConformsToSelfValid = false;
@@ -5622,6 +5622,8 @@ Optional<KnownDerivableProtocolKind>
     return KnownDerivableProtocolKind::AdditiveArithmetic;
   case KnownProtocolKind::Differentiable:
     return KnownDerivableProtocolKind::Differentiable;
+  case KnownProtocolKind::Identifiable:
+    return KnownDerivableProtocolKind::Identifiable;
   case KnownProtocolKind::Actor:
     return KnownDerivableProtocolKind::Actor;
   case KnownProtocolKind::DistributedActor:

lib/AST/RequirementMachine/ConcreteContraction.cpp

@@ -599,6 +599,17 @@ bool ConcreteContraction::performConcreteContraction(
     // requirement where the left hand side is not a type parameter.
     SmallVector<Requirement, 4> reqs;
     if (req.inferred) {
+      // Discard errors from desugaring a substituted requirement that
+      // was inferred. For example, if we have something like
+      //
+      //   <T, U where T == Int, U == Set<T>>
+      //
+      // The inferred requirement 'T : Hashable' from 'Set<>' will
+      // be substituted with 'T == Int' to get 'Int : Hashable'.
+      //
+      // Desugaring will diagnose a redundant conformance requirement,
+      // but we want to ignore that, since the user did not explicitly
+      // write 'Int : Hashable' (or 'T : Hashable') anywhere.
       SmallVector<RequirementError, 4> discardErrors;
       desugarRequirement(substReq, SourceLoc(), reqs, discardErrors);
     } else {