Skip to content

Commit 56b565b

Browse files
DougGregorDougGregor
authored
Merge pull request #40371 from DougGregor/concurrency-function-type-conversions-as-warnings
Downgrade concurrency-related function type errors in existing code
2 parents 47b375f + c0f5502 commit 56b565b

14 files changed

+165
-146
lines changed

‎include/swift/AST/DiagnosticsSema.def

Lines changed: 0 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -398,22 +398,12 @@ NOTE(generic_parameter_inferred_from_result_context,none,
398398
ERROR(cannot_pass_type_to_non_ephemeral,none,
399399
"cannot pass %0 to parameter; argument %1 must be a pointer that "
400400
"outlives the call%select{| to %3}2", (Type, StringRef, bool, DeclName))
401-
WARNING(cannot_pass_type_to_non_ephemeral_warning,none,
402-
"passing %0 to parameter, but argument %1 should be a pointer that "
403-
"outlives the call%select{| to %3}2", (Type, StringRef, bool, DeclName))
404401
ERROR(cannot_use_inout_non_ephemeral,none,
405402
"cannot use inout expression here; argument %0 must be a pointer that "
406403
"outlives the call%select{| to %2}1", (StringRef, bool, DeclName))
407-
WARNING(cannot_use_inout_non_ephemeral_warning,none,
408-
"inout expression creates a temporary pointer, but argument %0 should "
409-
"be a pointer that outlives the call%select{| to %2}1",
410-
(StringRef, bool, DeclName))
411404
ERROR(cannot_construct_dangling_pointer,none,
412405
"initialization of %0 results in a dangling %select{|buffer }1pointer",
413406
(Type, unsigned))
414-
WARNING(cannot_construct_dangling_pointer_warning,none,
415-
"initialization of %0 results in a dangling %select{|buffer }1pointer",
416-
(Type, unsigned))
417407
NOTE(ephemeral_pointer_argument_conversion_note,none,
418408
"implicit argument conversion from %0 to %1 produces a pointer valid only "
419409
"for the duration of the call%select{| to %3}2",

‎include/swift/AST/EducationalNotes.def

Lines changed: 0 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -25,17 +25,9 @@ EDUCATIONAL_NOTES(could_not_use_member_on_existential,
2525
"existential-member-access-limitations.md")
2626

2727
EDUCATIONAL_NOTES(cannot_pass_type_to_non_ephemeral, "temporary-pointers.md")
28-
EDUCATIONAL_NOTES(cannot_pass_type_to_non_ephemeral_warning,
29-
"temporary-pointers.md")
3028
EDUCATIONAL_NOTES(cannot_use_inout_non_ephemeral,
3129
"temporary-pointers.md")
32-
EDUCATIONAL_NOTES(cannot_use_inout_non_ephemeral_warning,
33-
"temporary-pointers.md")
3430
EDUCATIONAL_NOTES(cannot_construct_dangling_pointer, "temporary-pointers.md")
35-
EDUCATIONAL_NOTES(cannot_construct_dangling_pointer_warning,
36-
"temporary-pointers.md")
37-
38-
3931

4032
EDUCATIONAL_NOTES(non_nominal_no_initializers, "nominal-types.md")
4133
EDUCATIONAL_NOTES(non_nominal_extension, "nominal-types.md")

‎include/swift/Sema/CSFix.h

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -650,9 +650,9 @@ class ContextualMismatch : public ConstraintFix {
650650
Type LHS, RHS;
651651

652652
ContextualMismatch(ConstraintSystem &cs, Type lhs, Type rhs,
653-
ConstraintLocator *locator)
654-
: ConstraintFix(cs, FixKind::ContextualMismatch, locator), LHS(lhs),
655-
RHS(rhs) {}
653+
ConstraintLocator *locator, bool warning)
654+
: ConstraintFix(cs, FixKind::ContextualMismatch, locator, warning),
655+
LHS(lhs), RHS(rhs) {}
656656

657657
protected:
658658
ContextualMismatch(ConstraintSystem &cs, FixKind kind, Type lhs, Type rhs,
@@ -741,9 +741,9 @@ class MarkExplicitlyEscaping final : public ContextualMismatch {
741741
/// Mark function type as being part of a global actor.
742742
class MarkGlobalActorFunction final : public ContextualMismatch {
743743
MarkGlobalActorFunction(ConstraintSystem &cs, Type lhs, Type rhs,
744-
ConstraintLocator *locator)
744+
ConstraintLocator *locator, bool warning)
745745
: ContextualMismatch(cs, FixKind::MarkGlobalActorFunction, lhs, rhs,
746-
locator) {
746+
locator, warning) {
747747
}
748748

749749
public:
@@ -752,7 +752,8 @@ class MarkGlobalActorFunction final : public ContextualMismatch {
752752
bool diagnose(const Solution &solution, bool asNote = false) const override;
753753

754754
static MarkGlobalActorFunction *create(ConstraintSystem &cs, Type lhs,
755-
Type rhs, ConstraintLocator *locator);
755+
Type rhs, ConstraintLocator *locator,
756+
bool warning);
756757

757758
static bool classof(ConstraintFix *fix) {
758759
return fix->getKind() == FixKind::MarkGlobalActorFunction;
@@ -787,9 +788,10 @@ class ForceOptional final : public ContextualMismatch {
787788
/// function types, repair it by adding @Sendable attribute.
788789
class AddSendableAttribute final : public ContextualMismatch {
789790
AddSendableAttribute(ConstraintSystem &cs, FunctionType *fromType,
790-
FunctionType *toType, ConstraintLocator *locator)
791+
FunctionType *toType, ConstraintLocator *locator,
792+
bool warning)
791793
: ContextualMismatch(cs, FixKind::AddSendableAttribute, fromType, toType,
792-
locator) {
794+
locator, warning) {
793795
assert(fromType->isSendable() != toType->isSendable());
794796
}
795797

@@ -801,7 +803,8 @@ class AddSendableAttribute final : public ContextualMismatch {
801803
static AddSendableAttribute *create(ConstraintSystem &cs,
802804
FunctionType *fromType,
803805
FunctionType *toType,
804-
ConstraintLocator *locator);
806+
ConstraintLocator *locator,
807+
bool warning);
805808

806809
static bool classof(ConstraintFix *fix) {
807810
return fix->getKind() == FixKind::AddSendableAttribute;

‎lib/Sema/CSDiagnostics.cpp

Lines changed: 10 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -102,7 +102,10 @@ template <typename... ArgTypes>
102102
InFlightDiagnostic
103103
FailureDiagnostic::emitDiagnosticAt(ArgTypes &&... Args) const {
104104
auto &DE = getASTContext().Diags;
105-
return DE.diagnose(std::forward<ArgTypes>(Args)...);
105+
auto behavior = isWarning ? DiagnosticBehavior::Warning
106+
: DiagnosticBehavior::Unspecified;
107+
return std::move(DE.diagnose(std::forward<ArgTypes>(Args)...)
108+
.limitBehavior(behavior));
106109
}
107110

108111
Expr *FailureDiagnostic::findParentExpr(const Expr *subExpr) const {
@@ -6779,12 +6782,9 @@ bool NonEphemeralConversionFailure::diagnosePointerInit() const {
67796782
return false;
67806783
}
67816784

6782-
auto diagID = DowngradeToWarning
6783-
? diag::cannot_construct_dangling_pointer_warning
6784-
: diag::cannot_construct_dangling_pointer;
6785-
67866785
auto anchor = getRawAnchor();
6787-
emitDiagnosticAt(::getLoc(anchor), diagID, constructedTy, constructorKind)
6786+
emitDiagnosticAt(::getLoc(anchor), diag::cannot_construct_dangling_pointer,
6787+
constructedTy, constructorKind)
67886788
.highlight(::getSourceRange(anchor));
67896789

67906790
emitSuggestionNotes();
@@ -6814,20 +6814,12 @@ bool NonEphemeralConversionFailure::diagnoseAsError() {
68146814

68156815
auto *argExpr = getArgExpr();
68166816
if (isa<InOutExpr>(argExpr)) {
6817-
auto diagID = DowngradeToWarning
6818-
? diag::cannot_use_inout_non_ephemeral_warning
6819-
: diag::cannot_use_inout_non_ephemeral;
6820-
6821-
emitDiagnosticAt(argExpr->getLoc(), diagID, argDesc, getCallee(),
6822-
getCalleeFullName())
6817+
emitDiagnosticAt(argExpr->getLoc(), diag::cannot_use_inout_non_ephemeral,
6818+
argDesc, getCallee(), getCalleeFullName())
68236819
.highlight(argExpr->getSourceRange());
68246820
} else {
6825-
auto diagID = DowngradeToWarning
6826-
? diag::cannot_pass_type_to_non_ephemeral_warning
6827-
: diag::cannot_pass_type_to_non_ephemeral;
6828-
6829-
emitDiagnosticAt(argExpr->getLoc(), diagID, getArgType(), argDesc,
6830-
getCallee(), getCalleeFullName())
6821+
emitDiagnosticAt(argExpr->getLoc(), diag::cannot_pass_type_to_non_ephemeral,
6822+
getArgType(), argDesc, getCallee(), getCalleeFullName())
68316823
.highlight(argExpr->getSourceRange());
68326824
}
68336825
emitSuggestionNotes();

‎lib/Sema/CSDiagnostics.h

Lines changed: 26 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -42,13 +42,17 @@ class FunctionArgApplyInfo;
4242
class FailureDiagnostic {
4343
const Solution &S;
4444
ConstraintLocator *Locator;
45+
bool isWarning;
4546

4647
public:
47-
FailureDiagnostic(const Solution &solution, ConstraintLocator *locator)
48-
: S(solution), Locator(locator) {}
48+
FailureDiagnostic(const Solution &solution, ConstraintLocator *locator,
49+
bool isWarning = false)
50+
: S(solution), Locator(locator), isWarning(isWarning) {}
4951

50-
FailureDiagnostic(const Solution &solution, ASTNode anchor)
51-
: FailureDiagnostic(solution, solution.getConstraintLocator(anchor)) {}
52+
FailureDiagnostic(const Solution &solution, ASTNode anchor,
53+
bool isWarning = false)
54+
: FailureDiagnostic(solution, solution.getConstraintLocator(anchor),
55+
isWarning) { }
5256

5357
virtual ~FailureDiagnostic();
5458

@@ -601,20 +605,21 @@ class ContextualFailure : public FailureDiagnostic {
601605

602606
public:
603607
ContextualFailure(const Solution &solution, Type lhs, Type rhs,
604-
ConstraintLocator *locator)
608+
ConstraintLocator *locator, bool isWarning = false)
605609
: ContextualFailure(
606610
solution,
607611
locator->isForContextualType()
608612
? locator->castLastElementTo<LocatorPathElt::ContextualType>()
609613
.getPurpose()
610614
: solution.getConstraintSystem().getContextualTypePurpose(
611615
locator->getAnchor()),
612-
lhs, rhs, locator) {}
616+
lhs, rhs, locator, isWarning) {}
613617

614618
ContextualFailure(const Solution &solution, ContextualTypePurpose purpose,
615-
Type lhs, Type rhs, ConstraintLocator *locator)
616-
: FailureDiagnostic(solution, locator), CTP(purpose), RawFromType(lhs),
617-
RawToType(rhs) {
619+
Type lhs, Type rhs, ConstraintLocator *locator,
620+
bool isWarning = false)
621+
: FailureDiagnostic(solution, locator, isWarning), CTP(purpose),
622+
RawFromType(lhs), RawToType(rhs) {
618623
assert(lhs && "Expected a valid 'from' type");
619624
assert(rhs && "Expected a valid 'to' type");
620625
}
@@ -753,8 +758,9 @@ class AttributedFuncToTypeConversionFailure final : public ContextualFailure {
753758

754759
AttributedFuncToTypeConversionFailure(const Solution &solution, Type fromType,
755760
Type toType, ConstraintLocator *locator,
756-
AttributeKind attributeKind)
757-
: ContextualFailure(solution, fromType, toType, locator),
761+
AttributeKind attributeKind,
762+
bool isWarning = false)
763+
: ContextualFailure(solution, fromType, toType, locator, isWarning),
758764
attributeKind(attributeKind) {}
759765

760766
bool diagnoseAsError() override;
@@ -777,8 +783,9 @@ class AttributedFuncToTypeConversionFailure final : public ContextualFailure {
777783
class DroppedGlobalActorFunctionAttr final : public ContextualFailure {
778784
public:
779785
DroppedGlobalActorFunctionAttr(const Solution &solution, Type fromType,
780-
Type toType, ConstraintLocator *locator)
781-
: ContextualFailure(solution, fromType, toType, locator) {}
786+
Type toType, ConstraintLocator *locator,
787+
bool isWarning)
788+
: ContextualFailure(solution, fromType, toType, locator, isWarning) { }
782789

783790
bool diagnoseAsError() override;
784791
};
@@ -1942,8 +1949,9 @@ class ArgumentMismatchFailure : public ContextualFailure {
19421949

19431950
public:
19441951
ArgumentMismatchFailure(const Solution &solution, Type argType,
1945-
Type paramType, ConstraintLocator *locator)
1946-
: ContextualFailure(solution, argType, paramType, locator),
1952+
Type paramType, ConstraintLocator *locator,
1953+
bool warning = false)
1954+
: ContextualFailure(solution, argType, paramType, locator, warning),
19471955
Info(*getFunctionArgApplyInfo(getLocator())) {}
19481956

19491957
bool diagnoseAsError() override;
@@ -2112,16 +2120,15 @@ class InvalidUseOfTrailingClosure final : public ArgumentMismatchFailure {
21122120
/// ```
21132121
class NonEphemeralConversionFailure final : public ArgumentMismatchFailure {
21142122
ConversionRestrictionKind ConversionKind;
2115-
bool DowngradeToWarning;
21162123

21172124
public:
21182125
NonEphemeralConversionFailure(const Solution &solution,
21192126
ConstraintLocator *locator, Type fromType,
21202127
Type toType,
21212128
ConversionRestrictionKind conversionKind,
2122-
bool downgradeToWarning)
2123-
: ArgumentMismatchFailure(solution, fromType, toType, locator),
2124-
ConversionKind(conversionKind), DowngradeToWarning(downgradeToWarning) {
2129+
bool warning)
2130+
: ArgumentMismatchFailure(solution, fromType, toType, locator, warning),
2131+
ConversionKind(conversionKind) {
21252132
}
21262133

21272134
bool diagnoseAsError() override;

‎lib/Sema/CSFix.cpp

Lines changed: 12 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -201,39 +201,41 @@ MarkExplicitlyEscaping::create(ConstraintSystem &cs, Type lhs, Type rhs,
201201
bool MarkGlobalActorFunction::diagnose(const Solution &solution,
202202
bool asNote) const {
203203
DroppedGlobalActorFunctionAttr failure(
204-
solution, getFromType(), getToType(), getLocator());
204+
solution, getFromType(), getToType(), getLocator(), isWarning());
205205
return failure.diagnose(asNote);
206206
}
207207

208208
MarkGlobalActorFunction *
209209
MarkGlobalActorFunction::create(ConstraintSystem &cs, Type lhs, Type rhs,
210-
ConstraintLocator *locator) {
210+
ConstraintLocator *locator, bool warning) {
211211
if (locator->isLastElement<LocatorPathElt::ApplyArgToParam>())
212212
locator = cs.getConstraintLocator(
213213
locator, LocatorPathElt::ArgumentAttribute::forGlobalActor());
214214

215-
return new (cs.getAllocator()) MarkGlobalActorFunction(cs, lhs, rhs, locator);
215+
return new (cs.getAllocator()) MarkGlobalActorFunction(
216+
cs, lhs, rhs, locator, warning);
216217
}
217218

218219
bool AddSendableAttribute::diagnose(const Solution &solution,
219220
bool asNote) const {
220221
AttributedFuncToTypeConversionFailure failure(
221222
solution, getFromType(), getToType(), getLocator(),
222-
AttributedFuncToTypeConversionFailure::Concurrent);
223+
AttributedFuncToTypeConversionFailure::Concurrent, isWarning());
223224
return failure.diagnose(asNote);
224225
}
225226

226227
AddSendableAttribute *
227228
AddSendableAttribute::create(ConstraintSystem &cs,
228-
FunctionType *fromType,
229-
FunctionType *toType,
230-
ConstraintLocator *locator) {
229+
FunctionType *fromType,
230+
FunctionType *toType,
231+
ConstraintLocator *locator,
232+
bool warning) {
231233
if (locator->isLastElement<LocatorPathElt::ApplyArgToParam>())
232234
locator = cs.getConstraintLocator(
233235
locator, LocatorPathElt::ArgumentAttribute::forConcurrent());
234236

235237
return new (cs.getAllocator()) AddSendableAttribute(
236-
cs, fromType, toType, locator);
238+
cs, fromType, toType, locator, warning);
237239
}
238240
bool RelabelArguments::diagnose(const Solution &solution, bool asNote) const {
239241
LabelingFailure failure(solution, getLocator(), getLabels());
@@ -369,7 +371,8 @@ bool ContextualMismatch::diagnoseForAmbiguity(
369371
ContextualMismatch *ContextualMismatch::create(ConstraintSystem &cs, Type lhs,
370372
Type rhs,
371373
ConstraintLocator *locator) {
372-
return new (cs.getAllocator()) ContextualMismatch(cs, lhs, rhs, locator);
374+
return new (cs.getAllocator()) ContextualMismatch(
375+
cs, lhs, rhs, locator, /*warning=*/false);
373376
}
374377

375378
bool AllowWrappedValueMismatch::diagnose(const Solution &solution, bool asError) const {

‎lib/Sema/CSSimplify.cpp

Lines changed: 21 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,7 @@
1616
//===----------------------------------------------------------------------===//
1717

1818
#include "CSDiagnostics.h"
19+
#include "TypeCheckConcurrency.h"
1920
#include "swift/AST/ASTPrinter.h"
2021
#include "swift/AST/Decl.h"
2122
#include "swift/AST/ExistentialLayout.h"
@@ -2170,6 +2171,22 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
21702171
increaseScore(SK_SyncInAsync);
21712172
}
21722173

2174+
/// Whether to downgrade to a concurrency warning.
2175+
auto isConcurrencyWarning = [&] {
2176+
if (contextUsesConcurrencyFeatures(DC) ||
2177+
Context.LangOpts.isSwiftVersionAtLeast(6))
2178+
return false;
2179+
2180+
switch (kind) {
2181+
case ConstraintKind::Conversion:
2182+
case ConstraintKind::ArgumentConversion:
2183+
return true;
2184+
2185+
default:
2186+
return false;
2187+
}
2188+
};
2189+
21732190
// A @Sendable function can be a subtype of a non-@Sendable function.
21742191
if (func1->isSendable() != func2->isSendable()) {
21752192
// Cannot add '@Sendable'.
@@ -2178,7 +2195,8 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
21782195
return getTypeMatchFailure(locator);
21792196

21802197
auto *fix = AddSendableAttribute::create(
2181-
*this, func1, func2, getConstraintLocator(locator));
2198+
*this, func1, func2, getConstraintLocator(locator),
2199+
isConcurrencyWarning());
21822200
if (recordFix(fix))
21832201
return getTypeMatchFailure(locator);
21842202
}
@@ -2212,7 +2230,8 @@ ConstraintSystem::matchFunctionTypes(FunctionType *func1, FunctionType *func2,
22122230
return getTypeMatchFailure(locator);
22132231

22142232
auto *fix = MarkGlobalActorFunction::create(
2215-
*this, func1, func2, getConstraintLocator(locator));
2233+
*this, func1, func2, getConstraintLocator(locator),
2234+
isConcurrencyWarning());
22162235

22172236
if (recordFix(fix))
22182237
return getTypeMatchFailure(locator);

‎test/Concurrency/actor_isolation.swift

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -403,7 +403,7 @@ func testGlobalActorClosures() {
403403
return 17
404404
}
405405

406-
acceptConcurrentClosure { @SomeGlobalActor in 5 } // expected-error{{converting function value of type '@SomeGlobalActor @Sendable () -> Int' to '@Sendable () -> Int' loses global actor 'SomeGlobalActor'}}
406+
acceptConcurrentClosure { @SomeGlobalActor in 5 } // expected-warning{{converting function value of type '@SomeGlobalActor @Sendable () -> Int' to '@Sendable () -> Int' loses global actor 'SomeGlobalActor'}}
407407
}
408408

409409
@available(SwiftStdlib 5.1, *)

‎test/Concurrency/global_actor_function_types.swift

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ struct OtherGlobalActor {
1616
func testConversions(f: @escaping @SomeGlobalActor (Int) -> Void, g: @escaping (Int) -> Void) {
1717
let _: Int = f // expected-error{{cannot convert value of type '@SomeGlobalActor (Int) -> Void' to specified type 'Int'}}
1818

19-
let _: (Int) -> Void = f // expected-error{{converting function value of type '@SomeGlobalActor (Int) -> Void' to '(Int) -> Void' loses global actor 'SomeGlobalActor'}}
19+
let _: (Int) -> Void = f // expected-warning{{converting function value of type '@SomeGlobalActor (Int) -> Void' to '(Int) -> Void' loses global actor 'SomeGlobalActor'}}
2020
let _: @SomeGlobalActor (Int) -> Void = g // okay
2121

2222
// FIXME: this could be better.
@@ -119,7 +119,7 @@ func testTypesNonConcurrencyContext() { // expected-note{{add '@SomeGlobalActor'
119119
let f1 = onSomeGlobalActor // expected-note{{calls to let 'f1' from outside of its actor context are implicitly asynchronous}}
120120
let f2 = onSomeGlobalActorUnsafe
121121

122-
let _: () -> Int = f1 // expected-error{{converting function value of type '@SomeGlobalActor () -> Int' to '() -> Int' loses global actor 'SomeGlobalActor'}}
122+
let _: () -> Int = f1 // expected-warning{{converting function value of type '@SomeGlobalActor () -> Int' to '() -> Int' loses global actor 'SomeGlobalActor'}}
123123
let _: () -> Int = f2
124124

125125
_ = f1() // expected-error{{call to global actor 'SomeGlobalActor'-isolated let 'f1' in a synchronous nonisolated context}}

0 commit comments

Comments
 (0)