Merge branch 'apple:main' into nicked/getting-started

Author: nicked

include/swift/Basic/Compiler.h

@@ -13,6 +13,8 @@
 #ifndef SWIFT_BASIC_COMPILER_H
 #define SWIFT_BASIC_COMPILER_H
 
+#include <stddef.h>
+
 #if defined(_MSC_VER) && !defined(__clang__)
 #define SWIFT_COMPILER_IS_MSVC 1
 #else
@@ -190,4 +192,21 @@
 #define ENUM_EXTENSIBILITY_ATTR(arg)
 #endif
 
+// The 'u8' string literal prefix creates `char` types on C++14/17 but
+// `char8_t` types on C++20. To support compiling in both modes
+// simultaneously, wrap Unicode literals in `SWIFT_UTF8("...")` to ensure
+// that they are interpreted by the compiler as UTF-8 but always return
+// `char` types.
+#if defined(__cplusplus)
+#if defined(__cpp_char8_t)
+inline constexpr char operator""_swift_u8(char8_t c) { return c; }
+inline const char *operator""_swift_u8(const char8_t *p, std::size_t) {
+  return reinterpret_cast<const char *>(p);
+}
+#define SWIFT_UTF8(literal) u8##literal##_swift_u8
+#else  // !defined(__cpp_char8_t)
+#define SWIFT_UTF8(literal) u8##literal
+#endif // defined(__cpp_char8_t)
+#endif // defined(__cplusplus)
+
 #endif // SWIFT_BASIC_COMPILER_H

lib/AST/Type.cpp

@@ -36,6 +36,7 @@
 #include "swift/AST/SubstitutionMap.h"
 #include "swift/AST/TypeLoc.h"
 #include "swift/AST/TypeRepr.h"
+#include "swift/Basic/Compiler.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/APFloat.h"
 #include "llvm/ADT/SmallPtrSet.h"
@@ -2036,8 +2037,8 @@ Identifier GenericTypeParamType::getName() const {
   llvm::SmallString<10> nameBuf;
   llvm::raw_svector_ostream os(nameBuf);
 
-  static const char *tau = u8"\u03C4_";
-  
+  static const char *tau = SWIFT_UTF8("\u03C4_");
+
   os << tau << getDepth() << '_' << getIndex();
   Identifier name = C.getIdentifier(os.str());
   names.insert({depthIndex, name});

lib/Basic/Unicode.cpp

@@ -11,6 +11,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/Basic/Unicode.h"
+#include "swift/Basic/Compiler.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ConvertUTF.h"
@@ -135,7 +136,7 @@ std::string swift::unicode::sanitizeUTF8(StringRef Text) {
   Builder.reserve(Text.size());
   const llvm::UTF8* Data = reinterpret_cast<const llvm::UTF8*>(Text.begin());
   const llvm::UTF8* End = reinterpret_cast<const llvm::UTF8*>(Text.end());
-  StringRef Replacement = u8"\ufffd";
+  StringRef Replacement = SWIFT_UTF8("\ufffd");
   while (Data < End) {
     auto Step = llvm::getNumBytesForUTF8(*Data);
     if (Data + Step > End) {

lib/IRGen/IRGenDebugInfo.cpp

@@ -28,6 +28,7 @@
 #include "swift/AST/ModuleLoader.h"
 #include "swift/AST/Pattern.h"
 #include "swift/AST/TypeDifferenceVisitor.h"
+#include "swift/Basic/Compiler.h"
 #include "swift/Basic/Dwarf.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Version.h"
@@ -3034,7 +3035,7 @@ void IRGenDebugInfoImpl::emitTypeMetadata(IRGenFunction &IGF,
     return;
 
   llvm::SmallString<8> Buf;
-  static const char *Tau = u8"\u03C4";
+  static const char *Tau = SWIFT_UTF8("\u03C4");
   llvm::raw_svector_ostream OS(Buf);
   OS << '$' << Tau << '_' << Depth << '_' << Index;
   uint64_t PtrWidthInBits = CI.getTargetInfo().getPointerWidth(0);

lib/Macros/Sources/SwiftMacros/OptionSetMacro.swift

@@ -123,27 +123,25 @@ public struct OptionSetMacro {
   }
 }
 
-extension OptionSetMacro: ConformanceMacro {
-  public static func expansion<
-    Decl: DeclGroupSyntax,
-    Context: MacroExpansionContext
-  >(
+extension OptionSetMacro: ExtensionMacro {
+  public static func expansion(
     of attribute: AttributeSyntax,
-    providingConformancesOf decl: Decl,
-    in context: Context
-  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-    // Decode the expansion arguments.
-    guard let (structDecl, _, _) = decodeExpansion(of: attribute, attachedTo: decl, in: context) else {
-      return []
-    }
-
+    attachedTo decl: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
+    in context: some MacroExpansionContext
+  ) throws -> [ExtensionDeclSyntax] {
     // If there is an explicit conformance to OptionSet already, don't add one.
-    if let inheritedTypes = structDecl.inheritanceClause?.inheritedTypes,
-       inheritedTypes.contains(where: { inherited in inherited.type.trimmedDescription == "OptionSet" }) {
+    if protocols.isEmpty {
       return []
     }
 
-    return [("OptionSet", nil)]
+    let ext: DeclSyntax =
+      """
+      extension \(type.trimmed): OptionSet {}
+      """
+
+    return [ext.cast(ExtensionDeclSyntax.self)]
   }
 }
 

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -1080,6 +1080,10 @@ function(add_swift_target_library_single target name)
       target_include_directories("${target}" SYSTEM PRIVATE
         ${SWIFTLIB_INCLUDE})
     endif()
+    if(libkind STREQUAL STATIC)
+      set_property(TARGET "${target}" PROPERTY
+        PREFIX lib)
+    endif()
   endif()
 
   if("${SWIFTLIB_SINGLE_SDK}" STREQUAL "WINDOWS" AND NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "Windows")
@@ -2665,6 +2669,10 @@ function(_add_swift_target_executable_single name)
     set_target_properties(${name} PROPERTIES
       BUILD_WITH_INSTALL_RPATH YES
       INSTALL_RPATH "@executable_path/../lib/swift/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR};@executable_path/../../../lib/swift/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR}")
+  elseif(SWIFT_HOST_VARIANT_SDK STREQUAL "LINUX")
+    set_target_properties(${name} PROPERTIES
+      BUILD_WITH_INSTALL_RPATH YES
+      INSTALL_RPATH "$ORIGIN/../../../lib/swift/${SWIFT_SDK_${SWIFTEXE_SINGLE_SDK}_LIB_SUBDIR}")
   endif()
   set_output_directory(${name}
       BINARY_DIR ${SWIFT_RUNTIME_OUTPUT_INTDIR}

stdlib/public/Backtracing/Dwarf.swift

@@ -1538,7 +1538,7 @@ struct DwarfReader<S: DwarfSource> {
 
     var cursor = ImageSourceCursor(source: infoSection,
                                    offset: abstractOrigin)
-    let abbrev = try cursor.readULEB128()
+    var abbrev = try cursor.readULEB128()
     if abbrev == 0 {
       return
     }
@@ -1553,13 +1553,39 @@ struct DwarfReader<S: DwarfSource> {
       return
     }
 
-    let refAttrs = try readDieAttributes(
+    var refAttrs = try readDieAttributes(
       at: &cursor,
       unit: unit,
       abbrevInfo: abbrevInfo,
       shouldFetchIndirect: true
     )
 
+    if let specificationVal = refAttrs[.DW_AT_specification],
+       case let .reference(specification) = specificationVal {
+      cursor = ImageSourceCursor(source: infoSection,
+                                 offset: specification)
+      abbrev = try cursor.readULEB128()
+      if abbrev == 0 {
+        return
+      }
+
+      guard let abbrevInfo = unit.abbrevs[abbrev] else {
+        throw DwarfError.missingAbbrev(abbrev)
+      }
+
+      let tag = abbrevInfo.tag
+      if tag != .DW_TAG_subprogram {
+        return
+      }
+      
+      refAttrs = try readDieAttributes(
+        at: &cursor,
+        unit: unit,
+        abbrevInfo: abbrevInfo,
+        shouldFetchIndirect: true
+      )
+    }
+
     var name: String? = nil
     var rawName: String? = nil
 

stdlib/public/Cxx/std/CMakeLists.txt

@@ -31,7 +31,7 @@ add_swift_target_library(swiftCxxStdlib STATIC NO_LINK_NAME IS_STDLIB IS_SWIFT_O
     ${SWIFT_SDK_LINUX_CXX_OVERLAY_SWIFT_COMPILE_FLAGS}
 
     LINK_FLAGS "${SWIFT_RUNTIME_SWIFT_LINK_FLAGS}"
-    TARGET_SDKS ALL_APPLE_PLATFORMS LINUX
+    TARGET_SDKS ALL_APPLE_PLATFORMS LINUX WINDOWS
     INSTALL_IN_COMPONENT compiler
     INSTALL_WITH_SHARED
     DEPENDS libstdcxx-modulemap libcxxshim_modulemap)

test/IRGen/debug_scope_distinct.swift

@@ -1,3 +1,5 @@
+// REQUIRES: differentiable_programming
+
 // RUN: %empty-directory(%t)
 // RUN: %target-swiftc_driver -DM -emit-module -emit-module-path %t/M.swiftmodule %s -module-name M
 // RUN: %target-swiftc_driver -O -g -I %t -c %s -emit-ir -o - | %FileCheck %s

test/Index/index_macros.swift

@@ -207,14 +207,16 @@ public struct SomeAccessorMacro: AccessorMacro {
   }
 }
 
-public struct SomeConformanceMacro: ConformanceMacro {
+public struct SomeConformanceMacro: ExtensionMacro {
   public static func expansion(
     of node: AttributeSyntax,
-    providingConformancesOf decl: some DeclGroupSyntax,
+    attachedTo: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
     in context: some MacroExpansionContext
-  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-    let protocolName: TypeSyntax = "TestProto"
-    return [(protocolName, nil)]
+  ) throws -> [ExtensionDeclSyntax] {
+    let ext: DeclSyntax = "extension \(type.trimmed): TestProto {}"
+    return [ext.cast(ExtensionDeclSyntax.self)]
   }
 }
 

test/Interop/Cxx/stdlib/Inputs/std-map.h

@@ -7,6 +7,7 @@
 
 using Map = std::map<int, int>;
 using MapStrings = std::map<std::string, std::string>;
+using NestedMap = std::map<int, Map>;
 using UnorderedMap = std::unordered_map<int, int>;
 
 inline Map initMap() { return {{1, 3}, {2, 2}, {3, 3}}; }

test/Interop/Cxx/stdlib/use-std-map.swift

@@ -50,6 +50,24 @@ StdMapTestSuite.test("MapStrings.subscript") {
   expectEqual(m[std.string("abc")], std.string("qwe"))
 }
 
+StdMapTestSuite.test("NestedMap.subscript") {
+  var m = NestedMap()
+  expectNil(m[0])
+  expectNil(m[0])
+  m[1] = Map()
+  expectNotNil(m[1])
+
+  expectNil(m[1]![0])
+  m[1]![0] = 123
+  expectEqual(m[1]![0], 123)
+
+  m[1]![0] = nil
+  expectNil(m[1]![0])
+
+  m[1] = nil
+  expectNil(m[1])
+}
+
 StdMapTestSuite.test("UnorderedMap.subscript") {
   // This relies on the `std::unordered_map` conformance to `CxxDictionary` protocol.
   var m = initUnorderedMap()

test/Macros/Inputs/syntax_macro_definitions.swift

@@ -1281,14 +1281,16 @@ public struct EmptyPeerMacro: PeerMacro {
   }
 }
 
-public struct EquatableMacro: ConformanceMacro {
+public struct EquatableMacro: ExtensionMacro {
   public static func expansion(
     of node: AttributeSyntax,
-    providingConformancesOf decl: some DeclGroupSyntax,
+    attachedTo: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
     in context: some MacroExpansionContext
-  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-    let protocolName: TypeSyntax = "Equatable"
-    return [(protocolName, nil)]
+  ) throws -> [ExtensionDeclSyntax] {
+    let ext: DeclSyntax = "extension \(type.trimmed): Equatable {}"
+    return [ext.cast(ExtensionDeclSyntax.self)]
   }
 }
 
@@ -1316,34 +1318,37 @@ public struct ConformanceViaExtensionMacro: ExtensionMacro {
   }
 }
 
-public struct HashableMacro: ConformanceMacro {
+public struct HashableMacro: ExtensionMacro {
   public static func expansion(
     of node: AttributeSyntax,
-    providingConformancesOf decl: some DeclGroupSyntax,
+    attachedTo: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
     in context: some MacroExpansionContext
-  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-    let protocolName: TypeSyntax = "Hashable"
-    return [(protocolName, nil)]
+  ) throws -> [ExtensionDeclSyntax] {
+    let ext: DeclSyntax = "extension \(type.trimmed): Hashable {}"
+    return [ext.cast(ExtensionDeclSyntax.self)]
   }
 }
 
-public struct DelegatedConformanceMacro: ConformanceMacro, MemberMacro {
+public struct DelegatedConformanceMacro: ExtensionMacro, MemberMacro {
   public static func expansion(
     of node: AttributeSyntax,
-    providingConformancesOf decl: some DeclGroupSyntax,
+    attachedTo: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
     in context: some MacroExpansionContext
-  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-    let protocolName: TypeSyntax = "P"
+  ) throws -> [ExtensionDeclSyntax] {
     let conformance: DeclSyntax =
       """
-      extension Placeholder where Element: P {}
+      extension \(type.trimmed): P where Element: P {}
       """
 
     guard let extensionDecl = conformance.as(ExtensionDeclSyntax.self) else {
       return []
     }
 
-    return [(protocolName, extensionDecl.genericWhereClause)]
+    return [extensionDecl]
   }
 
   public static func expansion(
@@ -1760,26 +1765,21 @@ public struct AddPeerStoredPropertyMacro: PeerMacro, Sendable {
   }
 }
 
-public struct InitializableMacro: ConformanceMacro, MemberMacro {
+public struct InitializableMacro: ExtensionMacro {
   public static func expansion(
     of node: AttributeSyntax,
-    providingConformancesOf decl: some DeclGroupSyntax,
-    in context: some MacroExpansionContext
-  ) throws -> [(TypeSyntax, GenericWhereClauseSyntax?)] {
-    return [("Initializable", nil)]
-  }
-
-  public static func expansion(
-    of node: AttributeSyntax,
-    providingMembersOf decl: some DeclGroupSyntax,
+    attachedTo: some DeclGroupSyntax,
+    providingExtensionsOf type: some TypeSyntaxProtocol,
+    conformingTo protocols: [TypeSyntax],
     in context: some MacroExpansionContext
-  ) throws -> [DeclSyntax] {
-    let requirement: DeclSyntax =
+  ) throws -> [ExtensionDeclSyntax] {
+    let ext: DeclSyntax = 
       """
-      init(value: Int) {}
+      extension \(type.trimmed): Initializable {
+        init(value: Int) {}
+      }
       """
-
-    return [requirement]
+    return [ext.cast(ExtensionDeclSyntax.self)]
   }
 }
 

test/Macros/top_level_freestanding.swift

@@ -117,8 +117,7 @@ macro Empty<T>(_ closure: () -> T) = #externalMacro(module: "MacroDefinition", t
   S(a: 10, b: 10)
 }
 
-@attached(extension, conformances: Initializable)
-@attached(member, names: named(init))
+@attached(extension, conformances: Initializable, names: named(init))
 macro Initializable() = #externalMacro(module: "MacroDefinition", type: "InitializableMacro")
 
 protocol Initializable {