Merge branch 'main' of github.com:apple/swift into maxd/main-merge

# Conflicts:
#	stdlib/public/runtime/CMakeLists.txt

Author: MaxDesiatov

CMakeLists.txt

@@ -1031,37 +1031,6 @@ endif()
 # Find required dependencies.
 #
 
-function(swift_icu_variables_set sdk arch result)
-  string(TOUPPER "${sdk}" sdk)
-
-  set(icu_var_ICU_UC_INCLUDE ${SWIFT_${sdk}_${arch}_ICU_UC_INCLUDE})
-  set(icu_var_ICU_UC ${SWIFT_${sdk}_${arch}_ICU_UC})
-  set(icu_var_ICU_I18N_INCLUDE ${SWIFT_${sdk}_${arch}_ICU_I18N_INCLUDE})
-  set(icu_var_ICU_I18N ${SWIFT_${sdk}_${arch}_ICU_I18N})
-
-  if(icu_var_ICU_UC_INCLUDE AND icu_var_ICU_UC AND
-     icu_var_ICU_I18N_INCLUDE AND icu_var_ICU_I18N)
-    set(${result} TRUE PARENT_SCOPE)
-  else()
-    set(${result} FALSE PARENT_SCOPE)
-  endif()
-endfunction()
-
-# ICU is provided through CoreFoundation on Darwin.  On other hosts, if the ICU
-# unicode and i18n include and library paths are not defined, perform a standard
-# package lookup.  Otherwise, rely on the paths specified by the user.  These
-# need to be defined when cross-compiling.
-if(NOT CMAKE_SYSTEM_NAME STREQUAL "Darwin")
-  if(SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
-    swift_icu_variables_set("${SWIFT_PRIMARY_VARIANT_SDK}"
-                            "${SWIFT_PRIMARY_VARIANT_ARCH}"
-                            ICU_CONFIGURED)
-    if("${SWIFT_PATH_TO_LIBICU_BUILD}" STREQUAL "" AND NOT ${ICU_CONFIGURED})
-      find_package(ICU REQUIRED COMPONENTS uc i18n)
-    endif()
-  endif()
-endif()
-
 find_package(Python3 COMPONENTS Interpreter REQUIRED)
 
 #
@@ -1184,7 +1153,6 @@ endif()
 
 if(SWIFT_INCLUDE_TESTS)
   add_subdirectory(test)
-  add_subdirectory(validation-test)
   add_subdirectory(unittests)
 endif()
 if(SWIFT_INCLUDE_DOCS)

cmake/modules/AddSwift.cmake

@@ -430,7 +430,6 @@ endfunction()
 #     [SHARED]
 #     [STATIC]
 #     [OBJECT]
-#     [PURE_SWIFT]
 #     [LLVM_LINK_COMPONENTS comp1 ...]
 #     source1 [source2 source3 ...])
 #
@@ -449,18 +448,13 @@ endfunction()
 # LLVM_LINK_COMPONENTS
 #   LLVM components this library depends on.
 #
-# PURE_SWIFT
-#   This has two effects if set: we do not use llvm_update_compile_flags to
-#   generate cflags/etc and we leave the linking mode of the library as swift.
-#
 # source1 ...
 #   Sources to add into this library.
 function(add_swift_host_library name)
   set(options
         SHARED
         STATIC
-        OBJECT
-        PURE_SWIFT)
+        OBJECT)
   set(single_parameter_options)
   set(multiple_parameter_options
         LLVM_LINK_COMPONENTS)
@@ -523,9 +517,7 @@ function(add_swift_host_library name)
   if (LLVM_COMMON_DEPENDS)
     add_dependencies(${name} ${LLVM_COMMON_DEPENDS})
   endif()
-  if (NOT ASHL_PURE_SWIFT)
-    llvm_update_compile_flags(${name})
-  endif()
+  llvm_update_compile_flags(${name})
   swift_common_llvm_config(${name} ${ASHL_LLVM_LINK_COMPONENTS})
   set_output_directory(${name}
       BINARY_DIR ${SWIFT_RUNTIME_OUTPUT_INTDIR}
@@ -584,11 +576,7 @@ function(add_swift_host_library name)
       NO_SONAME YES)
   endif()
 
-  # Always link as CXX even if we have swift content unless we only contain
-  # swift content signaled via us being marked "PURE_SWIFT".
-  if (NOT ASHL_PURE_SWIFT)
-    set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
-  endif()
+  set_target_properties(${name} PROPERTIES LINKER_LANGUAGE CXX)
 
   if(${SWIFT_HOST_VARIANT_SDK} IN_LIST SWIFT_DARWIN_PLATFORMS)
     target_link_options(${name} PRIVATE
@@ -598,30 +586,6 @@ function(add_swift_host_library name)
         "LINKER:-current_version,${SWIFT_COMPILER_VERSION}")
     endif()
 
-    # If we found a swift compiler and are going to use swift code in swift
-    # host side tools but link with clang, add the appropriate -L paths so we
-    # find all of the necessary swift libraries on Darwin.
-    if (NOT ASHL_PURE_SWIFT)
-      if (CMAKE_Swift_COMPILER)
-        # Add in the toolchain directory so we can grab compatibility libraries
-        get_filename_component(TOOLCHAIN_BIN_DIR ${CMAKE_Swift_COMPILER} DIRECTORY)
-        get_filename_component(TOOLCHAIN_LIB_DIR "${TOOLCHAIN_BIN_DIR}/../lib/swift/macosx" ABSOLUTE)
-        target_link_directories(${name} PUBLIC ${TOOLCHAIN_LIB_DIR})
-
-        # Add in the SDK directory for the host platform.
-        #
-        # NOTE: We do this /after/ target_link_directorying TOOLCHAIN_LIB_DIR to
-        # ensure that we first find libraries from the toolchain, rather than
-        # from the SDK. The reason why this is important is that when we perform
-        # a stage2 build, this path is into the stage1 build. This is not a pure
-        # SDK and also contains compatibility libraries. We need to make sure
-        # that the compiler sees the actual toolchain's compatibility libraries
-        # first before the just built compability libraries or build errors occur.
-        target_link_directories(${name} PRIVATE
-          ${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_ARCH_${SWIFT_HOST_VARIANT_ARCH}_PATH}/usr/lib/swift)
-      endif()
-    endif()
-
     # For now turn off on Darwin swift targets, debug info if we are compiling a static
     # library and set up an rpath so that if someone works around this by using
     # shared libraries that in the short term we can find shared libraries.
@@ -947,25 +911,7 @@ function(add_swift_host_tool executable)
       set_property(TARGET ${executable} APPEND_STRING PROPERTY
                    LINK_FLAGS " -lobjc ")
 
-    else() # ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE
-
-      # TODO: do we really need this? Do any tools which don't link libswift include other swift code?
-
-      # Add in the SDK directory for the host platform.
-      #
-      # NOTE: We do this /after/ target_link_directorying TOOLCHAIN_LIB_DIR to
-      # ensure that we first find libraries from the toolchain, rather than from
-      # the SDK.
-      target_link_directories(${executable} PRIVATE "${sdk_dir}")
-
-      # We also want to be able to find libraries from the base toolchain
-      # directory. This is so swiftc can rely on its own host side dylibs that may
-      # contain swift content.
-      list(APPEND RPATH_LIST "@executable_path/../lib")
-
-      # Also include the abi stable system stdlib in our rpath.
-      list(APPEND RPATH_LIST "/usr/lib/swift")
-    endif()
+    endif() # ASHT_HAS_LIBSWIFT AND LIBSWIFT_BUILD_MODE
 
     set_target_properties(${executable} PROPERTIES
       BUILD_WITH_INSTALL_RPATH YES

cmake/modules/FindICU.cmake

@@ -65,14 +65,6 @@ function(_report_sdk prefix)
       message(STATUS "  ${arch} libc header path: ${SWIFT_SDK_${prefix}_ARCH_${arch}_LIBC_INCLUDE_DIRECTORY}")
       message(STATUS "  ${arch} libc architecture specific header path: ${SWIFT_SDK_${prefix}_ARCH_${arch}_LIBC_ARCHITECTURE_INCLUDE_DIRECTORY}")
     endforeach()
-    if(SWIFT_BUILD_STDLIB)
-      foreach(arch ${SWIFT_SDK_${prefix}_ARCHITECTURES})
-        message(STATUS "  ${arch} ICU i18n INCLUDE: ${SWIFT_${prefix}_${arch}_ICU_I18N_INCLUDE}")
-        message(STATUS "  ${arch} ICU i18n LIB: ${SWIFT_${prefix}_${arch}_ICU_I18N}")
-        message(STATUS "  ${arch} ICU unicode INCLUDE: ${SWIFT_${prefix}_${arch}_ICU_UC_INCLUDE}")
-        message(STATUS "  ${arch} ICU unicode LIB: ${SWIFT_${prefix}_${arch}_ICU_UC}")
-      endforeach()
-    endif()
   endif()
 
   message(STATUS "")

cmake/modules/SwiftConfigureSDK.cmake

@@ -273,6 +273,15 @@ class ASTContext final {
   /// Diags - The diagnostics engine.
   DiagnosticEngine &Diags;
 
+  /// If the shared pointer is not a \c nullptr and the pointee is \c true,
+  /// all operations working on this ASTContext should be aborted at the next
+  /// possible opportunity.
+  /// This is used by SourceKit to cancel requests for which the result is no
+  /// longer of interest.
+  /// The returned result will be discarded, so the operation that acknowledges
+  /// the cancellation might return with any result.
+  std::shared_ptr<std::atomic<bool>> CancellationFlag = nullptr;
+
   TypeCheckCompletionCallback *CompletionCallback = nullptr;
 
   /// The request-evaluator that is used to process various requests.

include/swift/AST/ASTContext.h

@@ -91,6 +91,9 @@ ERROR(forbidden_interpolated_string,none,
 ERROR(forbidden_extended_escaping_string,none,
       "%0 cannot be an extended escaping string literal", (StringRef))
 
+ERROR(regex_literal_parsing_error,none,
+      "%0", (StringRef))
+
 //------------------------------------------------------------------------------
 // MARK: Lexer diagnostics
 //------------------------------------------------------------------------------
@@ -108,9 +111,6 @@ ERROR(lex_unprintable_ascii_character,none,
 ERROR(lex_invalid_utf8,none,
       "invalid UTF-8 found in source file", ())
 
-NOTE(lex_experimental_regex_strawperson,none,
-     "'%0'", (StringRef))
-
 ERROR(lex_single_quote_string,none,
       "single-quoted string literal found, use '\"'", ())
 ERROR(lex_invalid_curly_quote,none,
@@ -140,6 +140,9 @@ ERROR(lex_invalid_escape_delimiter,none,
 ERROR(lex_invalid_closing_delimiter,none,
       "too many '#' characters in closing delimiter", ())
 
+ERROR(lex_unterminated_regex,none,
+      "unterminated regex literal", ())
+
 ERROR(lex_invalid_unicode_scalar,none,
       "invalid unicode scalar", ())
 ERROR(lex_unicode_escape_braces,none,

include/swift/AST/DiagnosticsParse.def

@@ -3668,6 +3668,9 @@ ERROR(builtin_string_literal_broken_proto,none,
 ERROR(string_literal_broken_proto,none,
       "protocol 'ExpressibleByStringLiteral' is broken", ())
 
+ERROR(regex_decl_broken,none,
+      "cannot find 'Regex' type in scope", ())
+
 // Array literals
 ERROR(should_use_dictionary_literal,none,
       "dictionary of type %0 cannot be %select{used|initialized}1 "

include/swift/AST/DiagnosticsSema.def

@@ -961,7 +961,38 @@ class InterpolatedStringLiteralExpr : public LiteralExpr {
     return E->getKind() == ExprKind::InterpolatedStringLiteral;
   }
 };
-  
+
+/// A regular expression literal e.g '(a|c)*'.
+class RegexLiteralExpr : public LiteralExpr {
+  SourceLoc Loc;
+  StringRef RegexText;
+  Expr *SemanticExpr;
+
+  RegexLiteralExpr(SourceLoc loc, StringRef regexText, Expr *semanticExpr,
+                   bool isImplicit)
+      : LiteralExpr(ExprKind::RegexLiteral, isImplicit), Loc(loc),
+        RegexText(regexText), SemanticExpr(semanticExpr) {}
+
+public:
+  static RegexLiteralExpr *createParsed(ASTContext &ctx, SourceLoc loc,
+                                        StringRef regexText,
+                                        Expr *semanticExpr);
+
+  /// Retrieve the raw regex text.
+  StringRef getRegexText() const { return RegexText; }
+
+  /// Retrieve the semantic expression that the regex will be type-checked and
+  /// emitted as.
+  Expr *getSemanticExpr() const { return SemanticExpr; }
+  void setSemanticExpr(Expr *expr) { SemanticExpr = expr; }
+
+  SourceRange getSourceRange() const { return Loc; }
+
+  static bool classof(const Expr *E) {
+    return E->getKind() == ExprKind::RegexLiteral;
+  }
+};
+
 /// MagicIdentifierLiteralExpr - A magic identifier like #file which expands
 /// out to a literal at SILGen time.
 class MagicIdentifierLiteralExpr : public BuiltinLiteralExpr {

include/swift/AST/Expr.h

@@ -78,6 +78,7 @@ ABSTRACT_EXPR(Literal, Expr)
     LITERAL_EXPR(MagicIdentifierLiteral, BuiltinLiteralExpr)
     EXPR_RANGE(BuiltinLiteral, BooleanLiteral, MagicIdentifierLiteral)
   LITERAL_EXPR(InterpolatedStringLiteral, LiteralExpr)
+  LITERAL_EXPR(RegexLiteral, LiteralExpr)
   LITERAL_EXPR(ObjectLiteral, LiteralExpr)
   EXPR_RANGE(Literal, NilLiteral, ObjectLiteral)
 EXPR(DiscardAssignment, Expr)

include/swift/AST/ExprNodes.def

@@ -250,6 +250,10 @@ IDENTIFIER(pullback)
 IDENTIFIER(TangentVector)
 IDENTIFIER(zero)
 
+// Regex literals
+IDENTIFIER(Regex)
+IDENTIFIER(_regexString)
+
 // Distributed actors
 IDENTIFIER(transport)
 IDENTIFIER(using)