Skip to content

Commit cad0722

Browse files
rudkxrudkx
committed
Remove unused argument to type matcher.
1 parent 6f25962 commit cad0722

File tree

6 files changed

+43
-62
lines changed

6 files changed

+43
-62
lines changed

‎include/swift/AST/Types.h

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -763,7 +763,7 @@ class alignas(1 << TypeAlignInBits) TypeBase {
763763

764764
/// \brief Determines whether this type is similar to \p other as defined by
765765
/// \p matchOptions.
766-
bool matches(Type other, TypeMatchOptions matchOptions, LazyResolver *resolver);
766+
bool matches(Type other, TypeMatchOptions matchOptions);
767767

768768
/// \brief Determines whether this type has a retainable pointer
769769
/// representation, i.e. whether it is representable as a single,

‎lib/AST/Decl.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -4936,8 +4936,7 @@ static bool requiresNewVTableEntry(const AbstractFunctionDecl *decl) {
49364936
base, decl, baseInterfaceTy);
49374937

49384938
return !derivedInterfaceTy->matches(overrideInterfaceTy,
4939-
TypeMatchFlags::AllowABICompatible,
4940-
/*resolver*/nullptr);
4939+
TypeMatchFlags::AllowABICompatible);
49414940
}
49424941

49434942
void AbstractFunctionDecl::computeNeedsNewVTableEntry() {

‎lib/AST/Type.cpp

Lines changed: 10 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -2180,8 +2180,7 @@ namespace {
21802180

21812181
static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
21822182
ParameterPosition paramPosition,
2183-
OptionalUnwrapping insideOptional,
2184-
LazyResolver *resolver) {
2183+
OptionalUnwrapping insideOptional) {
21852184
if (t1 == t2) return true;
21862185

21872186
// First try unwrapping optionals.
@@ -2193,7 +2192,7 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
21932192
if (auto obj1 = t1.getAnyOptionalObjectType()) {
21942193
// Allow T? and T! to freely match one another.
21952194
return matches(obj1, obj2, matchMode, ParameterPosition::NotParameter,
2196-
OptionalUnwrapping::OptionalToOptional, resolver);
2195+
OptionalUnwrapping::OptionalToOptional);
21972196
}
21982197

21992198
// Value-to-optional.
@@ -2204,15 +2203,15 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
22042203
if (matchMode.contains(TypeMatchFlags::AllowOverride) ||
22052204
matchMode.contains(TypeMatchFlags::AllowTopLevelOptionalMismatch)) {
22062205
return matches(t1, obj2, matchMode, ParameterPosition::NotParameter,
2207-
OptionalUnwrapping::ValueToOptional, resolver);
2206+
OptionalUnwrapping::ValueToOptional);
22082207
}
22092208

22102209
} else if (matchMode.contains(
22112210
TypeMatchFlags::AllowTopLevelOptionalMismatch)) {
22122211
// Optional-to-value, normally disallowed.
22132212
if (auto obj1 = t1.getAnyOptionalObjectType()) {
22142213
return matches(obj1, t2, matchMode, ParameterPosition::NotParameter,
2215-
OptionalUnwrapping::OptionalToValue, resolver);
2214+
OptionalUnwrapping::OptionalToValue);
22162215
}
22172216
}
22182217
}
@@ -2236,15 +2235,14 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
22362235
if (!tuple1 || tuple1->getNumElements() != tuple2->getNumElements()) {
22372236
if (tuple2->getNumElements() == 1) {
22382237
return matches(t1, tuple2.getElementType(0), matchMode, elementPosition,
2239-
OptionalUnwrapping::None, resolver);
2238+
OptionalUnwrapping::None);
22402239
}
22412240
return false;
22422241
}
22432242

22442243
for (auto i : indices(tuple1.getElementTypes())) {
22452244
if (!matches(tuple1.getElementType(i), tuple2.getElementType(i),
2246-
matchMode, elementPosition, OptionalUnwrapping::None,
2247-
resolver)){
2245+
matchMode, elementPosition, OptionalUnwrapping::None)) {
22482246
return false;
22492247
}
22502248
}
@@ -2287,11 +2285,9 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
22872285

22882286
// Inputs are contravariant, results are covariant.
22892287
return (matches(fn2.getInput(), fn1.getInput(), matchMode,
2290-
ParameterPosition::Parameter, OptionalUnwrapping::None,
2291-
resolver) &&
2288+
ParameterPosition::Parameter, OptionalUnwrapping::None) &&
22922289
matches(fn1.getResult(), fn2.getResult(), matchMode,
2293-
ParameterPosition::NotParameter, OptionalUnwrapping::None,
2294-
resolver));
2290+
ParameterPosition::NotParameter, OptionalUnwrapping::None));
22952291
}
22962292

22972293
if (matchMode.contains(TypeMatchFlags::AllowNonOptionalForIUOParam) &&
@@ -2317,11 +2313,9 @@ static bool matches(CanType t1, CanType t2, TypeMatchOptions matchMode,
23172313
return false;
23182314
}
23192315

2320-
bool TypeBase::matches(Type other, TypeMatchOptions matchMode,
2321-
LazyResolver *resolver) {
2316+
bool TypeBase::matches(Type other, TypeMatchOptions matchMode) {
23222317
return ::matches(getCanonicalType(), other->getCanonicalType(), matchMode,
2323-
ParameterPosition::NotParameter, OptionalUnwrapping::None,
2324-
resolver);
2318+
ParameterPosition::NotParameter, OptionalUnwrapping::None);
23252319
}
23262320

23272321
/// getNamedElementId - If this tuple has a field with the specified name,

‎lib/SIL/SILFunctionType.cpp

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2137,8 +2137,7 @@ SILParameterInfo TypeConverter::getConstantSelfParameter(SILDeclRef constant) {
21372137
// @guaranteed or whatever.
21382138
static bool checkASTTypeForABIDifferences(CanType type1,
21392139
CanType type2) {
2140-
return !type1->matches(type2, TypeMatchFlags::AllowABICompatible,
2141-
/*resolver*/nullptr);
2140+
return !type1->matches(type2, TypeMatchFlags::AllowABICompatible);
21422141
}
21432142

21442143
// FIXME: This makes me very upset. Can we do without this?

‎lib/Sema/TypeCheckDecl.cpp

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -6139,7 +6139,7 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
61396139
TypeMatchFlags::IgnoreNonEscapingForOptionalFunctionParam;
61406140
}
61416141

6142-
if (declTy->matches(parentDeclTy, matchMode, &TC)) {
6142+
if (declTy->matches(parentDeclTy, matchMode)) {
61436143
// If the Objective-C selectors match, always call it exact.
61446144
matches.push_back({parentDecl, objCMatch, parentDeclTy});
61456145
hadExactMatch |= objCMatch;
@@ -6373,10 +6373,9 @@ class DeclChecker : public DeclVisitor<DeclChecker> {
63736373
auto propertyTy = property->getInterfaceType();
63746374
auto parentPropertyTy = superclass->adjustSuperclassMemberDeclType(
63756375
matchDecl, decl, matchDecl->getInterfaceType());
6376-
6376+
63776377
if (!propertyTy->matches(parentPropertyTy,
6378-
TypeMatchFlags::AllowOverride,
6379-
&TC)) {
6378+
TypeMatchFlags::AllowOverride)) {
63806379
TC.diagnose(property, diag::override_property_type_mismatch,
63816380
property->getName(), propertyTy, parentPropertyTy);
63826381
noteFixableMismatchedTypes(TC, decl, matchDecl);

‎unittests/AST/TypeMatchTests.cpp

Lines changed: 27 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -23,8 +23,8 @@ TEST(TypeMatch, IdenticalTypes) {
2323
TestContext C;
2424

2525
auto check = [](Type ty) {
26-
return ty->matches(ty, TypeMatchOptions(), /*resolver*/nullptr) &&
27-
ty->matches(ty, TypeMatchFlags::AllowOverride, /*resolver*/nullptr);
26+
return ty->matches(ty, TypeMatchOptions()) &&
27+
ty->matches(ty, TypeMatchFlags::AllowOverride);
2828
};
2929

3030
EXPECT_TRUE(check(C.Ctx.TheEmptyTupleType));
@@ -50,9 +50,8 @@ TEST(TypeMatch, UnrelatedTypes) {
5050
TestContext C;
5151

5252
auto check = [](Type base, Type derived) {
53-
return derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr) &&
54-
derived->matches(base, TypeMatchFlags::AllowOverride,
55-
/*resolver*/nullptr);
53+
return derived->matches(base, TypeMatchOptions()) &&
54+
derived->matches(base, TypeMatchFlags::AllowOverride);
5655
};
5756

5857
EXPECT_FALSE(check(C.Ctx.TheEmptyTupleType, C.Ctx.TheRawPointerType));
@@ -102,9 +101,8 @@ TEST(TypeMatch, Classes) {
102101
TestContext C;
103102

104103
auto check = [](Type base, Type derived) {
105-
return derived->matches(base, TypeMatchFlags::AllowOverride,
106-
/*resolver*/nullptr) &&
107-
!derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr);
104+
return derived->matches(base, TypeMatchFlags::AllowOverride) &&
105+
!derived->matches(base, TypeMatchOptions());
108106
};
109107

110108
auto *baseClass = C.makeNominal<ClassDecl>("Base");
@@ -144,9 +142,8 @@ TEST(TypeMatch, Optionals) {
144142
TestContext C{DeclareOptionalTypes};
145143

146144
auto check = [](Type base, Type derived) {
147-
return derived->matches(base, TypeMatchFlags::AllowOverride,
148-
/*resolver*/nullptr) &&
149-
!derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr);
145+
return derived->matches(base, TypeMatchFlags::AllowOverride) &&
146+
!derived->matches(base, TypeMatchOptions());
150147
};
151148

152149
auto *baseClass = C.makeNominal<ClassDecl>("Base");
@@ -176,18 +173,16 @@ TEST(TypeMatch, IUONearMatch) {
176173
TestContext C{DeclareOptionalTypes};
177174

178175
auto check = [](Type base, Type derived) {
179-
return derived->matches(base, TypeMatchFlags::AllowOverride,
180-
/*resolver*/nullptr) &&
181-
!derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr);
176+
return derived->matches(base, TypeMatchFlags::AllowOverride) &&
177+
!derived->matches(base, TypeMatchOptions());
182178
};
183179
auto checkIUO = [](Type base, Type derived) {
184-
return derived->matches(base, TypeMatchFlags::AllowNonOptionalForIUOParam,
185-
/*resolver*/nullptr);
180+
return derived->matches(base, TypeMatchFlags::AllowNonOptionalForIUOParam);
186181
};
187182
auto checkIUOOverride = [](Type base, Type derived) {
188183
TypeMatchOptions matchMode = TypeMatchFlags::AllowOverride;
189184
matchMode |= TypeMatchFlags::AllowNonOptionalForIUOParam;
190-
return derived->matches(base, matchMode, /*resolver*/nullptr);
185+
return derived->matches(base, matchMode);
191186
};
192187

193188
auto *baseClass = C.makeNominal<ClassDecl>("Base");
@@ -253,18 +248,17 @@ TEST(TypeMatch, OptionalMismatch) {
253248
TestContext C{DeclareOptionalTypes};
254249

255250
auto check = [](Type base, Type derived) {
256-
return derived->matches(base, TypeMatchFlags::AllowOverride,
257-
/*resolver*/nullptr) &&
258-
!derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr);
251+
return derived->matches(base, TypeMatchFlags::AllowOverride) &&
252+
!derived->matches(base, TypeMatchOptions());
259253
};
260254
auto checkOpt = [](Type base, Type derived) {
261-
return derived->matches(base, TypeMatchFlags::AllowTopLevelOptionalMismatch,
262-
/*resolver*/nullptr);
255+
return derived->matches(base,
256+
TypeMatchFlags::AllowTopLevelOptionalMismatch);
263257
};
264258
auto checkOptOverride = [](Type base, Type derived) {
265259
TypeMatchOptions matchMode = TypeMatchFlags::AllowOverride;
266260
matchMode |= TypeMatchFlags::AllowTopLevelOptionalMismatch;
267-
return derived->matches(base, matchMode, /*resolver*/nullptr);
261+
return derived->matches(base, matchMode);
268262
};
269263

270264
auto *baseClass = C.makeNominal<ClassDecl>("Base");
@@ -328,9 +322,8 @@ TEST(TypeMatch, OptionalMismatchTuples) {
328322
TestContext C{DeclareOptionalTypes};
329323

330324
auto checkOverride = [](Type base, Type derived) {
331-
return derived->matches(base, TypeMatchFlags::AllowOverride,
332-
/*resolver*/nullptr) &&
333-
!derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr);
325+
return derived->matches(base, TypeMatchFlags::AllowOverride) &&
326+
!derived->matches(base, TypeMatchOptions());
334327
};
335328

336329
auto *baseClass = C.makeNominal<ClassDecl>("Base");
@@ -359,8 +352,8 @@ TEST(TypeMatch, OptionalMismatchTuples) {
359352
EXPECT_FALSE(checkOverride(optBaseTuple, baseOptTuple));
360353

361354
auto checkOpt = [](Type base, Type derived) {
362-
return derived->matches(base, TypeMatchFlags::AllowTopLevelOptionalMismatch,
363-
/*resolver*/nullptr);
355+
return derived->matches(base,
356+
TypeMatchFlags::AllowTopLevelOptionalMismatch);
364357
};
365358

366359
EXPECT_TRUE(checkOpt(baseBaseTuple, optOptTuple));
@@ -390,13 +383,12 @@ TEST(TypeMatch, OptionalMismatchFunctions) {
390383
TestContext C{DeclareOptionalTypes};
391384

392385
auto checkOverride = [](Type base, Type derived) {
393-
return derived->matches(base, TypeMatchFlags::AllowOverride,
394-
/*resolver*/nullptr) &&
395-
!derived->matches(base, TypeMatchOptions(), /*resolver*/nullptr);
386+
return derived->matches(base, TypeMatchFlags::AllowOverride) &&
387+
!derived->matches(base, TypeMatchOptions());
396388
};
397389
auto checkOpt = [](Type base, Type derived) {
398-
return derived->matches(base, TypeMatchFlags::AllowTopLevelOptionalMismatch,
399-
/*resolver*/nullptr);
390+
return derived->matches(base,
391+
TypeMatchFlags::AllowTopLevelOptionalMismatch);
400392
};
401393

402394
Type voidToVoid = FunctionType::get(C.Ctx.TheEmptyTupleType,
@@ -414,14 +406,12 @@ TEST(TypeMatch, NoEscapeMismatchFunctions) {
414406
// Note the reversed names here: parameters must be contravariant for the
415407
// functions that take them to be covariant.
416408
auto checkOverride = [](Type paramOfDerived, Type paramOfBase) {
417-
return paramOfBase->matches(paramOfDerived, TypeMatchFlags::AllowOverride,
418-
/*resolver*/nullptr);
409+
return paramOfBase->matches(paramOfDerived, TypeMatchFlags::AllowOverride);
419410
};
420411
auto checkMismatch = [](Type paramOfDerived, Type paramOfBase) {
421412
return paramOfBase->matches(
422413
paramOfDerived,
423-
TypeMatchFlags::IgnoreNonEscapingForOptionalFunctionParam,
424-
/*resolver*/nullptr);
414+
TypeMatchFlags::IgnoreNonEscapingForOptionalFunctionParam);
425415
};
426416

427417
Type voidToVoidFn = FunctionType::get(C.Ctx.TheEmptyTupleType,

0 commit comments

Comments
 (0)