Merge pull request #4661 from swiftwasm/main

[pull] swiftwasm from main

Author: kateinoigakukun

CHANGELOG.md

@@ -488,6 +488,18 @@ _**Note:** This is in reverse chronological order, so newer entries are added to
   the result type provides a generalization where the callee chooses the
   resulting type and value.
 
+* The compiler now correctly emits errors for `@available` attributes on stored properties with the `lazy` modifier or with attached property wrappers. Previously, the attribute was accepted on this subset of stored properties but the resulting binary would crash at runtime when type metadata was unavailable.
+
+  ```swift
+  struct S {
+    @available(macOS 99, *) // error: stored properties cannot be marked potentially unavailable with '@available'
+    lazy var a: Int = 42
+  
+    @available(macOS 99, *) // error: stored properties cannot be marked potentially unavailable with '@available'
+    @Wrapper var b: Int
+  }
+  ```
+  
 * The compiler now correctly emits warnings for more kinds of expressions where a protocol conformance is used and may be unavailable at runtime. Previously, member reference expressions and type erasing expressions that used potentially unavailable conformances were not diagnosed, leading to potential crashes at runtime.
 
   ```swift

SwiftCompilerSources/CMakeLists.txt

@@ -168,6 +168,10 @@ function(add_swift_compiler_modules_library name)
               "-emit-module-path" "${build_dir}/${module}.swiftmodule"
               "-parse-as-library" ${sources}
               "-wmo" ${swift_compile_options}
+              # LLVM modules and headers.
+              "-Xcc" "-I" "-Xcc" "${LLVM_MAIN_INCLUDE_DIR}"
+              # Generated LLVM headers.
+              "-Xcc" "-I" "-Xcc" "${LLVM_INCLUDE_DIR}"
               # Bridging modules and headers.
               "-Xcc" "-I" "-Xcc" "${SWIFT_SOURCE_DIR}/include"
               # Generated C headers.

SwiftCompilerSources/Package.swift

@@ -20,6 +20,8 @@ private extension Target {
       "-Xfrontend", "-enable-experimental-cxx-interop",
       // Bridging modules and headers
       "-Xcc", "-I", "-Xcc", "../include",
+      // LLVM modules and headers
+      "-Xcc", "-I", "-Xcc", "../../llvm-project/llvm/include",
       "-cross-module-optimization"
     ]),
   ]

SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -80,7 +80,7 @@ public struct DiagnosticEngine {
                        highlight: CharSourceRange? = nil,
                        fixIts: [DiagnosticFixIt] = []) {
 
-    let bridgedSourceLoc: BridgedSourceLoc = position.bridged
+    let bridgedSourceLoc: swift.SourceLoc = position.bridged
     let bridgedHighlightRange: BridgedCharSourceRange = highlight.bridged
     var bridgedArgs: [BridgedDiagnosticArgument] = []
     var bridgedFixIts: [BridgedDiagnosticFixIt] = []

SwiftCompilerSources/Sources/Basic/SourceLoc.swift

@@ -21,15 +21,15 @@ public struct SourceLoc {
     self.locationInFile = locationInFile
   }
 
-  public init?(bridged: BridgedSourceLoc) {
-    guard let locationInFile = bridged.pointer else {
+  public init?(bridged: swift.SourceLoc) {
+    guard bridged.isValid() else {
       return nil
     }
-    self.init(locationInFile: locationInFile)
+    self.locationInFile = bridged.getOpaquePointerValue().assumingMemoryBound(to: UInt8.self)
   }
 
-  public var bridged: BridgedSourceLoc {
-    .init(pointer: locationInFile)
+  public var bridged: swift.SourceLoc {
+    .init(llvm.SMLoc.getFromPointer(locationInFile))
   }
 }
 
@@ -40,8 +40,8 @@ extension SourceLoc {
 }
 
 extension Optional where Wrapped == SourceLoc {
-  public var bridged: BridgedSourceLoc {
-    self?.bridged ?? .init(pointer: nil)
+  public var bridged: swift.SourceLoc {
+    self?.bridged ?? .init()
   }
 }
 
@@ -68,6 +68,6 @@ public struct CharSourceRange {
 
 extension Optional where Wrapped == CharSourceRange {
   public var bridged: BridgedCharSourceRange {
-    self?.bridged ?? .init(start: .init(pointer: nil), byteLength: 0)
+    self?.bridged ?? .init(start: .init(), byteLength: 0)
   }
 }

SwiftCompilerSources/Sources/Parse/Regex.swift

@@ -92,7 +92,7 @@ public func _RegexLiteralParsingFn(
   _ versionOut: UnsafeMutablePointer<CUnsignedInt>,
   _ captureStructureOut: UnsafeMutableRawPointer,
   _ captureStructureSize: CUnsignedInt,
-  _ bridgedDiagnosticBaseLoc: BridgedSourceLoc,
+  _ bridgedDiagnosticBaseLoc: swift.SourceLoc,
   _ bridgedDiagnosticEngine: BridgedDiagnosticEngine
 ) -> Bool {
   let str = String(cString: inputPtr)

docs/DevelopmentTips.md

@@ -23,10 +23,25 @@ Copy the invocation that has  ` -o <build-path>/swift-macosx-x86_64/stdlib/publi
 ### Choosing the bootstrapping mode
 By default, the compiler builds with the `boostrapping-with-hostlibs` (macOS) or `bootstrapping` (Linux) bootstrapping mode. To speed up local development it's recommended to build with the `hosttools` mode: `utils/build-script --bootstrapping=hosttools`.
 
-It requires a recently new swift toolchain to be installed on your build machine. On macOS this comes with your Xcode installation.
+It requires a recently new swift toolchain to be installed on your build machine. You might need to download and install a nightly Swift toolchain to build the Swift project in `hosttools` mode.
 
 Not that changing the bootstrapping mode needs a reconfiguration.
 
+#### Using a locally built Swift toolchain
+
+If you do not want to install a nightly Swift toolchain, or you need to debug Swift code within SwiftCompilerSources, you can build the Swift toolchain in `boostrapping-with-hostlibs` mode on your local machine once, and then use this toolchain to iterate on your changes with the `hosttools` mode:
+
+* Build the toolchain locally in `boostrapping-with-hostlibs` mode: `./utils/build-toolchain com.yourname`.
+* Copy the `swift-LOCAL-YYYY-MM-DD.xctoolchain` file from `./swift-nightly-install/Library/Developer/Toolchains` to `/Library/Developer/Toolchains`.
+* Launch Xcode, in the menu bar select _Xcode_ > _Toolchains_ > _Local Swift Development Snapshot YYYY-MM-DD_.
+* Remove the Swift build directory: `./build`.
+* Run the Swift build script with the locally built Swift toolchain in `hosttools` mode: `TOOLCHAINS=com.yourname.YYYYMMDD ./utils/build-script --bootstrapping=hosttools`. Repeat this step as you iterate on your change.
+
+To debug using LLDB, run LLDB from the locally built toolchain with a couple of environment variables set:
+```
+DYLD_LIBRARY_PATH=/Library/Developer/Toolchains/swift-LOCAL-YYYY-MM-DD.xctoolchain/usr/lib/swift/macosx DYLD_FRAMEWORK_PATH=/Applications/Xcode.app/Contents/Developer/Library/Frameworks /Library/Developer/Toolchains/swift-LOCAL-YYYY-MM-DD.xctoolchain/usr/bin/lldb
+```
+
 ### Working with two build directories
 For developing and debugging you are probably building a debug configuration of swift. But it's often beneficial to also build a release-assert configuration in parallel (`utils/build-script -R`).
 

include/swift/AST/ASTBridging.h

@@ -18,10 +18,6 @@
 #include <stdbool.h>
 #include <stddef.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 //===----------------------------------------------------------------------===//
@@ -56,7 +52,7 @@ typedef struct {
 } BridgedDiagnosticArgument;
 
 typedef struct {
-  BridgedSourceLoc start;
+  swift::SourceLoc start;
   SwiftInt byteLength;
   BridgedStringRef text;
 } BridgedDiagnosticFixIt;
@@ -70,7 +66,7 @@ typedef struct {
 } BridgedOptionalDiagnosticEngine;
 
 // FIXME: Can we bridge InFlightDiagnostic?
-void DiagnosticEngine_diagnose(BridgedDiagnosticEngine, BridgedSourceLoc loc,
+void DiagnosticEngine_diagnose(BridgedDiagnosticEngine, swift::SourceLoc loc,
                                BridgedDiagID diagID, BridgedArrayRef arguments,
                                BridgedCharSourceRange highlight,
                                BridgedArrayRef fixIts);
@@ -79,8 +75,4 @@ bool DiagnosticEngine_hadAnyError(BridgedDiagnosticEngine);
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif // SWIFT_AST_ASTBRIDGING_H

include/swift/AST/Decl.h

@@ -6414,9 +6414,6 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
   /// A function is concurrent if it has the @Sendable attribute.
   bool isSendable() const;
 
-  /// Determine if function has 'nonisolated' attribute
-  bool isNonisolated() const;
-
   /// Returns true if the function is a suitable 'async' context.
   ///
   /// Functions that are an 'async' context can make calls to 'async' functions.

include/swift/AST/DiagnosticsSema.def

@@ -4495,8 +4495,8 @@ ERROR(actor_inheritance,none,
       (bool))
 
 ERROR(actor_protocol_illegal_inheritance,none,
-      "non-actor type %0 cannot conform to the 'Actor' protocol",
-      (DeclName))
+      "non-actor type %0 cannot conform to the %1 protocol",
+      (DeclName, DeclName))
 ERROR(distributed_actor_conformance_missing_system_type,none,
       "distributed actor %0 does not declare ActorSystem it can be used with.",
       (DeclName))

include/swift/AST/KnownProtocols.def

@@ -59,6 +59,7 @@
     BUILTIN_EXPRESSIBLE_BY_LITERAL_PROTOCOL_WITH_NAME(name, "_" #name)
 
 PROTOCOL(Actor)
+PROTOCOL(AnyActor)
 PROTOCOL(Sequence)
 PROTOCOL(Identifiable)
 PROTOCOL(IteratorProtocol)

include/swift/Basic/BasicBridging.h

@@ -14,12 +14,9 @@
 #define SWIFT_BASIC_BASICBRIDGING_H
 
 #include "swift/Basic/BridgedSwiftObject.h"
+#include "swift/Basic/SourceLoc.h"
 #include <stddef.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 typedef intptr_t SwiftInt;
@@ -48,18 +45,10 @@ void freeBridgedStringRef(BridgedStringRef str);
 //===----------------------------------------------------------------------===//
 
 typedef struct {
-  const unsigned char * _Nullable pointer;
-} BridgedSourceLoc;
-
-typedef struct {
-  BridgedSourceLoc start;
+  swift::SourceLoc start;
   SwiftInt byteLength;
 } BridgedCharSourceRange;
 
 SWIFT_END_NULLABILITY_ANNOTATIONS
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif

include/swift/Basic/BridgingUtils.h

@@ -36,25 +36,14 @@ inline llvm::ArrayRef<T> getArrayRef(BridgedArrayRef bridged) {
   return {static_cast<const T *>(bridged.data), bridged.numElements};
 }
 
-inline SourceLoc getSourceLoc(const BridgedSourceLoc &bridged) {
-  return SourceLoc(
-      llvm::SMLoc::getFromPointer((const char *)bridged.pointer));
-}
-
-inline BridgedSourceLoc getBridgedSourceLoc(const SourceLoc &loc) {
-  return {static_cast<const unsigned char *>(loc.getOpaquePointerValue())};
-}
-
 inline CharSourceRange
 getCharSourceRange(const BridgedCharSourceRange &bridged) {
-  auto start = getSourceLoc(bridged.start);
-  return CharSourceRange(start, bridged.byteLength);
+  return CharSourceRange(bridged.start, bridged.byteLength);
 }
 
 inline BridgedCharSourceRange
 getBridgedCharSourceRange(const CharSourceRange &range) {
-  auto start = getBridgedSourceLoc(range.getStart());
-  return {start, range.getByteLength()};
+  return {range.getStart(), range.getByteLength()};
 }
 
 /// Copies the string in an malloc'ed memory and the caller is responsible for

include/swift/Parse/RegexParserBridging.h

@@ -17,10 +17,6 @@
 #include "swift/AST/ASTBridging.h"
 #include <stdbool.h>
 
-#ifdef __cplusplus
-extern "C" {
-#endif
-
 /// Attempt to lex a regex literal string. Takes the following arguments:
 ///
 /// - CurPtrPtr: A pointer to the current pointer of lexer, which should be the
@@ -60,12 +56,8 @@ typedef bool (*RegexLiteralParsingFn)(/*InputPtr*/ const char *_Nonnull,
                                       /*VersionOut*/ unsigned *_Nonnull,
                                       /*CaptureStructureOut*/ void *_Nonnull,
                                       /*CaptureStructureSize*/ unsigned,
-                                      /*DiagnosticBaseLoc*/ BridgedSourceLoc,
+                                      /*DiagnosticBaseLoc*/ swift::SourceLoc,
                                       BridgedDiagnosticEngine);
 void Parser_registerRegexLiteralParsingFn(RegexLiteralParsingFn _Nullable fn);
 
-#ifdef __cplusplus
-} // extern "C"
-#endif
-
 #endif // REGEX_PARSER_BRIDGING

lib/AST/ASTBridging.cpp

@@ -38,14 +38,13 @@ getDiagnosticArgument(const BridgedDiagnosticArgument &bridged) {
 } // namespace
 
 void DiagnosticEngine_diagnose(
-    BridgedDiagnosticEngine bridgedEngine, BridgedSourceLoc bridgedLoc,
+    BridgedDiagnosticEngine bridgedEngine, SourceLoc loc,
     BridgedDiagID bridgedDiagID,
     BridgedArrayRef /*BridgedDiagnosticArgument*/ bridgedArguments,
     BridgedCharSourceRange bridgedHighlight,
     BridgedArrayRef /*BridgedDiagnosticFixIt*/ bridgedFixIts) {
   auto *D = getDiagnosticEngine(bridgedEngine);
 
-  auto loc = getSourceLoc(bridgedLoc);
   auto diagID = static_cast<DiagID>(bridgedDiagID);
   SmallVector<DiagnosticArgument, 2> arguments;
   for (auto bridgedArg :
@@ -62,7 +61,7 @@ void DiagnosticEngine_diagnose(
 
   // Add fix-its.
   for (auto bridgedFixIt : getArrayRef<BridgedDiagnosticFixIt>(bridgedFixIts)) {
-    auto range = CharSourceRange(getSourceLoc(bridgedFixIt.start),
+    auto range = CharSourceRange(bridgedFixIt.start,
                                  bridgedFixIt.byteLength);
     auto text = getStringRef(bridgedFixIt.text);
     inflight.fixItReplaceChars(range.getStart(), range.getEnd(), text);

lib/AST/Decl.cpp

@@ -7781,10 +7781,6 @@ bool AbstractFunctionDecl::isSendable() const {
   return getAttrs().hasAttribute<SendableAttr>();
 }
 
-bool AbstractFunctionDecl::isNonisolated() const {
-  return getAttrs().hasAttribute<NonisolatedAttr>();
-}
-
 bool AbstractFunctionDecl::isBackDeployed() const {
   if (getAttrs().hasAttribute<BackDeployAttr>())
     return true;

lib/AST/Type.cpp

@@ -960,6 +960,67 @@ Type TypeBase::stripConcurrency(bool recurse, bool dropGlobalActor) {
     return newFnType;
   }
 
+  if (auto existentialType = getAs<ExistentialType>()) {
+    auto newConstraintType = existentialType->getConstraintType()
+        ->stripConcurrency(recurse, dropGlobalActor);
+    if (newConstraintType.getPointer() ==
+            existentialType->getConstraintType().getPointer())
+      return Type(this);
+
+    return ExistentialType::get(newConstraintType);
+  }
+
+  if (auto protocolType = getAs<ProtocolType>()) {
+    if (protocolType->getDecl()->isSpecificProtocol(
+            KnownProtocolKind::Sendable))
+      return ProtocolCompositionType::get(getASTContext(), { }, false);
+
+    return Type(this);
+  }
+
+  if (auto protocolCompositionType = getAs<ProtocolCompositionType>()) {
+    SmallVector<Type, 4> newMembers;
+    auto members = protocolCompositionType->getMembers();
+    for (unsigned i : indices(members)) {
+      auto memberType = members[i];
+      auto newMemberType =
+          memberType->stripConcurrency(recurse, dropGlobalActor);
+      if (!newMembers.empty()) {
+        newMembers.push_back(newMemberType);
+        continue;
+      }
+
+      if (memberType.getPointer() != newMemberType.getPointer()) {
+        newMembers.append(members.begin(), members.begin() + i);
+        newMembers.push_back(newMemberType);
+        continue;
+      }
+    }
+
+    if (!newMembers.empty()) {
+      return ProtocolCompositionType::get(
+          getASTContext(), newMembers,
+          protocolCompositionType->hasExplicitAnyObject());
+    }
+
+    return Type(this);
+  }
+
+  if (auto existentialMetatype = getAs<ExistentialMetatypeType>()) {
+    auto instanceType = existentialMetatype->getExistentialInstanceType();
+    auto newInstanceType =
+        instanceType->stripConcurrency(recurse, dropGlobalActor);
+    if (instanceType.getPointer() != newInstanceType.getPointer()) {
+      Optional<MetatypeRepresentation> repr;
+      if (existentialMetatype->hasRepresentation())
+        repr = existentialMetatype->getRepresentation();
+      return ExistentialMetatypeType::get(
+          newInstanceType, repr, getASTContext());
+    }
+
+    return Type(this);
+  }
+
   return Type(this);
 }