Skip to content

Commit f9c2ad6

Browse files
CodaFiCodaFi
authored
Merge pull request swiftlang#34710 from CodaFi/never-never-land
Push NeverNullType Into The Leaves of Type Resolution
2 parents 273ef12 + 4a8fdb8 commit f9c2ad6

File tree

1 file changed

+98
-94
lines changed

1 file changed

+98
-94
lines changed

‎lib/Sema/TypeCheckType.cpp

Lines changed: 98 additions & 94 deletions
Original file line numberDiff line numberDiff line change
@@ -1706,11 +1706,14 @@ namespace {
17061706
public:
17071707
/// Construct a never-null Type. If \p Ty is null, a fatal error is thrown.
17081708
NeverNullType(Type Ty) : WrappedTy(Ty) {
1709-
if (Ty.isNull()) {
1709+
if (WrappedTy.isNull()) {
17101710
llvm::report_fatal_error("Resolved to null type!");
17111711
}
17121712
}
17131713

1714+
/// Construct a never-null Type. If \p TyB is null, a fatal error is thrown.
1715+
NeverNullType(TypeBase *TyB) : NeverNullType(Type(TyB)) {}
1716+
17141717
operator Type() const { return WrappedTy; }
17151718
Type get() const { return WrappedTy; }
17161719

@@ -1755,24 +1758,24 @@ namespace {
17551758
return diags.diagnose(std::forward<ArgTypes>(Args)...);
17561759
}
17571760

1758-
Type resolveAttributedType(AttributedTypeRepr *repr,
1759-
TypeResolutionOptions options);
1760-
Type resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
1761-
TypeResolutionOptions options);
1762-
Type resolveASTFunctionType(FunctionTypeRepr *repr,
1763-
TypeResolutionOptions options,
1764-
AnyFunctionType::Representation representation
1765-
= AnyFunctionType::Representation::Swift,
1766-
bool noescape = false,
1767-
const clang::Type *parsedClangFunctionType
1768-
= nullptr,
1769-
DifferentiabilityKind diffKind
1770-
= DifferentiabilityKind::NonDifferentiable);
1761+
NeverNullType resolveAttributedType(AttributedTypeRepr *repr,
1762+
TypeResolutionOptions options);
1763+
NeverNullType resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
1764+
TypeResolutionOptions options);
1765+
NeverNullType
1766+
resolveASTFunctionType(FunctionTypeRepr *repr,
1767+
TypeResolutionOptions options,
1768+
AnyFunctionType::Representation representation =
1769+
AnyFunctionType::Representation::Swift,
1770+
bool noescape = false,
1771+
const clang::Type *parsedClangFunctionType = nullptr,
1772+
DifferentiabilityKind diffKind =
1773+
DifferentiabilityKind::NonDifferentiable);
17711774
SmallVector<AnyFunctionType::Param, 8> resolveASTFunctionTypeParams(
17721775
TupleTypeRepr *inputRepr, TypeResolutionOptions options,
17731776
bool requiresMappingOut, DifferentiabilityKind diffKind);
17741777

1775-
Type resolveSILFunctionType(
1778+
NeverNullType resolveSILFunctionType(
17761779
FunctionTypeRepr *repr, TypeResolutionOptions options,
17771780
SILCoroutineKind coroutineKind = SILCoroutineKind::None,
17781781
SILFunctionType::ExtInfoBuilder extInfoBuilder =
@@ -1791,40 +1794,40 @@ namespace {
17911794
SmallVectorImpl<SILYieldInfo> &yields,
17921795
SmallVectorImpl<SILResultInfo> &results,
17931796
Optional<SILResultInfo> &errorResult);
1794-
Type resolveIdentifierType(IdentTypeRepr *IdType,
1795-
TypeResolutionOptions options);
1796-
Type resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
1797-
TypeResolutionOptions options);
1798-
Type resolveArrayType(ArrayTypeRepr *repr,
1799-
TypeResolutionOptions options);
1800-
Type resolveDictionaryType(DictionaryTypeRepr *repr,
1801-
TypeResolutionOptions options);
1802-
Type resolveOptionalType(OptionalTypeRepr *repr,
1803-
TypeResolutionOptions options);
1804-
Type resolveImplicitlyUnwrappedOptionalType(ImplicitlyUnwrappedOptionalTypeRepr *repr,
1805-
TypeResolutionOptions options,
1806-
bool isDirect);
1807-
Type resolveTupleType(TupleTypeRepr *repr,
1808-
TypeResolutionOptions options);
1809-
Type resolveCompositionType(CompositionTypeRepr *repr,
1810-
TypeResolutionOptions options);
1811-
Type resolveMetatypeType(MetatypeTypeRepr *repr,
1812-
TypeResolutionOptions options);
1813-
Type resolveProtocolType(ProtocolTypeRepr *repr,
1814-
TypeResolutionOptions options);
1815-
Type resolveSILBoxType(SILBoxTypeRepr *repr,
1816-
TypeResolutionOptions options);
1817-
1818-
Type buildMetatypeType(MetatypeTypeRepr *repr,
1819-
Type instanceType,
1820-
Optional<MetatypeRepresentation> storedRepr);
1821-
Type buildProtocolType(ProtocolTypeRepr *repr,
1822-
Type instanceType,
1823-
Optional<MetatypeRepresentation> storedRepr);
1824-
1825-
Type resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
1826-
unsigned ordinal,
1827-
TypeResolutionOptions options);
1797+
NeverNullType resolveIdentifierType(IdentTypeRepr *IdType,
1798+
TypeResolutionOptions options);
1799+
NeverNullType resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
1800+
TypeResolutionOptions options);
1801+
NeverNullType resolveArrayType(ArrayTypeRepr *repr,
1802+
TypeResolutionOptions options);
1803+
NeverNullType resolveDictionaryType(DictionaryTypeRepr *repr,
1804+
TypeResolutionOptions options);
1805+
NeverNullType resolveOptionalType(OptionalTypeRepr *repr,
1806+
TypeResolutionOptions options);
1807+
NeverNullType resolveImplicitlyUnwrappedOptionalType(
1808+
ImplicitlyUnwrappedOptionalTypeRepr *repr,
1809+
TypeResolutionOptions options, bool isDirect);
1810+
NeverNullType resolveTupleType(TupleTypeRepr *repr,
1811+
TypeResolutionOptions options);
1812+
NeverNullType resolveCompositionType(CompositionTypeRepr *repr,
1813+
TypeResolutionOptions options);
1814+
NeverNullType resolveMetatypeType(MetatypeTypeRepr *repr,
1815+
TypeResolutionOptions options);
1816+
NeverNullType resolveProtocolType(ProtocolTypeRepr *repr,
1817+
TypeResolutionOptions options);
1818+
NeverNullType resolveSILBoxType(SILBoxTypeRepr *repr,
1819+
TypeResolutionOptions options);
1820+
1821+
NeverNullType
1822+
buildMetatypeType(MetatypeTypeRepr *repr, Type instanceType,
1823+
Optional<MetatypeRepresentation> storedRepr);
1824+
NeverNullType
1825+
buildProtocolType(ProtocolTypeRepr *repr, Type instanceType,
1826+
Optional<MetatypeRepresentation> storedRepr);
1827+
1828+
NeverNullType resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
1829+
unsigned ordinal,
1830+
TypeResolutionOptions options);
18281831

18291832
/// Returns true if the given type conforms to `Differentiable` in the
18301833
/// module of `DC`. If `tangentVectorEqualsSelf` is true, returns true iff
@@ -1920,7 +1923,7 @@ NeverNullType TypeResolver::resolveType(TypeRepr *repr,
19201923
// Default non-escaping for closure parameters
19211924
auto result =
19221925
resolveASTFunctionType(cast<FunctionTypeRepr>(repr), options);
1923-
if (result && result->is<FunctionType>())
1926+
if (result->is<FunctionType>())
19241927
return applyNonEscapingIfNecessary(result, options);
19251928
return result;
19261929
}
@@ -1992,18 +1995,19 @@ static Type rebuildWithDynamicSelf(ASTContext &Context, Type ty) {
19921995
}
19931996
}
19941997

1995-
Type TypeResolver::resolveAttributedType(AttributedTypeRepr *repr,
1996-
TypeResolutionOptions options) {
1998+
NeverNullType
1999+
TypeResolver::resolveAttributedType(AttributedTypeRepr *repr,
2000+
TypeResolutionOptions options) {
19972001
// Copy the attributes, since we're about to start hacking on them.
19982002
TypeAttributes attrs = repr->getAttrs();
19992003
assert(!attrs.empty());
20002004

20012005
return resolveAttributedType(attrs, repr->getTypeRepr(), options);
20022006
}
20032007

2004-
Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
2005-
TypeRepr *repr,
2006-
TypeResolutionOptions options) {
2008+
NeverNullType
2009+
TypeResolver::resolveAttributedType(TypeAttributes &attrs, TypeRepr *repr,
2010+
TypeResolutionOptions options) {
20072011
// Convenience to grab the source range of a type attribute.
20082012
auto getTypeAttrRangeWithAt = [](ASTContext &ctx, SourceLoc attrLoc) {
20092013
return SourceRange(attrLoc, attrLoc.getAdvancedLoc(1));
@@ -2627,10 +2631,10 @@ TypeResolver::resolveASTFunctionTypeParams(TupleTypeRepr *inputRepr,
26272631
return elements;
26282632
}
26292633

2630-
Type TypeResolver::resolveOpaqueReturnType(TypeRepr *repr,
2631-
StringRef mangledName,
2632-
unsigned ordinal,
2633-
TypeResolutionOptions options) {
2634+
NeverNullType
2635+
TypeResolver::resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
2636+
unsigned ordinal,
2637+
TypeResolutionOptions options) {
26342638
// The type repr should be a generic identifier type. We don't really use
26352639
// the identifier for anything, but we do resolve the generic arguments
26362640
// to instantiate the possibly-generic opaque type.
@@ -2669,7 +2673,7 @@ Type TypeResolver::resolveOpaqueReturnType(TypeRepr *repr,
26692673
return ty;
26702674
}
26712675

2672-
Type TypeResolver::resolveASTFunctionType(
2676+
NeverNullType TypeResolver::resolveASTFunctionType(
26732677
FunctionTypeRepr *repr, TypeResolutionOptions parentOptions,
26742678
AnyFunctionType::Representation representation, bool noescape,
26752679
const clang::Type *parsedClangFunctionType,
@@ -2804,8 +2808,8 @@ bool TypeResolver::isDifferentiable(Type type, bool tangentVectorEqualsSelf) {
28042808
return type->getCanonicalType() == tanSpace->getCanonicalType();
28052809
}
28062810

2807-
Type TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
2808-
TypeResolutionOptions options) {
2811+
NeverNullType TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
2812+
TypeResolutionOptions options) {
28092813
// Resolve the field types.
28102814
SmallVector<SILField, 4> fields;
28112815
{
@@ -2869,7 +2873,7 @@ Type TypeResolver::resolveSILBoxType(SILBoxTypeRepr *repr,
28692873
return SILBoxType::get(getASTContext(), layout, subMap);
28702874
}
28712875

2872-
Type TypeResolver::resolveSILFunctionType(
2876+
NeverNullType TypeResolver::resolveSILFunctionType(
28732877
FunctionTypeRepr *repr, TypeResolutionOptions options,
28742878
SILCoroutineKind coroutineKind,
28752879
SILFunctionType::ExtInfoBuilder extInfoBuilder, ParameterConvention callee,
@@ -3284,8 +3288,9 @@ bool TypeResolver::resolveSILResults(TypeRepr *repr,
32843288
yields, ordinaryResults, errorResult);
32853289
}
32863290

3287-
Type TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
3288-
TypeResolutionOptions options) {
3291+
NeverNullType
3292+
TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
3293+
TypeResolutionOptions options) {
32893294
auto ComponentRange = IdType->getComponentRange();
32903295
auto Components = llvm::makeArrayRef(ComponentRange.begin(),
32913296
ComponentRange.end());
@@ -3319,8 +3324,9 @@ Type TypeResolver::resolveIdentifierType(IdentTypeRepr *IdType,
33193324
return result;
33203325
}
33213326

3322-
Type TypeResolver::resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
3323-
TypeResolutionOptions options) {
3327+
NeverNullType
3328+
TypeResolver::resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
3329+
TypeResolutionOptions options) {
33243330
// inout is only valid for (non-Subscript and non-EnumCaseDecl)
33253331
// function parameters.
33263332
if (!options.is(TypeResolverContext::FunctionInput) ||
@@ -3361,9 +3367,8 @@ Type TypeResolver::resolveSpecifierTypeRepr(SpecifierTypeRepr *repr,
33613367
return resolveType(repr->getBase(), options);
33623368
}
33633369

3364-
3365-
Type TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
3366-
TypeResolutionOptions options) {
3370+
NeverNullType TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
3371+
TypeResolutionOptions options) {
33673372
auto baseTy = resolveType(repr->getBase(), options.withoutContext());
33683373
if (baseTy->hasError()) {
33693374
return ErrorType::get(getASTContext());
@@ -3377,8 +3382,9 @@ Type TypeResolver::resolveArrayType(ArrayTypeRepr *repr,
33773382
return sliceTy;
33783383
}
33793384

3380-
Type TypeResolver::resolveDictionaryType(DictionaryTypeRepr *repr,
3381-
TypeResolutionOptions options) {
3385+
NeverNullType
3386+
TypeResolver::resolveDictionaryType(DictionaryTypeRepr *repr,
3387+
TypeResolutionOptions options) {
33823388
options = adjustOptionsForGenericArgs(options);
33833389

33843390
auto keyTy = resolveType(repr->getKey(), options.withoutContext());
@@ -3407,8 +3413,8 @@ Type TypeResolver::resolveDictionaryType(DictionaryTypeRepr *repr,
34073413
return DictionaryType::get(keyTy, valueTy);
34083414
}
34093415

3410-
Type TypeResolver::resolveOptionalType(OptionalTypeRepr *repr,
3411-
TypeResolutionOptions options) {
3416+
NeverNullType TypeResolver::resolveOptionalType(OptionalTypeRepr *repr,
3417+
TypeResolutionOptions options) {
34123418
TypeResolutionOptions elementOptions = options.withoutContext(true);
34133419
elementOptions.setContext(TypeResolverContext::ImmediateOptionalTypeArgument);
34143420

@@ -3426,10 +3432,9 @@ Type TypeResolver::resolveOptionalType(OptionalTypeRepr *repr,
34263432
return optionalTy;
34273433
}
34283434

3429-
Type TypeResolver::resolveImplicitlyUnwrappedOptionalType(
3430-
ImplicitlyUnwrappedOptionalTypeRepr *repr,
3431-
TypeResolutionOptions options,
3432-
bool isDirect) {
3435+
NeverNullType TypeResolver::resolveImplicitlyUnwrappedOptionalType(
3436+
ImplicitlyUnwrappedOptionalTypeRepr *repr, TypeResolutionOptions options,
3437+
bool isDirect) {
34333438
TypeResolutionFlags allowIUO = TypeResolutionFlags::SILType;
34343439

34353440
bool doDiag = false;
@@ -3497,8 +3502,8 @@ Type TypeResolver::resolveImplicitlyUnwrappedOptionalType(
34973502
return uncheckedOptionalTy;
34983503
}
34993504

3500-
Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
3501-
TypeResolutionOptions options) {
3505+
NeverNullType TypeResolver::resolveTupleType(TupleTypeRepr *repr,
3506+
TypeResolutionOptions options) {
35023507
SmallVector<TupleTypeElt, 8> elements;
35033508
elements.reserve(repr->getNumElements());
35043509

@@ -3565,8 +3570,9 @@ Type TypeResolver::resolveTupleType(TupleTypeRepr *repr,
35653570
return TupleType::get(elements, getASTContext());
35663571
}
35673572

3568-
Type TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
3569-
TypeResolutionOptions options) {
3573+
NeverNullType
3574+
TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
3575+
TypeResolutionOptions options) {
35703576

35713577
// Note that the superclass type will appear as part of one of the
35723578
// types in 'Members', so it's not used when constructing the
@@ -3633,8 +3639,8 @@ Type TypeResolver::resolveCompositionType(CompositionTypeRepr *repr,
36333639
/*HasExplicitAnyObject=*/false);
36343640
}
36353641

3636-
Type TypeResolver::resolveMetatypeType(MetatypeTypeRepr *repr,
3637-
TypeResolutionOptions options) {
3642+
NeverNullType TypeResolver::resolveMetatypeType(MetatypeTypeRepr *repr,
3643+
TypeResolutionOptions options) {
36383644
// The instance type of a metatype is always abstract, not SIL-lowered.
36393645
auto ty = resolveType(repr->getBase(), options.withoutContext());
36403646
if (ty->hasError()) {
@@ -3654,10 +3660,9 @@ Type TypeResolver::resolveMetatypeType(MetatypeTypeRepr *repr,
36543660
return buildMetatypeType(repr, ty, storedRepr);
36553661
}
36563662

3657-
Type TypeResolver::buildMetatypeType(
3658-
MetatypeTypeRepr *repr,
3659-
Type instanceType,
3660-
Optional<MetatypeRepresentation> storedRepr) {
3663+
NeverNullType
3664+
TypeResolver::buildMetatypeType(MetatypeTypeRepr *repr, Type instanceType,
3665+
Optional<MetatypeRepresentation> storedRepr) {
36613666
if (instanceType->isAnyExistentialType()) {
36623667
// TODO: diagnose invalid representations?
36633668
return ExistentialMetatypeType::get(instanceType, storedRepr);
@@ -3666,8 +3671,8 @@ Type TypeResolver::buildMetatypeType(
36663671
}
36673672
}
36683673

3669-
Type TypeResolver::resolveProtocolType(ProtocolTypeRepr *repr,
3670-
TypeResolutionOptions options) {
3674+
NeverNullType TypeResolver::resolveProtocolType(ProtocolTypeRepr *repr,
3675+
TypeResolutionOptions options) {
36713676
// The instance type of a metatype is always abstract, not SIL-lowered.
36723677
auto ty = resolveType(repr->getBase(), options.withoutContext());
36733678
if (ty->hasError()) {
@@ -3687,10 +3692,9 @@ Type TypeResolver::resolveProtocolType(ProtocolTypeRepr *repr,
36873692
return buildProtocolType(repr, ty, storedRepr);
36883693
}
36893694

3690-
Type TypeResolver::buildProtocolType(
3691-
ProtocolTypeRepr *repr,
3692-
Type instanceType,
3693-
Optional<MetatypeRepresentation> storedRepr) {
3695+
NeverNullType
3696+
TypeResolver::buildProtocolType(ProtocolTypeRepr *repr, Type instanceType,
3697+
Optional<MetatypeRepresentation> storedRepr) {
36943698
if (!instanceType->isAnyExistentialType()) {
36953699
diagnose(repr->getProtocolLoc(), diag::dot_protocol_on_non_existential,
36963700
instanceType);

0 commit comments

Comments
 (0)