Skip to content

[TypeResolution] Remove unnecessary parameter pack special case from function type resolution. #63256

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 2 commits into from
Jan 27, 2023
Merged

[TypeResolution] Remove unnecessary parameter pack special case from function type resolution. #63256

Changes from all commits
Commits
Show all changes
2 commits
Select commit Hold shift + click to select a range
2eb96d0
[TypeResolution] Remove unnecessary parameter pack special case from …
hborla Jan 27, 2023
5d20f03
[TypeResolution] Fold maybeResolvePackExpansionType into resolvePackE…
hborla Jan 27, 2023
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
71 changes: 19 additions & 52 deletions lib/Sema/TypeCheckType.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2030,9 +2030,6 @@ namespace {
NeverNullType resolveImplicitlyUnwrappedOptionalType(
ImplicitlyUnwrappedOptionalTypeRepr *repr,
TypeResolutionOptions options, bool isDirect);
std::pair<Type, Type>
maybeResolvePackExpansionType(PackExpansionTypeRepr *repr,
TypeResolutionOptions options);
NeverNullType resolveVarargType(VarargTypeRepr *repr,
TypeResolutionOptions options);
NeverNullType resolvePackType(PackTypeRepr *repr,
Expand Down Expand Up @@ -3158,20 +3155,7 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
// Do we have an old-style variadic parameter?
bool variadic = false;

if (auto *packExpansionTypeRepr = dyn_cast<PackExpansionTypeRepr>(nestedRepr)) {
auto patternOptions = elementOptions;
patternOptions.setContext(TypeResolverContext::VariadicFunctionInput);

auto pair = maybeResolvePackExpansionType(packExpansionTypeRepr,
patternOptions);
if (pair.first->hasError()) {
elements.emplace_back(ErrorType::get(getASTContext()));
continue;
}

// We have a pack expansion type.
ty = PackExpansionType::get(pair.first, pair.second);
} else if (auto *varargTypeRepr = dyn_cast<VarargTypeRepr>(nestedRepr)) {
if (auto *varargTypeRepr = dyn_cast<VarargTypeRepr>(nestedRepr)) {
if (ellipsisLoc) {
diagnose(varargTypeRepr->getLoc(),
diag::multiple_ellipsis_in_tuple)
Expand Down Expand Up @@ -4194,25 +4178,6 @@ NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
return uncheckedOptionalTy;
}

std::pair<Type, Type>
TypeResolver::maybeResolvePackExpansionType(PackExpansionTypeRepr *repr,
TypeResolutionOptions options) {
auto elementOptions = options;
elementOptions |= TypeResolutionFlags::AllowPackReferences;
auto patternTy = resolveType(repr->getPatternType(), elementOptions);
if (patternTy->hasError())
return std::make_pair(ErrorType::get(getASTContext()), Type());

// Find the first type parameter pack and use that as the count type.
SmallVector<Type, 1> rootParameterPacks;
patternTy->getTypeParameterPacks(rootParameterPacks);

if (rootParameterPacks.empty())
return std::make_pair(patternTy, Type());

return std::make_pair(patternTy, rootParameterPacks[0]);
}

NeverNullType TypeResolver::resolveVarargType(VarargTypeRepr *repr,
TypeResolutionOptions options) {
auto element = resolveType(repr->getElementType(), options);
Expand Down Expand Up @@ -4257,32 +4222,34 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
TypeResolutionOptions options) {
auto &ctx = getASTContext();

auto pair = maybeResolvePackExpansionType(repr, options);

if (pair.first->hasError())
auto elementOptions = options;
elementOptions |= TypeResolutionFlags::AllowPackReferences;
auto patternType = resolveType(repr->getPatternType(), elementOptions);
if (patternType->hasError())
return ErrorType::get(ctx);

// We might not allow variadic expansions here at all.
if (!options.isPackExpansionSupported(getDeclContext())) {
diagnose(repr->getLoc(), diag::expansion_not_allowed, pair.first);
return ErrorType::get(ctx);
}
// Find the first type parameter pack and use that as the count type.
SmallVector<Type, 2> rootParameterPacks;
patternType->getTypeParameterPacks(rootParameterPacks);

if (!pair.second) {
if (rootParameterPacks.empty()) {
// The pattern type must contain at least one pack reference.
diagnose(repr->getLoc(), diag::expansion_not_variadic, pair.first)
diagnose(repr->getLoc(), diag::expansion_not_variadic, patternType)
.highlight(repr->getSourceRange());
return ErrorType::get(ctx);
}

// We might not allow variadic expansions here at all.
if (!options.isPackExpansionSupported(getDeclContext())) {
diagnose(repr->getLoc(), diag::expansion_not_allowed, patternType);
return ErrorType::get(ctx);
}

if (resolution.getStage() == TypeResolutionStage::Interface) {
auto genericSig = resolution.getGenericSignature();
auto shapeType = genericSig->getReducedShape(pair.second);

auto result = PackExpansionType::get(pair.first, shapeType);
auto shapeType = genericSig->getReducedShape(rootParameterPacks[0]);
auto result = PackExpansionType::get(patternType, shapeType);

SmallVector<Type, 2> rootParameterPacks;
pair.first->getTypeParameterPacks(rootParameterPacks);
for (auto type : rootParameterPacks) {
if (!genericSig->haveSameShape(type, shapeType)) {
ctx.Diags.diagnose(repr->getLoc(), diag::expansion_not_same_shape,
Expand All @@ -4292,7 +4259,7 @@ NeverNullType TypeResolver::resolvePackExpansionType(PackExpansionTypeRepr *repr
return result;
}

return PackExpansionType::get(pair.first, pair.second);
return PackExpansionType::get(patternType, rootParameterPacks[0]);
}

NeverNullType TypeResolver::resolvePackReference(PackReferenceTypeRepr *repr,
Expand Down