Skip to content

Commit 10c6254

Browse files
jrose-applejrose-apple
committed
[Serialization] Extract error types to a separate header.
The next commits will need access from ModuleFile.cpp. Also stop pretending we care what kind of error we got back, or that we might get back random other errors that weren't accounted for. That's good for crash logs, but not actually interesting here. (Nearly every place that previously looked for OverrideError will also accept the upcoming TypeError.) No effective functionality change.
1 parent 1478159 commit 10c6254

File tree

2 files changed

+280
-254
lines changed

2 files changed

+280
-254
lines changed

‎lib/Serialization/Deserialization.cpp

Lines changed: 26 additions & 254 deletions
Original file line numberDiff line numberDiff line change
@@ -10,6 +10,7 @@
1010
//
1111
//===----------------------------------------------------------------------===//
1212

13+
#include "DeserializationErrors.h"
1314
#include "swift/Serialization/ModuleFile.h"
1415
#include "swift/Serialization/ModuleFormat.h"
1516
#include "swift/AST/ASTContext.h"
@@ -96,161 +97,6 @@ namespace {
9697
}
9798
};
9899

99-
class XRefTracePath {
100-
class PathPiece {
101-
public:
102-
enum class Kind {
103-
Value,
104-
Type,
105-
Operator,
106-
OperatorFilter,
107-
Accessor,
108-
Extension,
109-
GenericParam,
110-
Unknown
111-
};
112-
113-
private:
114-
Kind kind;
115-
void *data;
116-
117-
template <typename T>
118-
T getDataAs() const {
119-
return llvm::PointerLikeTypeTraits<T>::getFromVoidPointer(data);
120-
}
121-
122-
public:
123-
template <typename T>
124-
PathPiece(Kind K, T value)
125-
: kind(K),
126-
data(llvm::PointerLikeTypeTraits<T>::getAsVoidPointer(value)) {}
127-
128-
void print(raw_ostream &os) const {
129-
switch (kind) {
130-
case Kind::Value:
131-
os << getDataAs<Identifier>();
132-
break;
133-
case Kind::Type:
134-
os << "with type " << getDataAs<Type>();
135-
break;
136-
case Kind::Extension:
137-
if (getDataAs<ModuleDecl *>())
138-
os << "in an extension in module '" << getDataAs<ModuleDecl *>()->getName()
139-
<< "'";
140-
else
141-
os << "in an extension in any module";
142-
break;
143-
case Kind::Operator:
144-
os << "operator " << getDataAs<Identifier>();
145-
break;
146-
case Kind::OperatorFilter:
147-
switch (getDataAs<uintptr_t>()) {
148-
case Infix:
149-
os << "(infix)";
150-
break;
151-
case Prefix:
152-
os << "(prefix)";
153-
break;
154-
case Postfix:
155-
os << "(postfix)";
156-
break;
157-
default:
158-
os << "(unknown operator filter)";
159-
break;
160-
}
161-
break;
162-
case Kind::Accessor:
163-
switch (getDataAs<uintptr_t>()) {
164-
case Getter:
165-
os << "(getter)";
166-
break;
167-
case Setter:
168-
os << "(setter)";
169-
break;
170-
case MaterializeForSet:
171-
os << "(materializeForSet)";
172-
break;
173-
case Addressor:
174-
os << "(addressor)";
175-
break;
176-
case MutableAddressor:
177-
os << "(mutableAddressor)";
178-
break;
179-
case WillSet:
180-
os << "(willSet)";
181-
break;
182-
case DidSet:
183-
os << "(didSet)";
184-
break;
185-
default:
186-
os << "(unknown accessor kind)";
187-
break;
188-
}
189-
break;
190-
case Kind::GenericParam:
191-
os << "generic param #" << getDataAs<uintptr_t>();
192-
break;
193-
case Kind::Unknown:
194-
os << "unknown xref kind " << getDataAs<uintptr_t>();
195-
break;
196-
}
197-
}
198-
};
199-
200-
ModuleDecl &baseM;
201-
SmallVector<PathPiece, 8> path;
202-
203-
public:
204-
explicit XRefTracePath(ModuleDecl &M) : baseM(M) {}
205-
206-
void addValue(Identifier name) {
207-
path.push_back({ PathPiece::Kind::Value, name });
208-
}
209-
210-
void addType(Type ty) {
211-
path.push_back({ PathPiece::Kind::Type, ty });
212-
}
213-
214-
void addOperator(Identifier name) {
215-
path.push_back({ PathPiece::Kind::Operator, name });
216-
}
217-
218-
void addOperatorFilter(uint8_t fixity) {
219-
path.push_back({ PathPiece::Kind::OperatorFilter,
220-
static_cast<uintptr_t>(fixity) });
221-
}
222-
223-
void addAccessor(uint8_t kind) {
224-
path.push_back({ PathPiece::Kind::Accessor,
225-
static_cast<uintptr_t>(kind) });
226-
}
227-
228-
void addExtension(ModuleDecl *M) {
229-
path.push_back({ PathPiece::Kind::Extension, M });
230-
}
231-
232-
void addGenericParam(uintptr_t index) {
233-
path.push_back({ PathPiece::Kind::GenericParam, index });
234-
}
235-
236-
void addUnknown(uintptr_t kind) {
237-
path.push_back({ PathPiece::Kind::Unknown, kind });
238-
}
239-
240-
void removeLast() {
241-
path.pop_back();
242-
}
243-
244-
void print(raw_ostream &os, StringRef leading = "") const {
245-
os << "Cross-reference to module '" << baseM.getName() << "'\n";
246-
for (auto &piece : path) {
247-
os << leading << "... ";
248-
piece.print(os);
249-
os << "\n";
250-
}
251-
}
252-
};
253-
254100
class PrettyXRefTrace :
255101
public llvm::PrettyStackTraceEntry,
256102
public XRefTracePath {
@@ -273,67 +119,15 @@ namespace {
273119
os << Action << " \'" << getNameOfModule(MF) << "'\n";
274120
}
275121
};
276-
277-
class XRefError : public llvm::ErrorInfo<XRefError> {
278-
friend ErrorInfo;
279-
static const char ID;
280-
281-
XRefTracePath path;
282-
const char *message;
283-
public:
284-
template <size_t N>
285-
XRefError(const char (&message)[N], XRefTracePath path)
286-
: path(path), message(message) {}
287-
288-
void log(raw_ostream &OS) const override {
289-
OS << message << "\n";
290-
path.print(OS);
291-
}
292-
293-
std::error_code convertToErrorCode() const override {
294-
// This is a deprecated part of llvm::Error, so we just return a very
295-
// generic value.
296-
return {EINVAL, std::generic_category()};
297-
}
298-
};
299-
const char XRefError::ID = '\0';
300-
301-
class OverrideError : public llvm::ErrorInfo<OverrideError> {
302-
public:
303-
enum Kind {
304-
Normal,
305-
DesignatedInitializer
306-
};
307-
308-
private:
309-
friend ErrorInfo;
310-
static const char ID;
311-
312-
DeclName name;
313-
Kind kind;
314-
315-
public:
316-
317-
explicit OverrideError(DeclName name, Kind kind = Normal)
318-
: name(name), kind(kind) {}
319-
320-
void log(raw_ostream &OS) const override {
321-
OS << "could not find '" << name << "' in parent class";
322-
}
323-
324-
Kind getKind() const {
325-
return kind;
326-
}
327-
328-
std::error_code convertToErrorCode() const override {
329-
// This is a deprecated part of llvm::Error, so we just return a very
330-
// generic value.
331-
return {EINVAL, std::generic_category()};
332-
}
333-
};
334-
const char OverrideError::ID = '\0';
335122
} // end anonymous namespace
336123

124+
const char DeclDeserializationError::ID = '\0';
125+
void DeclDeserializationError::anchor() {}
126+
const char XRefError::ID = '\0';
127+
void XRefError::anchor() {}
128+
const char OverrideError::ID = '\0';
129+
void OverrideError::anchor() {}
130+
337131

338132
/// Skips a single record in the bitstream.
339133
///
@@ -2721,11 +2515,7 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
27212515

27222516
auto overridden = getDeclChecked(overriddenID);
27232517
if (!overridden) {
2724-
llvm::handleAllErrors(overridden.takeError(),
2725-
[](const XRefError &) { /* expected */ },
2726-
[this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
2727-
fatal(std::move(unhandled));
2728-
});
2518+
llvm::consumeError(overridden.takeError());
27292519
auto kind = OverrideError::Normal;
27302520
if (initKind == CtorInitializerKind::Designated)
27312521
kind = OverrideError::DesignatedInitializer;
@@ -2822,11 +2612,7 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
28222612

28232613
Expected<Decl *> overridden = getDeclChecked(overriddenID);
28242614
if (!overridden) {
2825-
llvm::handleAllErrors(overridden.takeError(),
2826-
[](const XRefError &) { /* expected */ },
2827-
[this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
2828-
fatal(std::move(unhandled));
2829-
});
2615+
llvm::consumeError(overridden.takeError());
28302616
return llvm::make_error<OverrideError>(name);
28312617
}
28322618

@@ -2949,11 +2735,7 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
29492735

29502736
Expected<Decl *> overridden = getDeclChecked(overriddenID);
29512737
if (!overridden) {
2952-
llvm::handleAllErrors(overridden.takeError(),
2953-
[](const XRefError &) { /* expected */ },
2954-
[this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
2955-
fatal(std::move(unhandled));
2956-
});
2738+
llvm::consumeError(overridden.takeError());
29572739
return llvm::make_error<OverrideError>(name);
29582740
}
29592741

@@ -3074,12 +2856,8 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
30742856
for (unsigned i = 0; i != numPatterns; ++i) {
30752857
auto pattern = readPattern(dc);
30762858
if (!pattern) {
3077-
// Silently drop the pattern if it had an override-related problem.
3078-
llvm::handleAllErrors(pattern.takeError(),
3079-
[](const OverrideError &) { /* expected */ },
3080-
[this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
3081-
fatal(std::move(unhandled));
3082-
});
2859+
// Silently drop the pattern...
2860+
llvm::consumeError(pattern.takeError());
30832861
// ...but continue to read any further patterns we're expecting.
30842862
continue;
30852863
}
@@ -3486,11 +3264,7 @@ ModuleFile::getDeclChecked(DeclID DID, Optional<DeclContext *> ForcedContext) {
34863264

34873265
Expected<Decl *> overridden = getDeclChecked(overriddenID);
34883266
if (!overridden) {
3489-
llvm::handleAllErrors(overridden.takeError(),
3490-
[](const XRefError &) { /* expected */ },
3491-
[this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
3492-
fatal(std::move(unhandled));
3493-
});
3267+
llvm::consumeError(overridden.takeError());
34943268
return llvm::make_error<OverrideError>(name);
34953269
}
34963270

@@ -4467,20 +4241,18 @@ void ModuleFile::loadAllMembers(Decl *container, uint64_t contextData) {
44674241
if (!getContext().LangOpts.EnableDeserializationRecovery)
44684242
fatal(next.takeError());
44694243

4470-
// Drop the member if it had an override-related problem.
4471-
auto handleMissingOverrideBase = [container](const OverrideError &error) {
4472-
if (error.getKind() != OverrideError::DesignatedInitializer)
4473-
return;
4474-
auto *containingClass = dyn_cast<ClassDecl>(container);
4475-
if (!containingClass)
4476-
return;
4477-
containingClass->setHasMissingDesignatedInitializers();
4478-
};
4479-
llvm::handleAllErrors(next.takeError(),
4480-
handleMissingOverrideBase,
4481-
[this](std::unique_ptr<llvm::ErrorInfoBase> unhandled) {
4482-
fatal(std::move(unhandled));
4483-
});
4244+
// Drop the member if it had a problem.
4245+
if (auto *containingClass = dyn_cast<ClassDecl>(container)) {
4246+
auto handleMissingDesignatedInit =
4247+
[containingClass](const DeclDeserializationError &error) {
4248+
if (error.getKind() != OverrideError::DesignatedInitializer)
4249+
return;
4250+
containingClass->setHasMissingDesignatedInitializers();
4251+
};
4252+
llvm::handleAllErrors(next.takeError(), handleMissingDesignatedInit);
4253+
} else {
4254+
llvm::consumeError(next.takeError());
4255+
}
44844256
continue;
44854257
}
44864258
assert(next.get() && "unchecked error deserializing next member");

0 commit comments

Comments
 (0)