Merge pull request #4553 from swiftwasm/release/5.7

[pull] swiftwasm-release/5.7 from release/5.7

Author: kateinoigakukun

cmake/caches/Windows-arm64.cmake

@@ -66,6 +66,8 @@ set(LLVM_TOOL_LLVM_SHLIB_BUILD NO CACHE BOOL "")
 # Avoid swig dependency for lldb
 set(LLDB_ALLOW_STATIC_BINDINGS YES CACHE BOOL "")
 set(LLDB_USE_STATIC_BINDINGS YES CACHE BOOL "")
+set(LLDB_ENABLE_PYTHON YES CACHE BOOL "")
+set(LLDB_EMBED_PYTHON_HOME NO CACHE BOOL "")
 
 # This requires perl which may not be available on Windows
 set(SWIFT_INCLUDE_DOCS NO CACHE BOOL "")

cmake/caches/Windows-x86_64.cmake

@@ -66,6 +66,8 @@ set(LLVM_TOOL_LLVM_SHLIB_BUILD NO CACHE BOOL "")
 # Avoid swig dependency for lldb
 set(LLDB_ALLOW_STATIC_BINDINGS YES CACHE BOOL "")
 set(LLDB_USE_STATIC_BINDINGS YES CACHE BOOL "")
+set(LLDB_ENABLE_PYTHON YES CACHE BOOL "")
+set(LLDB_EMBED_PYTHON_HOME NO CACHE BOOL "")
 
 # This requires perl which may not be available on Windows
 set(SWIFT_INCLUDE_DOCS NO CACHE BOOL "")

include/swift/AST/ExtInfo.h

@@ -358,8 +358,6 @@ class ASTExtInfoBuilder {
 
   constexpr Representation getRepresentation() const {
     unsigned rawRep = bits & RepresentationMask;
-    assert(rawRep <= unsigned(Representation::Last) &&
-           "unexpected SIL representation");
     return Representation(rawRep);
   }
 

include/swift/Basic/SourceManager.h

@@ -16,6 +16,7 @@
 #include "swift/Basic/FileSystem.h"
 #include "swift/Basic/SourceLoc.h"
 #include "clang/Basic/FileManager.h"
+#include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/SourceMgr.h"
 #include <map>
@@ -55,6 +56,10 @@ class SourceManager {
   /// reusing compilation.
   llvm::DenseMap<SourceRange, SourceRange> ReplacedRanges;
 
+  /// The starting source locations of regex literals written in source. This
+  /// is an unfortunate hack needed to allow for correct re-lexing.
+  llvm::DenseSet<SourceLoc> RegexLiteralStartLocs;
+
   std::map<const char *, VirtualFile> VirtualFiles;
   mutable std::pair<const char *, const VirtualFile*> CachedVFile = {nullptr, nullptr};
 
@@ -107,6 +112,17 @@ class SourceManager {
     ReplacedRanges[Orig] = New;
   }
 
+  /// Record the starting source location of a regex literal.
+  void recordRegexLiteralStartLoc(SourceLoc loc) {
+    RegexLiteralStartLocs.insert(loc);
+  }
+
+  /// Checks whether a given source location is for the start of a regex
+  /// literal.
+  bool isRegexLiteralStart(SourceLoc loc) const {
+    return RegexLiteralStartLocs.contains(loc);
+  }
+
   /// Returns true if \c LHS is before \c RHS in the source buffer.
   bool isBeforeInBuffer(SourceLoc LHS, SourceLoc RHS) const {
     return LHS.Value.getPointer() < RHS.Value.getPointer();

include/swift/IDE/CodeCompletionResultType.h

@@ -21,6 +21,15 @@
 namespace swift {
 namespace ide {
 
+enum class CustomAttributeKind : uint8_t {
+  /// A type that can be used as a property wrapper.
+  PropertyWrapper = 1 << 0,
+  /// A type that can be used as a result builder.
+  ResultBuilder = 1 << 1,
+  /// A type that can be used as a global actor.
+  GlobalActor = 1 << 2,
+};
+
 /// The expected contextual type(s) for code-completion.
 class ExpectedTypeContext {
   /// Possible types of the code completion expression.
@@ -37,6 +46,11 @@ class ExpectedTypeContext {
   bool IsImplicitSingleExpressionReturn = false;
   bool PreferNonVoid = false;
 
+  /// If not empty, \c PossibleTypes are ignored and types that have an
+  /// attribute kind that is contained in this list will be reported as
+  /// 'Convertible'. All other types are related as 'Invalid'.
+  OptionSet<CustomAttributeKind> ExpectedCustomAttributeKinds;
+
 public:
   ExpectedTypeContext() = default;
 
@@ -82,6 +96,15 @@ class ExpectedTypeContext {
   void setPreferNonVoid(bool PreferNonVoid) {
     this->PreferNonVoid = PreferNonVoid;
   }
+
+  OptionSet<CustomAttributeKind> getExpectedCustomAttributeKinds() const {
+    return ExpectedCustomAttributeKinds;
+  }
+
+  void setExpectedCustomAttributeKinds(
+      OptionSet<CustomAttributeKind> ExpectedAttributeKinds) {
+    this->ExpectedCustomAttributeKinds = ExpectedAttributeKinds;
+  }
 };
 
 /// Describes the relationship between the type of the completion results and
@@ -174,6 +197,9 @@ class USRBasedTypeContext {
 
   SmallVector<ContextualType, 4> ContextualTypes;
 
+  /// See \c ExpectedTypeContext::ExpectedAttributeKinds.
+  OptionSet<CustomAttributeKind> ExpectedCustomAttributeKinds;
+
 public:
   /// Create a USR-based equivalent of the \p TypeContext.
   USRBasedTypeContext(const ExpectedTypeContext *TypeContext,
@@ -203,10 +229,15 @@ class USRBasedType {
   /// declared in the same module that the type was defined.
   ArrayRef<const USRBasedType *> Supertypes;
 
+  /// The kinds of attributes this type can be used as.
+  OptionSet<CustomAttributeKind> CustomAttributeKinds;
+
   /// Memberwise initializer. \p USR and \p Supertypes need to be allocated in
   /// the same arena as this \c USRBasedType.
-  USRBasedType(StringRef USR, ArrayRef<const USRBasedType *> Supertypes)
-      : USR(USR), Supertypes(Supertypes) {}
+  USRBasedType(StringRef USR, ArrayRef<const USRBasedType *> Supertypes,
+               OptionSet<CustomAttributeKind> CustomAttributeKinds)
+      : USR(USR), Supertypes(Supertypes),
+        CustomAttributeKinds(CustomAttributeKinds) {}
 
   /// Implementation of \c typeRelation. \p VisistedTypes keeps track which
   /// types have already been visited.
@@ -225,13 +256,18 @@ class USRBasedType {
 
   /// Construct as \c USRBasedType from a USR and its supertypes. This method
   /// takes care of copying \p USR and \p Supertypes to \p Arena.
-  static const USRBasedType *fromUSR(StringRef USR,
-                                     ArrayRef<const USRBasedType *> Supertypes,
-                                     USRBasedTypeArena &Arena);
+  static const USRBasedType *
+  fromUSR(StringRef USR, ArrayRef<const USRBasedType *> Supertypes,
+          OptionSet<CustomAttributeKind> CustomAttributeKinds,
+          USRBasedTypeArena &Arena);
 
   StringRef getUSR() const { return USR; }
   ArrayRef<const USRBasedType *> getSupertypes() const { return Supertypes; }
 
+  OptionSet<CustomAttributeKind> getCustomAttributeKinds() const {
+    return CustomAttributeKinds;
+  }
+
   /// Compute the relation of \c ResultType when to this contextual type.
   CodeCompletionResultTypeRelation
   typeRelation(const USRBasedType *ResultType,

include/swift/IDE/CompletionLookup.h

@@ -240,13 +240,16 @@ class CompletionLookup final : public swift::VisibleDeclConsumer {
 
   void setIsStaticMetatype(bool value) { IsStaticMetatype = value; }
 
-  void setExpectedTypes(ArrayRef<Type> Types,
-                        bool isImplicitSingleExpressionReturn,
-                        bool preferNonVoid = false) {
+  void setExpectedTypes(
+      ArrayRef<Type> Types, bool isImplicitSingleExpressionReturn,
+      bool preferNonVoid = false,
+      OptionSet<CustomAttributeKind> expectedCustomAttributeKinds = {}) {
     expectedTypeContext.setIsImplicitSingleExpressionReturn(
         isImplicitSingleExpressionReturn);
     expectedTypeContext.setPreferNonVoid(preferNonVoid);
     expectedTypeContext.setPossibleTypes(Types);
+    expectedTypeContext.setExpectedCustomAttributeKinds(
+        expectedCustomAttributeKinds);
   }
 
   void setIdealExpectedType(Type Ty) { expectedTypeContext.setIdealType(Ty); }

include/swift/Reflection/TypeRefBuilder.h

@@ -100,6 +100,12 @@ class ReflectionSectionIteratorBase
     : OriginalSize(Size), Cur(Cur), Size(Size), Name(Name) {
     if (Size != 0) {
       auto NextRecord = this->operator*();
+      if (!NextRecord) {
+        // NULL record pointer, don't attempt to proceed. Setting size to 0 will
+        // make this iterator compare equal to the end iterator.
+        this->Size = 0;
+        return;
+      }
       auto NextSize = Self::getCurrentRecordSize(NextRecord);
       if (NextSize > Size) {
         std::cerr << "!!! Reflection section too small to contain first record\n" << std::endl;
@@ -109,7 +115,9 @@ class ReflectionSectionIteratorBase
                   << ", size of first record: "
                   << NextSize
                   << std::endl;
-        abort();
+        // Set this iterator equal to the end. This section is effectively
+        // empty.
+        this->Size = 0;
       }
     }
   }
@@ -149,14 +157,18 @@ class ReflectionSectionIteratorBase
           std::cerr << std::hex << std::setw(2) << (int)p[i] << " ";
         }
         std::cerr << std::endl;
-        abort();
+        Size = 0; // Set this iterator equal to the end.
       }
     }
 
     return asImpl();
   }
 
   bool operator==(const Self &other) const {
+    // Size = 0 means we're at the end even if Cur doesn't match. This allows
+    // iterators that encounter an incorrect size to safely end iteration.
+    if (Size == 0 && other.Size == 0)
+      return true;
     return Cur == other.Cur && Size == other.Size;
   }
 

lib/AST/ASTContext.cpp

@@ -24,6 +24,7 @@
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/DistributedDecl.h"
 #include "swift/AST/ExistentialLayout.h"
+#include "swift/AST/ExtInfo.h"
 #include "swift/AST/FileUnit.h"
 #include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
@@ -3683,6 +3684,16 @@ FunctionType *FunctionType::get(ArrayRef<AnyFunctionType::Param> params,
   auto properties = getFunctionRecursiveProperties(params, result, globalActor);
   auto arena = getArena(properties);
 
+  if (info.hasValue()) {
+    // Canonicalize all thin functions to be escaping (to keep compatibility
+    // with generic parameters). Note that one can pass SIL-level representation
+    // here, so we need additional check for maximum non-SIL value.
+    Representation rep = info.getValue().getRepresentation();
+    if (rep <= FunctionTypeRepresentation::Last &&
+        isThinRepresentation(rep))
+      info = info->withNoEscape(false);
+  }
+
   llvm::FoldingSetNodeID id;
   FunctionType::Profile(id, params, result, info);
 
@@ -4100,6 +4111,10 @@ CanSILFunctionType SILFunctionType::get(
     ext = ext.intoBuilder().withClangFunctionType(nullptr).build();
   }
 
+  // Canonicalize all thin functions to be escaping (to keep compatibility
+  // with generic parameters)
+  if (isThinRepresentation(ext.getRepresentation()))
+    ext = ext.intoBuilder().withNoEscape(false);
 
   llvm::FoldingSetNodeID id;
   SILFunctionType::Profile(id, genericSig, ext, coroutineKind, callee, params,

lib/IDE/CodeCompletion.cpp

@@ -1701,6 +1701,35 @@ void CodeCompletionCallbacksImpl::doneParsing() {
 
   case CompletionKind::AttributeBegin: {
     Lookup.getAttributeDeclCompletions(IsInSil, AttTargetDK);
+    OptionSet<CustomAttributeKind> ExpectedCustomAttributeKinds;
+    if (AttTargetDK) {
+      switch (*AttTargetDK) {
+      case DeclKind::Var:
+        ExpectedCustomAttributeKinds |= CustomAttributeKind::GlobalActor;
+        LLVM_FALLTHROUGH;
+      case DeclKind::Param:
+        ExpectedCustomAttributeKinds |= CustomAttributeKind::ResultBuilder;
+        ExpectedCustomAttributeKinds |= CustomAttributeKind::PropertyWrapper;
+        break;
+      case DeclKind::Func:
+        ExpectedCustomAttributeKinds |= CustomAttributeKind::ResultBuilder;
+        ExpectedCustomAttributeKinds |= CustomAttributeKind::GlobalActor;
+        break;
+      default:
+        break;
+      }
+    }
+    if (!ExpectedCustomAttributeKinds) {
+      // If we don't know on which decl kind we are completing, suggest all
+      // attribute kinds.
+      ExpectedCustomAttributeKinds |= CustomAttributeKind::PropertyWrapper;
+      ExpectedCustomAttributeKinds |= CustomAttributeKind::ResultBuilder;
+      ExpectedCustomAttributeKinds |= CustomAttributeKind::GlobalActor;
+    }
+    Lookup.setExpectedTypes(/*Types=*/{},
+                            /*isImplicitSingleExpressionReturn=*/false,
+                            /*preferNonVoid=*/false,
+                            ExpectedCustomAttributeKinds);
 
     // TypeName at attribute position after '@'.
     // - VarDecl: Property Wrappers.

lib/IDE/CodeCompletionCache.cpp

@@ -103,7 +103,7 @@ CodeCompletionCache::~CodeCompletionCache() {}
 ///
 /// This should be incremented any time we commit a change to the format of the
 /// cached results. This isn't expected to change very often.
-static constexpr uint32_t onDiskCompletionCacheVersion = 6; // Store completion item result types in the cache
+static constexpr uint32_t onDiskCompletionCacheVersion = 7; // Store whether a type can be used as attribute
 
 /// Deserializes CodeCompletionResults from \p in and stores them in \p V.
 /// \see writeCacheModule.
@@ -193,8 +193,9 @@ static bool readCachedModule(llvm::MemoryBuffer *in,
       auto supertypeIndex = read32le(p);
       supertypes.push_back(getType(supertypeIndex));
     }
-    const USRBasedType *res =
-        USRBasedType::fromUSR(usr, supertypes, V.USRTypeArena);
+    auto customAttributeKinds = OptionSet<CustomAttributeKind, uint8_t>(*p++);
+    const USRBasedType *res = USRBasedType::fromUSR(
+        usr, supertypes, customAttributeKinds, V.USRTypeArena);
     knownTypes[index] = res;
     return res;
   };
@@ -381,6 +382,9 @@ static void writeCachedModule(llvm::raw_ostream &out,
     for (auto supertypeIndex : supertypeIndicies) {
       LE.write(static_cast<uint32_t>(supertypeIndex));
     }
+    OptionSet<CustomAttributeKind, uint8_t> customAttributeKinds =
+        type->getCustomAttributeKinds();
+    LE.write(static_cast<uint8_t>(customAttributeKinds.toRaw()));
     knownTypes[type] = size;
     return static_cast<uint32_t>(size);
   };