Merge pull request #4931 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

include/swift/AST/Decl.h

@@ -2822,7 +2822,7 @@ class GenericTypeDecl : public GenericContext, public TypeDecl {
 /// (opaque archetype 1))`.
 class OpaqueTypeDecl final :
     public GenericTypeDecl,
-    private llvm::TrailingObjects<OpaqueTypeDecl, OpaqueReturnTypeRepr *> {
+    private llvm::TrailingObjects<OpaqueTypeDecl, TypeRepr *> {
   friend TrailingObjects;
 
 public:
@@ -2866,7 +2866,7 @@ class OpaqueTypeDecl final :
   OpaqueTypeDecl(ValueDecl *NamingDecl, GenericParamList *GenericParams,
                  DeclContext *DC,
                  GenericSignature OpaqueInterfaceGenericSignature,
-                 ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs);
+                 ArrayRef<TypeRepr *> OpaqueReturnTypeReprs);
 
   unsigned getNumOpaqueReturnTypeReprs() const {
     return NamingDeclAndHasOpaqueReturnTypeRepr.getInt()
@@ -2883,7 +2883,7 @@ class OpaqueTypeDecl final :
       ValueDecl *NamingDecl, GenericParamList *GenericParams,
       DeclContext *DC,
       GenericSignature OpaqueInterfaceGenericSignature,
-      ArrayRef<OpaqueReturnTypeRepr *> OpaqueReturnTypeReprs);
+      ArrayRef<TypeRepr *> OpaqueReturnTypeReprs);
 
   ValueDecl *getNamingDecl() const {
     return NamingDeclAndHasOpaqueReturnTypeRepr.getPointer();
@@ -2904,7 +2904,7 @@ class OpaqueTypeDecl final :
   /// repr `repr`, as introduce implicitly by an occurrence of "some" in return
   /// position e.g. `func f() -> some P`. Returns -1 if `repr` is not found.
   Optional<unsigned> getAnonymousOpaqueParamOrdinal(
-      OpaqueReturnTypeRepr *repr) const;
+      TypeRepr *repr) const;
 
   GenericSignature getOpaqueInterfaceGenericSignature() const {
     return OpaqueInterfaceGenericSignature;
@@ -2928,9 +2928,9 @@ class OpaqueTypeDecl final :
 
   /// Retrieve the buffer containing the opaque return type
   /// representations that correspond to the opaque generic parameters.
-  ArrayRef<OpaqueReturnTypeRepr *> getOpaqueReturnTypeReprs() const {
+  ArrayRef<TypeRepr *> getOpaqueReturnTypeReprs() const {
     return {
-      getTrailingObjects<OpaqueReturnTypeRepr *>(),
+      getTrailingObjects<TypeRepr *>(),
       getNumOpaqueReturnTypeReprs()
     };
   }
@@ -3163,7 +3163,7 @@ class AbstractTypeParamDecl : public TypeDecl {
 /// \endcode
 class GenericTypeParamDecl final :
     public AbstractTypeParamDecl,
-    private llvm::TrailingObjects<GenericTypeParamDecl, OpaqueReturnTypeRepr *>{
+    private llvm::TrailingObjects<GenericTypeParamDecl, TypeRepr *>{
   friend TrailingObjects;
 
   size_t numTrailingObjects(OverloadToken<OpaqueReturnTypeRepr *>) const {
@@ -3180,7 +3180,7 @@ class GenericTypeParamDecl final :
   /// \param nameLoc The location of the name.
   GenericTypeParamDecl(DeclContext *dc, Identifier name, SourceLoc nameLoc,
                        bool isTypeSequence, unsigned depth, unsigned index,
-                       bool isOpaqueType, OpaqueReturnTypeRepr *opaqueTypeRepr);
+                       bool isOpaqueType, TypeRepr *typeRepr);
 
 public:
   /// Construct a new generic type parameter.
@@ -3201,7 +3201,7 @@ class GenericTypeParamDecl final :
   static GenericTypeParamDecl *
   create(DeclContext *dc, Identifier name, SourceLoc nameLoc,
          bool isTypeSequence, unsigned depth, unsigned index,
-         bool isOpaqueType, OpaqueReturnTypeRepr *opaqueTypeRepr);
+         bool isOpaqueType, TypeRepr *typeRepr);
 
   /// The depth of this generic type parameter, i.e., the number of outer
   /// levels of generic parameter lists that enclose this type parameter.
@@ -3249,11 +3249,11 @@ class GenericTypeParamDecl final :
   ///     extension, meaning that it was specified explicitly
   ///   - the enclosing declaration was deserialized, in which case it lost
   ///     the source location information and has no type representation.
-  OpaqueReturnTypeRepr *getOpaqueTypeRepr() const {
+  TypeRepr *getOpaqueTypeRepr() const {
     if (!isOpaqueType())
       return nullptr;
 
-    return *getTrailingObjects<OpaqueReturnTypeRepr *>();
+    return *getTrailingObjects<TypeRepr *>();
   }
 
   /// The index of this generic type parameter within its generic parameter

include/swift/AST/DiagnosticsParse.def

@@ -1513,7 +1513,10 @@ ERROR(attr_availability_multiple_kinds ,none,
 WARNING(attr_availability_invalid_duplicate,none,
         "'%0' argument has already been specified", (StringRef))
 WARNING(attr_availability_unknown_platform,none,
-      "unknown platform '%0' for attribute '%1'", (StringRef, StringRef))
+       "unknown platform '%0' for attribute '%1'", (StringRef, StringRef))
+WARNING(attr_availability_suggest_platform,none,
+       "unknown platform '%0' for attribute '%1'; did you mean '%2'?",
+       (StringRef, StringRef, StringRef))
 ERROR(attr_availability_expected_platform,none,
       "expected platform in '%0' attribute", (StringRef))
 ERROR(attr_availability_invalid_renamed,none,
@@ -1897,6 +1900,10 @@ ERROR(avail_query_expected_rparen,PointsToFirstBadToken,
 
 WARNING(avail_query_unrecognized_platform_name,
         PointsToFirstBadToken, "unrecognized platform name %0", (Identifier))
+WARNING(avail_query_suggest_platform_name,
+        PointsToFirstBadToken, "unrecognized platform name %0;"
+        " did you mean '%1'?",
+        (Identifier, StringRef))
 
 ERROR(avail_query_disallowed_operator, PointsToFirstBadToken,
       "'%0' cannot be used in an availability condition", (StringRef))

include/swift/AST/DiagnosticsSema.def

@@ -5696,14 +5696,22 @@ ERROR(availability_decl_more_than_enclosing, none,
       "%0 cannot be more available than enclosing scope",
       (DescriptiveDeclKind))
 
+WARNING(availability_decl_more_than_unavailable_enclosing, none,
+        "%0 cannot be more available than unavailable enclosing scope",
+        (DescriptiveDeclKind))
+
 NOTE(availability_implicit_decl_here, none,
      "%0 implicitly declared here with availability of %1 %2 or newer",
      (DescriptiveDeclKind, StringRef, llvm::VersionTuple))
 
-NOTE(availability_decl_more_than_enclosing_enclosing_here, none,
+NOTE(availability_decl_more_than_enclosing_here, none,
      "enclosing scope requires availability of %0 %1 or newer",
      (StringRef, llvm::VersionTuple))
 
+NOTE(availability_decl_more_than_unavailable_enclosing_here, none,
+     "enclosing scope has been explicitly marked unavailable here",
+     ())
+
 ERROR(availability_decl_only_version_newer, none,
       "%0 is only available in %1 %2 or newer",
       (DeclName, StringRef, llvm::VersionTuple))

include/swift/AST/Expr.h

@@ -4047,14 +4047,6 @@ class ClosureExpr : public AbstractClosureExpr {
 ///   func f(x : @autoclosure () -> Int)
 ///   f(42)  // AutoclosureExpr convert from Int to ()->Int
 /// \endcode
-///
-///  They are also created when key path expressions are converted to function
-///  type, in which case, a pair of nested implicit closures are formed:
-/// \code
-///   { $kp$ in { $0[keyPath: $kp$] } }( \(E) )
-/// \endcode
-/// This is to ensure side effects of the key path expression (mainly indices in
-/// subscripts) are only evaluated once.
 class AutoClosureExpr : public AbstractClosureExpr {
   BraceStmt *Body;
 
@@ -5397,6 +5389,10 @@ class KeyPathExpr : public Expr {
   /// a contextual root type.
   bool HasLeadingDot = false;
 
+  /// When we parse a key path literal, we claim a closure discriminator for it, since it may be used as
+  /// a closure value in function type context.
+  unsigned ClosureDiscriminator;
+
 public:
   /// A single stored component, which will be one of:
   /// - an unresolved DeclNameRef, which has to be type-checked
@@ -5728,11 +5724,12 @@ class KeyPathExpr : public Expr {
 
   KeyPathExpr(SourceLoc startLoc, Expr *parsedRoot, Expr *parsedPath,
               SourceLoc endLoc, bool hasLeadingDot, bool isObjC,
-              bool isImplicit);
+              bool isImplicit, unsigned closureDiscriminator);
 
   /// Create a key path with unresolved root and path expressions.
   KeyPathExpr(SourceLoc backslashLoc, Expr *parsedRoot, Expr *parsedPath,
-              bool hasLeadingDot, bool isImplicit);
+              bool hasLeadingDot, bool isImplicit,
+              unsigned closureDiscriminator);
 
   /// Create a key path with components.
   KeyPathExpr(ASTContext &ctx, SourceLoc startLoc,
@@ -5742,8 +5739,9 @@ class KeyPathExpr : public Expr {
 public:
   /// Create a new parsed Swift key path expression.
   static KeyPathExpr *createParsed(ASTContext &ctx, SourceLoc backslashLoc,
-                                   Expr *parsedRoot, Expr *parsedPath,
-                                   bool hasLeadingDot);
+     Expr *parsedRoot, Expr *parsedPath,
+     bool hasLeadingDot,
+     unsigned closureDiscriminator = AbstractClosureExpr::InvalidDiscriminator);
 
   /// Create a new parsed #keyPath expression.
   static KeyPathExpr *createParsedPoundKeyPath(ASTContext &ctx,
@@ -5838,6 +5836,9 @@ class KeyPathExpr : public Expr {
   /// True if this key path expression has a leading dot.
   bool expectsContextualRoot() const { return HasLeadingDot; }
 
+  /// Return the discriminator to use if this key path becomes a closure.
+  unsigned getClosureDiscriminator() const { return ClosureDiscriminator; }
+
   static bool classof(const Expr *E) {
     return E->getKind() == ExprKind::KeyPath;
   }

include/swift/AST/NameLookup.h

@@ -27,6 +27,7 @@
 #include "swift/Basic/SourceLoc.h"
 #include "swift/Basic/SourceManager.h"
 #include "llvm/ADT/SmallVector.h"
+#include "swift/AST/TypeRepr.h"
 
 namespace swift {
 class ASTContext;
@@ -36,12 +37,15 @@ class TypeDecl;
 class ValueDecl;
 struct SelfBounds;
 class NominalTypeDecl;
-
 namespace ast_scope {
 class ASTSourceFileScope;
 class ASTScopeImpl;
 } // namespace ast_scope
 
+/// Walk the type representation recursively, collecting any
+/// `OpaqueReturnTypeRepr`s, `CompositionTypeRepr`s  or `IdentTypeRepr`s.
+CollectedOpaqueReprs collectOpaqueReturnTypeReprs(TypeRepr *, ASTContext &ctx, DeclContext *dc);
+
 /// LookupResultEntry - One result of unqualified lookup.
 struct LookupResultEntry {
 private:
@@ -637,8 +641,8 @@ class FindLocalVal : public StmtVisitor<FindLocalVal> {
   void visitDoCatchStmt(DoCatchStmt *S);
 
 };
-  
-  
+
+
 /// The bridge between the legacy UnqualifiedLookupFactory and the new ASTScope
 /// lookup system
 class AbstractASTScopeDeclConsumer {

include/swift/AST/PlatformKind.h

@@ -41,6 +41,10 @@ StringRef platformString(PlatformKind platform);
 /// or None if such a platform kind does not exist.
 Optional<PlatformKind> platformFromString(StringRef Name);
 
+/// Returns a valid platform string if the candidate string would be a valid
+/// platform string if its case were adjusted (e.g. "macos" -> "macOS").
+Optional<StringRef> caseCorrectedPlatformString(StringRef candidate);
+
 /// Returns a human-readable version of the platform name as a string, suitable
 /// for emission in diagnostics (e.g., "macOS").
 StringRef prettyPlatformString(PlatformKind platform);

include/swift/AST/TypeRepr.h

@@ -33,6 +33,7 @@
 #include "llvm/Support/TrailingObjects.h"
 
 namespace swift {
+  class ASTContext;
   class ASTWalker;
   class DeclContext;
   class IdentTypeRepr;
@@ -48,7 +49,7 @@ enum : unsigned { NumTypeReprKindBits =
   countBitsUsed(static_cast<unsigned>(TypeReprKind::Last_TypeRepr)) };
 
 class OpaqueReturnTypeRepr;
-using CollectedOpaqueReprs = SmallVector<OpaqueReturnTypeRepr *, 2>;
+using CollectedOpaqueReprs = SmallVector<TypeRepr *, 2>;
 
 /// Representation of a type as written in source.
 class alignas(1 << TypeReprAlignInBits) TypeRepr
@@ -118,6 +119,9 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
     return static_cast<TypeReprKind>(Bits.TypeRepr.Kind);
   }
 
+  /// Is this type representation a protocol?
+  bool isProtocol(DeclContext *dc);
+
   /// Is this type representation known to be invalid?
   bool isInvalid() const { return Bits.TypeRepr.Invalid; }
 
@@ -165,10 +169,6 @@ class alignas(1 << TypeReprAlignInBits) TypeRepr
   /// opaque return type reprs.
   bool hasOpaque();
 
-  /// Walk the type representation recursively, collecting any
-  /// `OpaqueReturnTypeRepr`s.
-  CollectedOpaqueReprs collectOpaqueReturnTypeReprs();
-
   /// Retrieve the type repr without any parentheses around it.
   ///
   /// The use of this function must be restricted to contexts where
@@ -866,6 +866,12 @@ class CompositionTypeRepr final : public TypeRepr,
   SourceLoc getSourceLoc() const { return FirstTypeLoc; }
   SourceRange getCompositionRange() const { return CompositionRange; }
 
+  /// 'Any' is understood as CompositionTypeRepr by the compiler but its type array will be empty
+  ///  becasue it is a  nonspecific type
+  bool isTypeReprAny() {
+        return getTypes().size() == 0 ?  true : false;
+  }
+  
   static CompositionTypeRepr *create(const ASTContext &C,
                                      ArrayRef<TypeRepr*> Protocols,
                                      SourceLoc FirstTypeLoc,

include/swift/Basic/Features.def

@@ -138,6 +138,9 @@ EXPERIMENTAL_FEATURE(ParserValidation)
 /// Swift Swift parser.
 EXPERIMENTAL_FEATURE(ParserSequenceFolding)
 
+/// Enables implicit some while also enabling existential `any`
+EXPERIMENTAL_FEATURE(ImplicitSome)
+
 #undef EXPERIMENTAL_FEATURE
 #undef UPCOMING_FEATURE
 #undef SUPPRESSIBLE_LANGUAGE_FEATURE

include/swift/Concurrency/Actor.h

@@ -52,8 +52,8 @@ enum : uint32_t {
   /// The actor is ready for deallocation once it stops running
   Zombie_ReadyForDeallocation = 0x3,
 
-  // Bit 3
-  DistributedRemote = 0x8,
+  // Bit 3 is free
+
   // Bit 4
   IsPriorityEscalated = 0x10,
 

include/swift/Option/FrontendOptions.td

@@ -579,6 +579,10 @@ def enable_experimental_associated_type_inference :
   Flag<["-"], "enable-experimental-associated-type-inference">,
   HelpText<"Enable experimental associated type inference via type witness systems">;
 
+def enable_experimental_implicit_some :
+  Flag<["-"], "enable-experimental-implicit-some">,
+  HelpText<"Enable experimental implicit some">;
+
 def disable_availability_checking : Flag<["-"],
   "disable-availability-checking">,
   HelpText<"Disable checking for potentially unavailable APIs">;