Merge pull request #4040 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

cmake/modules/AddSwift.cmake

@@ -636,8 +636,13 @@ function(add_libswift_module module)
                         ""
                         "DEPENDS"
                         ${ARGN})
-  set(sources ${ALSM_UNPARSED_ARGUMENTS})
-  list(TRANSFORM sources PREPEND "${CMAKE_CURRENT_SOURCE_DIR}/")
+  set(raw_sources ${ALSM_UNPARSED_ARGUMENTS})
+  set(sources)
+  foreach(raw_source ${raw_sources})
+    get_filename_component(
+      raw_source "${raw_source}" REALPATH BASE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    list(APPEND sources "${raw_source}")
+  endforeach()
 
   set(target_name "LibSwift${module}")
 

include/swift/AST/ASTContext.h

@@ -621,7 +621,7 @@ class ASTContext final {
                                      KnownProtocolKind builtinProtocol,
                 llvm::function_ref<DeclName (ASTContext &ctx)> initName) const;
 
-  /// Retrieve _StringProcessing.Regex.init(_regexString: String).
+  /// Retrieve _StringProcessing.Regex.init(_regexString: String, version: Int).
   ConcreteDeclRef getRegexInitDecl(Type regexType) const;
 
   /// Retrieve the declaration of Swift.<(Int, Int) -> Bool.

include/swift/AST/Expr.h

@@ -966,18 +966,23 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
 class RegexLiteralExpr : public LiteralExpr {
   SourceLoc Loc;
   StringRef RegexText;
+  unsigned Version;
 
-  RegexLiteralExpr(SourceLoc loc, StringRef regexText, bool isImplicit)
+  RegexLiteralExpr(SourceLoc loc, StringRef regexText, unsigned version,
+                   bool isImplicit)
       : LiteralExpr(ExprKind::RegexLiteral, isImplicit), Loc(loc),
-        RegexText(regexText) {}
+        RegexText(regexText), Version(version) {}
 
 public:
   static RegexLiteralExpr *createParsed(ASTContext &ctx, SourceLoc loc,
-                                        StringRef regexText);
+                                        StringRef regexText, unsigned version);
 
   /// Retrieve the raw regex text.
   StringRef getRegexText() const { return RegexText; }
 
+  /// Retrieve the version of the regex string.
+  unsigned getVersion() const { return Version; }
+
   SourceRange getSourceRange() const { return Loc; }
 
   static bool classof(const Expr *E) {

include/swift/AST/KnownIdentifiers.def

@@ -252,6 +252,7 @@ IDENTIFIER(zero)
 // String processing
 IDENTIFIER(Regex)
 IDENTIFIER_(regexString)
+IDENTIFIER(version)
 IDENTIFIER_(StringProcessing)
 
 // Distributed actors

include/swift/Parse/ExperimentalRegexBridging.h

@@ -5,17 +5,43 @@
 extern "C" {
 #endif
 
-typedef const char *(* ParseRegexStrawperson)(const char *);
-
-void Parser_registerParseRegexStrawperson(ParseRegexStrawperson fn);
-bool Parser_hasParseRegexStrawperson();
+/// Attempt to lex a regex literal string. Takes the following arguments:
+///
+/// - CurPtrPtr: A pointer to the current pointer of lexer, which should be the
+///              start of the literal. This will be advanced to the point at
+///              which the lexer should resume, or will remain the same if this
+///              is not a regex literal.
+/// - BufferEnd: A pointer to the end of the buffer, which should not be lexed
+///              past.
+/// - ErrorOut: If an error is encountered, this will be set to the error
+///             string.
+///
+/// Returns: A bool indicating whether lexing was completely erroneous, and
+///          cannot be recovered from, or false if there either was no error,
+///          or there was a recoverable error.
+typedef bool(* RegexLiteralLexingFn)(/*CurPtrPtr*/ const char **,
+                                     /*BufferEnd*/ const char *,
+                                     /*ErrorOut*/ const char **);
+void Parser_registerRegexLiteralLexingFn(RegexLiteralLexingFn fn);
+
+/// Parse a regex literal string. Takes the following arguments:
+///
+/// - InputPtr: A null-terminated C string of the regex literal.
+/// - ErrorOut: A buffer accepting an error string upon error.
+/// - VersionOut: A buffer accepting a regex literal format version.
+/// - CaptureStructureOut: A buffer accepting a byte sequence representing the
+///                        capture structure of the literal.
+/// - CaptureStructureSize: The size of the capture structure buffer. Must be
+///                         greater than or equal to `strlen(InputPtr)`.
+typedef void(* RegexLiteralParsingFn)(/*InputPtr*/ const char *,
+                                      /*ErrorOut*/ const char **,
+                                      /*VersionOut*/ unsigned *,
+                                      /*CaptureStructureOut*/ char *,
+                                      /*CaptureStructureSize*/ unsigned);
+void Parser_registerRegexLiteralParsingFn(RegexLiteralParsingFn fn);
 
 #ifdef __cplusplus
 } // extern "C"
 #endif
 
 #endif // EXPERIMENTAL_REGEX_BRIDGING
-
-
-//const char* experimental_regex_strawperson(const char *in);
-

include/swift/Parse/Lexer.h

@@ -595,7 +595,9 @@ class Lexer {
   void lexStringLiteral(unsigned CustomDelimiterLen = 0);
   void lexEscapedIdentifier();
 
-  void lexRegexLiteral(const char *TokStart);
+  /// Attempt to lex a regex literal, returning true if a regex literal was
+  /// lexed, false if this is not a regex literal.
+  bool tryLexRegexLiteral(const char *TokStart);
 
   void tryLexEditorPlaceholder();
   const char *findEndOfCurlyQuoteStringLiteral(const char *,
@@ -612,9 +614,6 @@ class Lexer {
 
   /// Emit diagnostics for single-quote string and suggest replacement
   /// with double-quoted equivalent.
-  ///
-  /// Or, if we're in strawperson mode, we will emit a custom
-  /// error message instead, determined by the Swift library.
   void diagnoseSingleQuoteStringLiteral(const char *TokStart,
                                         const char *TokEnd);
 

include/swift/SIL/OwnershipUtils.h

@@ -104,12 +104,9 @@ inline bool isForwardingConsume(SILValue value) {
 bool findInnerTransitiveGuaranteedUses(
     SILValue guaranteedValue, SmallVectorImpl<Operand *> *usePoints = nullptr);
 
-/// Like findInnerTransitiveGuaranteedUses except that rather than it being a
-/// precondition that the provided value not be a BorrowedValue, it is a [type-
-/// system-enforced] precondition that the provided value be a BorrowedValue.
-///
-/// TODO: Merge with findInnerTransitiveGuaranteedUses.
-bool findInnerTransitiveGuaranteedUsesOfBorrowedValue(
+/// Find all uses in the extended lifetime (i.e. including copies) of a simple
+/// (i.e. not reborrowed) borrow scope and its transitive uses.
+bool findExtendedUsesOfSimpleBorrowedValue(
     BorrowedValue borrowedValue,
     SmallVectorImpl<Operand *> *usePoints = nullptr);
 

include/swift/SIL/SILValue.h

@@ -438,7 +438,7 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
 
   template <class T> inline T *getSingleConsumingUserOfType() const;
 
-  /// Returns true if this operand has exactly two.
+  /// Returns true if this operand has exactly two uses.
   ///
   /// This is useful if one has found a predefined set of 2 unique users and
   /// wants to check if there are any other users without iterating over the

include/swift/SILOptimizer/Utils/CanonicalizeBorrowScope.h

@@ -147,7 +147,9 @@ class CanonicalizeBorrowScope {
   bool consolidateBorrowScope();
 };
 
-bool shrinkBorrowScope(BeginBorrowInst *bbi, InstructionDeleter &deleter);
+bool shrinkBorrowScope(
+    BeginBorrowInst *bbi, InstructionDeleter &deleter,
+    SmallVectorImpl<CopyValueInst *> &modifiedCopyValueInsts);
 
 } // namespace swift
 

lib/AST/ASTContext.cpp

@@ -1221,7 +1221,7 @@ ConcreteDeclRef ASTContext::getRegexInitDecl(Type regexType) const {
   auto *spModule = getLoadedModule(Id_StringProcessing);
   DeclName name(*const_cast<ASTContext *>(this),
                 DeclBaseName::createConstructor(),
-                {Id_regexString});
+                {Id_regexString, Id_version});
   SmallVector<ValueDecl *, 1> results;
   spModule->lookupQualified(getRegexType(), DeclNameRef(name),
                             NL_IncludeUsableFromInline, results);