swiftlang/swift

Description note_isolate_conformance_to_global_actor doesn't check if the protocol refines SendableMetatype. If it does, an isolated conformance isn't allowed, so this is a bad suggestion. This note and fix-it should be conditionalized on if the protocol refines SendableMetatype. Reproduction protocol P: SendableMetatype { static var n: Int { get } } @MainActor struct S: P { static let n = 0 } error: conformance of 'S' to protocol 'P' crosses into main actor-isolated code and can cause data races [conformance_mismatched_isolation_common] [#ConformanceIsolation] 4 | 5 | @MainActor 6 | struct S: P { | |- error: conformance of 'S' to protocol 'P' crosses into main actor-isolated code and can cause data races [conformance_mismatched_isolation_common] [#ConformanceIsolation] | |- note: isolate this conformance to the main actor with '@MainActor' [note_isolate_conformance_to_global_actor] | `- note: turn data races into runtime errors with '@preconcurre

Description No response Reproduction func sync() -> Int? {} func async() async -> Int? {} do { if let x = sync(), true {} // bad fix-it if let x = sync() {} // good fix-it if let x = await async(), true {} // bad fix-it if let x = await async() {} // good fix-it } warning: immutable value 'x' was never used; consider replacing with '_' or removing it [#NoUsage] if let x = sync(), true {} ~~~~^ _ warning: value 'x' was defined but never used; consider replacing with boolean test [#NoUsage] if let x = sync() {} ~~~~^~~~ != nil warning: immutable value 'x' was never used; consider replacing with '_' or removing it [#NoUsage] if let x = await async(), true {} ~~~~^ _ warning: value 'x' was defined but never used; consider replacing with boolean test [#NoUsage] if let x = await async() {} ~~~~^~~~ ( ) != nil Expected behavior Fix-it should match the one we emit when the condition is single.

Description When creating a typealias that partially specializes a generic type, the compiler generates an error when attempting to extend that type via the typealias. Steps to reproduce Create a Generic type with two type parameters. struct Field<Tag,Value> { let tag: Tag let value: Value } Define a typealias which specializes one of the type parameters as such : typealias IntField<Tag> = Field<Tag,Int> Define an extension based on the typealias: extension IntField { func adding(_ value: Int) -> Self { Field(tag: tag, value: self.value + value) } } Expected behavior I would expect this code to compile. Instead the compiler complained: "Binary operator '+' cannot be applied to operands of type 'Value' and 'Int'" If instead of extending the typealias, I extend the type directly it compiles fine as such: extension Field where Value == Int { func adding(_ value: Int) -> Self { Field(tag: tag, value: self.value + value) } } Environment Swift compiler version info swift

Description No response Reproduction @MainActor final class C { nonisolated var c = 0 } actor A { nonisolated var a = 0 } @MainActor struct S { nonisolated var s = 0 } <source>:3:3: error: 'nonisolated' cannot be applied to mutable stored properties 1 | @MainActor 2 | final class C { 3 | nonisolated var c = 0 | | `- note: convert 'c' to a 'let' constant or consider declaring it 'nonisolated(unsafe)' if manually managing concurrency safety | `- error: 'nonisolated' cannot be applied to mutable stored properties 4 | } 5 | actor A { <source>:6:3: error: 'nonisolated' cannot be applied to mutable stored properties 4 | } 5 | actor A { 6 | nonisolated var a = 0 | | `- note: convert 'a' to a 'let' constant or consider declaring it 'nonisolated(unsafe)' if manually managing concurrency safety | `- error: 'nonisolated' cannot be applied to mutable stored properties 7 | } 8 | @MainActor Expected behavior 'nonisolated' cannot

Description This is not true. The attribute can also be used on declarations such as types, functions, and imports. Reproduction let _: @preconcurrency @MainActor() -> Void = {} error: '@preconcurrency' only applies in inheritance clauses 83 | 84 | let _: @preconcurrency @MainActor() -> Void = {} | `- error: '@preconcurrency' only applies in inheritance clauses 85 | Expected behavior An accurate error message. It might be better to say that @preconcurrency cannot be used on a type attribute instead of enumerating all the valid positions. Environment Swift version 6.3-dev (fefcb25) Additional information No response