Skip to content

Commit 2a7de1b

Browse files
DougGregorDougGregor
committed
Store the conforming type within an abstract ProtocolConformanceRef
An "abstract" ProtocolConformanceRef is a conformance of a type parameter or archetype to a given protocol. Previously, we would only store the protocol requirement itself---but not track the actual conforming type, requiring clients of ProtocolConformanceRef to keep track of this information separately. Record the conforming type as part of an abstract ProtocolConformanceRef, so that clients will be able to recover it later. This is handled by a uniqued AbstractConformance structure, so that ProtocolConformanceRef itself stays one pointer. There remain a small number of places where we create an abstract ProtocolConformanceRef with a null type. We'll want to chip away at those and establish some stronger invariants on the abstract conformance in the future.
1 parent f8ab391 commit 2a7de1b

24 files changed

+325
-70
lines changed

Diff for: ‎include/swift/AST/ProtocolConformanceRef.h

+54-13
Original file line numberDiff line numberDiff line change
@@ -26,8 +26,24 @@
2626
#include "llvm/ADT/STLExtras.h"
2727
#include <optional>
2828

29+
namespace swift {
30+
class AbstractConformance;
31+
}
32+
2933
namespace llvm {
30-
class raw_ostream;
34+
class raw_ostream;
35+
36+
template <>
37+
struct PointerLikeTypeTraits<swift::AbstractConformance *> {
38+
public:
39+
static inline void *getAsVoidPointer(swift::AbstractConformance *ptr) {
40+
return ptr;
41+
}
42+
static inline swift::AbstractConformance *getFromVoidPointer(void *ptr) {
43+
return (swift::AbstractConformance *)ptr;
44+
}
45+
enum { NumLowBitsAvailable = swift::TypeAlignInBits };
46+
};
3147
}
3248

3349
namespace swift {
@@ -53,22 +69,27 @@ enum class EffectKind : uint8_t;
5369
/// ProtocolConformanceRef allows the efficient recovery of the protocol
5470
/// even when the conformance is abstract.
5571
class ProtocolConformanceRef {
56-
using UnionType = llvm::PointerUnion<ProtocolDecl *,
72+
public:
73+
using UnionType = llvm::PointerUnion<AbstractConformance *,
5774
ProtocolConformance *,
5875
PackConformance *>;
76+
77+
private:
5978
UnionType Union;
6079

6180
explicit ProtocolConformanceRef(UnionType value) : Union(value) {}
6281

82+
public:
83+
ProtocolConformanceRef() : Union() {}
84+
ProtocolConformanceRef(std::nullptr_t) : Union() {}
85+
6386
/// Create an abstract protocol conformance reference.
64-
explicit ProtocolConformanceRef(ProtocolDecl *proto) : Union(proto) {
65-
assert(proto != nullptr &&
87+
explicit ProtocolConformanceRef(AbstractConformance *abstract)
88+
: Union(abstract) {
89+
assert(abstract != nullptr &&
6690
"cannot construct ProtocolConformanceRef with null");
6791
}
6892

69-
public:
70-
ProtocolConformanceRef() : Union() {}
71-
7293
/// Create a concrete protocol conformance reference.
7394
explicit ProtocolConformanceRef(ProtocolConformance *conf) : Union(conf) {
7495
assert(conf != nullptr &&
@@ -95,7 +116,7 @@ class ProtocolConformanceRef {
95116
explicit operator bool() const { return !isInvalid(); }
96117

97118
/// Create an abstract conformance for a type parameter or archetype.
98-
static ProtocolConformanceRef forAbstract(Type subjectType,
119+
static ProtocolConformanceRef forAbstract(Type conformingType,
99120
ProtocolDecl *protocol);
100121

101122
bool isConcrete() const {
@@ -115,12 +136,11 @@ class ProtocolConformanceRef {
115136
}
116137

117138
bool isAbstract() const {
118-
return !isInvalid() && Union.is<ProtocolDecl*>();
139+
return !isInvalid() && Union.is<AbstractConformance*>();
119140
}
120141

121-
ProtocolDecl *getAbstract() const {
122-
ASSERT(isAbstract());
123-
return Union.get<ProtocolDecl*>();
142+
AbstractConformance *getAbstract() const {
143+
return Union.get<AbstractConformance *>();
124144
}
125145

126146
/// Determine whether this conformance (or a conformance it depends on)
@@ -149,7 +169,7 @@ class ProtocolConformanceRef {
149169
/// The given `body` will be called on each isolated conformance. If it ever
150170
/// returns `true`, this function will abort the search and return `true`.
151171
bool forEachIsolatedConformance(
152-
llvm::function_ref<bool(ProtocolConformance*)> body
172+
llvm::function_ref<bool(ProtocolConformanceRef)> body
153173
) const;
154174

155175
using OpaqueValue = void*;
@@ -158,6 +178,9 @@ class ProtocolConformanceRef {
158178
return ProtocolConformanceRef(UnionType::getFromOpaqueValue(value));
159179
}
160180

181+
/// Retrieve the conforming type.
182+
Type getConformingType() const;
183+
161184
/// Return the protocol requirement.
162185
ProtocolDecl *getRequirement() const;
163186

@@ -240,4 +263,22 @@ SourceLoc extractNearestSourceLoc(const ProtocolConformanceRef conformanceRef);
240263

241264
} // end namespace swift
242265

266+
namespace llvm {
267+
class raw_ostream;
268+
269+
template <>
270+
struct PointerLikeTypeTraits<swift::ProtocolConformanceRef>
271+
: PointerLikeTypeTraits<swift::ProtocolConformanceRef::UnionType>
272+
{
273+
public:
274+
static inline void *getAsVoidPointer(swift::ProtocolConformanceRef ref) {
275+
return ref.getOpaqueValue();
276+
}
277+
static inline swift::ProtocolConformanceRef getFromVoidPointer(void *ptr) {
278+
return swift::ProtocolConformanceRef::getFromOpaqueValue(ptr);
279+
}
280+
};
281+
282+
}
283+
243284
#endif // LLVM_SWIFT_AST_PROTOCOLCONFORMANCEREF_H

Diff for: ‎include/swift/AST/Requirement.h

+1-1
Original file line numberDiff line numberDiff line change
@@ -192,7 +192,7 @@ class Requirement {
192192
CheckRequirementResult checkRequirement(
193193
SmallVectorImpl<Requirement> &subReqs,
194194
bool allowMissing = false,
195-
SmallVectorImpl<ProtocolConformance *> *isolatedConformances = nullptr
195+
SmallVectorImpl<ProtocolConformanceRef> *isolatedConformances = nullptr
196196
) const;
197197

198198
/// Determines if this substituted requirement can ever be satisfied,

Diff for: ‎lib/AST/ASTContext.cpp

+34
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515
//===----------------------------------------------------------------------===//
1616

1717
#include "swift/AST/ASTContext.h"
18+
#include "AbstractConformance.h"
1819
#include "ClangTypeConverter.h"
1920
#include "ForeignRepresentationInfo.h"
2021
#include "SubstitutionMapStorage.h"
@@ -596,6 +597,9 @@ struct ASTContext::Implementation {
596597
/// The set of substitution maps (uniqued by their storage).
597598
llvm::FoldingSet<SubstitutionMap::Storage> SubstitutionMaps;
598599

600+
/// The set of abstract conformances (uniqued by their storage).
601+
llvm::FoldingSet<AbstractConformance> AbstractConformances;
602+
599603
~Arena() {
600604
for (auto &conformance : SpecializedConformances)
601605
conformance.~SpecializedProtocolConformance();
@@ -3379,6 +3383,7 @@ void ASTContext::Implementation::Arena::dump(llvm::raw_ostream &os) const {
33793383
SIZE_AND_BYTES(BuiltinConformances);
33803384
SIZE(PackConformances);
33813385
SIZE(SubstitutionMaps);
3386+
SIZE(AbstractConformances);
33823387

33833388
#undef SIZE
33843389
#undef SIZE_AND_BYTES
@@ -5739,6 +5744,35 @@ SubstitutionMap::Storage *SubstitutionMap::Storage::get(
57395744
return result;
57405745
}
57415746

5747+
ProtocolConformanceRef ProtocolConformanceRef::forAbstract(
5748+
Type conformingType, ProtocolDecl *proto) {
5749+
ASTContext &ctx = proto->getASTContext();
5750+
5751+
// Figure out which arena this should go in.
5752+
RecursiveTypeProperties properties;
5753+
if (conformingType)
5754+
properties |= conformingType->getRecursiveProperties();
5755+
auto arena = getArena(properties);
5756+
5757+
// Profile the substitution map.
5758+
llvm::FoldingSetNodeID id;
5759+
AbstractConformance::Profile(id, conformingType, proto);
5760+
5761+
// Did we already record this abstract conformance?
5762+
void *insertPos;
5763+
auto &abstractConformances =
5764+
ctx.getImpl().getArena(arena).AbstractConformances;
5765+
if (auto result = abstractConformances.FindNodeOrInsertPos(id, insertPos))
5766+
return ProtocolConformanceRef(result);
5767+
5768+
// Allocate and record this abstract conformance.
5769+
auto mem = ctx.Allocate(sizeof(AbstractConformance),
5770+
alignof(AbstractConformance), arena);
5771+
auto result = new (mem) AbstractConformance(conformingType, proto);
5772+
abstractConformances.InsertNode(result, insertPos);
5773+
return ProtocolConformanceRef(result);
5774+
}
5775+
57425776
const AvailabilityContext::Storage *AvailabilityContext::Storage::get(
57435777
const AvailabilityRange &platformRange, bool isDeprecated,
57445778
llvm::ArrayRef<DomainInfo> domainInfos, const ASTContext &ctx) {

Diff for: ‎lib/AST/ASTDumper.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -5519,7 +5519,7 @@ class PrintConformance : public PrintBase {
55195519
assert(conformance.isAbstract());
55205520

55215521
printHead("abstract_conformance", ASTNodeColor, label);
5522-
printReferencedDeclField(conformance.getAbstract(),
5522+
printReferencedDeclField(conformance.getRequirement(),
55235523
Label::always("protocol"));
55245524
printFoot();
55255525
}

Diff for: ‎lib/AST/ASTMangler.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -4545,7 +4545,7 @@ void ASTMangler::appendAnyProtocolConformance(
45454545
return;
45464546

45474547
auto path = genericSig->getConformancePath(conformingType,
4548-
conformance.getAbstract());
4548+
conformance.getRequirement());
45494549
appendDependentProtocolConformance(path, genericSig);
45504550
} else if (auto opaqueType = conformingType->getAs<OpaqueTypeArchetypeType>()) {
45514551
if (forInvertible)
@@ -4556,7 +4556,7 @@ void ASTMangler::appendAnyProtocolConformance(
45564556
ConformancePath conformancePath =
45574557
opaqueSignature->getConformancePath(
45584558
opaqueType->getInterfaceType(),
4559-
conformance.getAbstract());
4559+
conformance.getRequirement());
45604560

45614561
// Append the conformance path with the signature of the opaque type.
45624562
appendDependentProtocolConformance(conformancePath, opaqueSignature);

Diff for: ‎lib/AST/AbstractConformance.h

+51
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,51 @@
1+
//===--- AbstractConformance.h - Abstract conformance storage ---*- C++ -*-===//
2+
//
3+
// This source file is part of the Swift.org open source project
4+
//
5+
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
6+
// Licensed under Apache License v2.0 with Runtime Library Exception
7+
//
8+
// See https://swift.org/LICENSE.txt for license information
9+
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
10+
//
11+
//===----------------------------------------------------------------------===//
12+
//
13+
// This file defines the AbstractConformance class, which stores an
14+
// abstract conformance that is stashed in a ProtocolConformanceRef.
15+
//
16+
//===----------------------------------------------------------------------===//
17+
#ifndef SWIFT_AST_ABSTRACT_CONFORMANCE_H
18+
#define SWIFT_AST_ABSTRACT_CONFORMANCE_H
19+
20+
#include "swift/AST/Type.h"
21+
#include "llvm/ADT/FoldingSet.h"
22+
23+
namespace swift {
24+
class AbstractConformance final : public llvm::FoldingSetNode {
25+
Type conformingType;
26+
ProtocolDecl *requirement;
27+
28+
public:
29+
AbstractConformance(Type conformingType, ProtocolDecl *requirement)
30+
: conformingType(conformingType), requirement(requirement) { }
31+
32+
Type getConformingType() const { return conformingType; }
33+
ProtocolDecl *getRequirement() const { return requirement; }
34+
35+
void Profile(llvm::FoldingSetNodeID &id) const {
36+
Profile(id, getConformingType(), getRequirement());
37+
}
38+
39+
/// Profile the substitution map storage, for use with LLVM's FoldingSet.
40+
static void Profile(llvm::FoldingSetNodeID &id,
41+
Type conformingType,
42+
ProtocolDecl *requirement) {
43+
id.AddPointer(conformingType.getPointer());
44+
id.AddPointer(requirement);
45+
}
46+
};
47+
48+
}
49+
50+
#endif // SWIFT_AST_ABSTRACT_CONFORMANCE_H
51+

0 commit comments

Comments
 (0)