Merge pull request #5299 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

docs/SIL.rst

@@ -1442,6 +1442,9 @@ namespace SpecialPointerAuthDiscriminators {
 
   /// C type StoreExtraInhabitantTag function descriminator
   const uint16_t StoreExtraInhabitantTagFunction = 0x9bf6; // = 39926
+
+  // Relative protocol witness table descriminator
+  const uint16_t RelativeProtocolWitnessTable = 0xb830; // = 47152
 }
 
 /// The number of arguments that will be passed directly to a generic

include/swift/ABI/MetadataValues.h

@@ -37,13 +37,16 @@ namespace Demangle {
 SWIFT_BEGIN_INLINE_NAMESPACE
 
 Type getTypeForMangling(ASTContext &ctx,
-                        llvm::StringRef mangling);
+                        llvm::StringRef mangling,
+                        GenericSignature genericSig=GenericSignature());
 
 TypeDecl *getTypeDeclForMangling(ASTContext &ctx,
-                                 llvm::StringRef mangling);
+                                 llvm::StringRef mangling,
+                                 GenericSignature genericSig=GenericSignature());
 
 TypeDecl *getTypeDeclForUSR(ASTContext &ctx,
-                            llvm::StringRef usr);
+                            llvm::StringRef usr,
+                            GenericSignature genericSig=GenericSignature());
 
 /// An implementation of MetadataReader's BuilderType concept that
 /// just finds and builds things in the AST.
@@ -55,6 +58,11 @@ class ASTBuilder {
   /// Created lazily.
   DeclContext *NotionalDC = nullptr;
 
+  /// The generic signature for interpreting type parameters. This is used
+  /// because the mangling for a type parameter doesn't record whether it
+  /// is a pack or not, so we have to find it here.
+  GenericSignature GenericSig;
+
 public:
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
@@ -66,7 +74,8 @@ class ASTBuilder {
 
   static constexpr bool needsToPrecomputeParentGenericContextShapes = false;
 
-  explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
+  explicit ASTBuilder(ASTContext &ctx, GenericSignature genericSig)
+    : Ctx(ctx), GenericSig(genericSig) {}
 
   ASTContext &getASTContext() { return Ctx; }
   DeclContext *getNotionalDC();
@@ -102,6 +111,12 @@ class ASTBuilder {
 
   Type createTupleType(ArrayRef<Type> eltTypes, StringRef labels);
 
+  Type createPackType(ArrayRef<Type> eltTypes);
+
+  Type createSILPackType(ArrayRef<Type> eltTypes, bool isElementAddress);
+
+  Type createPackExpansionType(Type patternType, Type countType);
+
   Type createFunctionType(
       ArrayRef<Demangle::FunctionParam<Type>> params,
       Type output, FunctionTypeFlags flags,

include/swift/AST/ASTDemangler.h

@@ -760,12 +760,11 @@ ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_global_var,
 ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_global_let, none,
       "'%0' was consumed but it is illegal to consume a noncopyable global let. One can only read from it",
       (StringRef))
-ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_escaping_let, none,
-      "'%0' was consumed but it is illegal to consume a noncopyable escaping immutable capture. One can only read from it",
-      (StringRef))
 ERROR(sil_moveonlychecker_notconsumable_but_assignable_was_consumed_escaping_var, none,
-      "'%0' was consumed but it is illegal to consume a noncopyable escaping mutable capture. One can only read from it or assign over it",
+      "'%0' was consumed but it is illegal to consume a noncopyable mutable capture of an escaping closure. One can only read from it or assign over it",
       (StringRef))
+ERROR(sil_moveonlychecker_let_capture_consumed, none,
+      "'%0' was consumed but it is illegal to consume a noncopyable immutable capture of an escaping closure. One can only read from it", (StringRef))
 
 NOTE(sil_moveonlychecker_moveonly_field_consumed_here, none,
      "move only field consumed here", ())

include/swift/AST/DiagnosticsSIL.def

@@ -3893,6 +3893,9 @@ ERROR(optional_used_as_boolean,none,
 ERROR(integer_used_as_boolean,none,
      "type %0 cannot be used as a boolean; "
      "test for '%select{!|=}1= 0' instead", (Type, bool))
+ERROR(integer_used_as_boolean_literal,none,
+     "integer literal value '%0' cannot be used as a boolean; "
+     "did you mean '%select{false|true}1'?", (StringRef, bool))
 
 ERROR(interpolation_missing_proto,none,
       "string interpolation requires the protocol 'ExpressibleByStringInterpolation' to be defined",

include/swift/AST/DiagnosticsSema.def

@@ -204,6 +204,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
 
   /// C type StoreExtraInhabitantTag function descriminator.
   PointerAuthSchema StoreExtraInhabitantTagFunction;
+
+  /// Relative protocol witness table descriminator.
+  PointerAuthSchema RelativeProtocolWitnessTable;
 };
 
 enum class JITDebugArtifact : unsigned {

include/swift/AST/IRGenOptions.h

@@ -120,5 +120,9 @@ SEMANTICS_ATTR(LIFETIMEMANAGEMENT_COPY, "lifetimemanagement.copy")
 
 SEMANTICS_ATTR(NO_PERFORMANCE_ANALYSIS, "no_performance_analysis")
 
+// A flag used to turn off moveonly diagnostics on functions that allocbox to
+// stack specialized.
+SEMANTICS_ATTR(NO_MOVEONLY_DIAGNOSTICS, "sil.optimizer.moveonly.diagnostic.ignore")
+
 #undef SEMANTICS_ATTR
 

include/swift/AST/SemanticAttrs.def

@@ -3181,16 +3181,16 @@ void simple_display(llvm::raw_ostream &out,
 /// Resolve a given custom attribute to an attached macro declaration.
 class ResolveMacroRequest
     : public SimpleRequest<ResolveMacroRequest,
-                           MacroDecl *(UnresolvedMacroReference,
-                                       DeclContext *),
+                           ConcreteDeclRef(UnresolvedMacroReference,
+                                           DeclContext *),
                            RequestFlags::Cached> {
 public:
   using SimpleRequest::SimpleRequest;
 
 private:
   friend SimpleRequest;
 
-  MacroDecl *
+  ConcreteDeclRef
   evaluate(Evaluator &evaluator, UnresolvedMacroReference macroRef,
            DeclContext *dc) const;
 

include/swift/AST/TypeCheckRequests.h

@@ -341,7 +341,7 @@ SWIFT_REQUEST(TypeChecker, ResolveImplicitMemberRequest,
               evaluator::SideEffect(NominalTypeDecl *, ImplicitMemberAction),
               Uncached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveMacroRequest,
-              MacroDecl *(CustomAttr *, DeclContext *),
+              ConcreteDeclRef(UnresolvedMacroReference, DeclContext *),
               Cached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ResolveTypeEraserTypeRequest,
               Type(ProtocolDecl *, TypeEraserAttr *),

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -331,7 +331,7 @@ namespace swift {
     bool UseMalloc = false;
 
     /// Specifies how strict concurrency checking will be.
-    StrictConcurrency StrictConcurrencyLevel = StrictConcurrency::Targeted;
+    StrictConcurrency StrictConcurrencyLevel = StrictConcurrency::Minimal;
 
     /// Enable experimental concurrency model.
     bool EnableExperimentalConcurrency = false;
@@ -532,6 +532,9 @@ namespace swift {
     /// The model of concurrency to be used.
     ConcurrencyModel ActiveConcurrencyModel = ConcurrencyModel::Standard;
 
+    /// Allows the explicit 'import Builtin' within Swift modules.
+    bool EnableBuiltinModule = false;
+
     bool isConcurrencyModelTaskToThread() const {
       return ActiveConcurrencyModel == ConcurrencyModel::TaskToThread;
     }

include/swift/Basic/LangOptions.h

@@ -214,17 +214,25 @@ class SourceManager {
            (isBeforeInBuffer(R.Start, Loc) && isBeforeInBuffer(Loc, R.End));
   }
 
+  /// Returns true if range \c R contains the location \c Loc.  The location
+  /// \c Loc should point at the beginning of the token.
+  bool rangeContainsTokenLoc(CharSourceRange R, SourceLoc Loc) const {
+    return Loc == R.getStart() || (isBeforeInBuffer(R.getStart(), Loc) &&
+                                   isBeforeInBuffer(Loc, R.getEnd()));
+  }
+
   /// Returns true if range \c Enclosing contains the range \c Inner.
   bool rangeContains(SourceRange Enclosing, SourceRange Inner) const {
     return rangeContainsTokenLoc(Enclosing, Inner.Start) &&
            rangeContainsTokenLoc(Enclosing, Inner.End);
   }
 
   /// Returns true if range \p R contains the code-completion location, if any.
-  bool rangeContainsIDEInspectionTarget(SourceRange R) const {
-    return IDEInspectionTargetBufferID
-               ? rangeContainsTokenLoc(R, getIDEInspectionTargetLoc())
-               : false;
+  bool rangeContainsIDEInspectionTarget(CharSourceRange R) const {
+    if (!IDEInspectionTargetBufferID) {
+      return false;
+    }
+    return rangeContainsTokenLoc(R, getIDEInspectionTargetLoc());
   }
 
   /// Returns the buffer ID for the specified *valid* location.

include/swift/Basic/SourceManager.h

@@ -236,6 +236,8 @@ NODE(Tuple)
 NODE(TupleElement)
 NODE(TupleElementName)
 NODE(Pack)
+NODE(SILPackDirect)
+NODE(SILPackIndirect)
 NODE(PackExpansion)
 NODE(Type)
 CONTEXT_NODE(TypeSymbolicReference)

include/swift/Demangling/DemangleNodes.def

@@ -530,6 +530,7 @@ class Demangler : public NodeFactory {
   NodePointer popTuple();
   NodePointer popTypeList();
   NodePointer popPack();
+  NodePointer popSILPack();
   NodePointer popProtocol();
   NodePointer demangleBoundGenericType();
   NodePointer demangleBoundGenericArgs(NodePointer nominalType,

include/swift/Demangling/Demangler.h

@@ -1072,6 +1072,46 @@ class TypeDecoder {
       return decodeMangledType(Node->getChild(0), depth + 1,
                                /*forRequirement=*/false);
 
+    case NodeKind::Pack:
+    case NodeKind::SILPackDirect:
+    case NodeKind::SILPackIndirect: {
+      llvm::SmallVector<BuiltType, 8> elements;
+
+      for (auto &element : *Node) {
+        // Decode the element type.
+        auto elementType =
+            decodeMangledType(element, depth + 1, /*forRequirement=*/false);
+        if (elementType.isError())
+          return elementType;
+
+        elements.push_back(elementType.getType());
+      }
+
+      switch (Node->getKind()) {
+      case NodeKind::Pack:
+        return Builder.createPackType(elements);
+      case NodeKind::SILPackDirect:
+        return Builder.createSILPackType(elements, /*isElementAddress=*/false);
+      case NodeKind::SILPackIndirect:
+        return Builder.createSILPackType(elements, /*isElementAddress=*/true);
+      default:
+        llvm_unreachable("Bad kind");
+      }
+    }
+
+    case NodeKind::PackExpansion: {
+      if (Node->getNumChildren() < 2)
+        return MAKE_NODE_TYPE_ERROR(Node,
+                                    "fewer children (%zu) than required (2)",
+                                    Node->getNumChildren());
+
+      auto patternType = decodeMangledType(Node->getChild(0), depth + 1);
+      auto countType = decodeMangledType(Node->getChild(1), depth + 1);
+
+      return Builder.createPackExpansionType(patternType.getType(),
+                                             countType.getType());
+    }
+
     case NodeKind::DependentGenericType: {
       if (Node->getNumChildren() < 2)
         return MAKE_NODE_TYPE_ERROR(Node,