Skip to content

Commit 19f1667

Browse files
redsun82redsun82
committed
Swift: change translation signature and detection
Translation now takes const references to swift entities and return trap entries (instead of taking apointer as an out parameter).
1 parent c3cb0d6 commit 19f1667

File tree

4 files changed

+151
-135
lines changed

4 files changed

+151
-135
lines changed

‎swift/codegen/templates/cpp_classes.mustache‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,9 @@ namespace {{namespace}} {
1414
{{#classes}}
1515

1616
struct {{name}}{{#has_bases}} : {{#bases}}{{^first}}, {{/first}}{{ref.name}}{{/bases}}{{/has_bases}} {
17-
{{name}}() {}
18-
1917
{{#final}}
18+
explicit {{name}}({{trap_affix}}Label<{{name}}Tag> id) : id{id} {}
19+
2020
{{trap_affix}}Label<{{name}}Tag> id{};
2121
{{/final}}
2222
{{#fields}}

‎swift/extractor/SwiftDispatcher.h‎

Lines changed: 7 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -83,6 +83,11 @@ class SwiftDispatcher {
8383
return label;
8484
}
8585

86+
template <typename E, typename = std::enable_if_t<!std::is_pointer_v<E>>>
87+
TrapLabelOf<E> assignNewLabel(E& e) {
88+
return assignNewLabel(&e);
89+
}
90+
8691
template <typename Tag>
8792
TrapLabel<Tag> createLabel() {
8893
auto ret = arena.allocateLabel<Tag>();
@@ -132,10 +137,10 @@ class SwiftDispatcher {
132137

133138
// map `fetchLabel` on the iterable `arg`, returning a vector of all labels
134139
template <typename Iterable>
135-
auto fetchRepeatedLabels(Iterable&& arg) -> std::vector<decltype(fetchLabel(*arg.begin()))> {
140+
auto fetchRepeatedLabels(Iterable&& arg) {
136141
std::vector<decltype(fetchLabel(*arg.begin()))> ret;
137142
ret.reserve(arg.size());
138-
for (const auto& e : arg) {
143+
for (const auto& e : std::forward<Iterable>(arg)) {
139144
ret.push_back(fetchLabel(e));
140145
}
141146
return ret;

‎swift/extractor/visitors/DeclVisitor.h‎

Lines changed: 122 additions & 106 deletions
Original file line numberDiff line numberDiff line change
@@ -11,216 +11,232 @@ namespace codeql {
1111
// `swift::Decl` visitor
1212
class DeclVisitor : public AstVisitorBase<DeclVisitor> {
1313
public:
14-
void translateFuncDecl(swift::FuncDecl* decl, codeql::ConcreteFuncDecl* entry) {
15-
entry->id = dispatcher_.assignNewLabel(decl);
14+
codeql::ConcreteFuncDecl translateFuncDecl(const swift::FuncDecl& decl) {
15+
ConcreteFuncDecl entry{dispatcher_.assignNewLabel(decl)};
1616
fillAbstractFunctionDecl(decl, entry);
17+
return entry;
1718
}
1819

19-
void translateConstructorDecl(swift::ConstructorDecl* decl, codeql::ConstructorDecl* entry) {
20-
entry->id = dispatcher_.assignNewLabel(decl);
20+
codeql::ConstructorDecl translateConstructorDecl(const swift::ConstructorDecl& decl) {
21+
ConstructorDecl entry{dispatcher_.assignNewLabel(decl)};
2122
fillAbstractFunctionDecl(decl, entry);
23+
return entry;
2224
}
2325

24-
void translateDestructorDecl(swift::DestructorDecl* decl, codeql::DestructorDecl* entry) {
25-
entry->id = dispatcher_.assignNewLabel(decl);
26+
codeql::DestructorDecl translateDestructorDecl(const swift::DestructorDecl& decl) {
27+
DestructorDecl entry{dispatcher_.assignNewLabel(decl)};
2628
fillAbstractFunctionDecl(decl, entry);
29+
return entry;
2730
}
2831

29-
void translatePrefixOperatorDecl(swift::PrefixOperatorDecl* decl,
30-
codeql::PrefixOperatorDecl* entry) {
31-
entry->id = dispatcher_.assignNewLabel(decl);
32+
codeql::PrefixOperatorDecl translatePrefixOperatorDecl(const swift::PrefixOperatorDecl& decl) {
33+
PrefixOperatorDecl entry{dispatcher_.assignNewLabel(decl)};
3234
fillOperatorDecl(decl, entry);
35+
return entry;
3336
}
3437

35-
void translatePostfixOperatorDecl(swift::PostfixOperatorDecl* decl,
36-
codeql::PostfixOperatorDecl* entry) {
37-
entry->id = dispatcher_.assignNewLabel(decl);
38+
codeql::PostfixOperatorDecl translatePostfixOperatorDecl(const swift::PostfixOperatorDecl& decl) {
39+
PostfixOperatorDecl entry{dispatcher_.assignNewLabel(decl)};
3840
fillOperatorDecl(decl, entry);
41+
return entry;
3942
}
4043

41-
void translateInfixOperatorDecl(swift::InfixOperatorDecl* decl,
42-
codeql::InfixOperatorDecl* entry) {
43-
entry->id = dispatcher_.assignNewLabel(decl);
44-
entry->precedence_group = dispatcher_.fetchOptionalLabel(decl->getPrecedenceGroup());
44+
codeql::InfixOperatorDecl translateInfixOperatorDecl(const swift::InfixOperatorDecl& decl) {
45+
InfixOperatorDecl entry{dispatcher_.assignNewLabel(decl)};
46+
entry.precedence_group = dispatcher_.fetchOptionalLabel(decl.getPrecedenceGroup());
4547
fillOperatorDecl(decl, entry);
48+
return entry;
4649
}
4750

48-
void translatePrecedenceGroupDecl(swift::PrecedenceGroupDecl* decl,
49-
codeql::PrecedenceGroupDecl* entry) {
50-
entry->id = dispatcher_.assignNewLabel(decl);
51+
codeql::PrecedenceGroupDecl translatePrecedenceGroupDecl(const swift::PrecedenceGroupDecl& decl) {
52+
PrecedenceGroupDecl entry{dispatcher_.assignNewLabel(decl)};
53+
return entry;
5154
}
5255

53-
void translateParamDecl(swift::ParamDecl* decl, codeql::ParamDecl* entry) {
54-
entry->id = dispatcher_.assignNewLabel(decl);
56+
codeql::ParamDecl translateParamDecl(const swift::ParamDecl& decl) {
57+
ParamDecl entry{dispatcher_.assignNewLabel(decl)};
5558
fillVarDecl(decl, entry);
59+
return entry;
5660
}
5761

58-
void translateTopLevelCodeDecl(swift::TopLevelCodeDecl* decl, codeql::TopLevelCodeDecl* entry) {
59-
entry->id = dispatcher_.assignNewLabel(decl);
60-
assert(decl->getBody() && "Expect top level code to have body");
61-
entry->body = dispatcher_.fetchLabel(decl->getBody());
62+
codeql::TopLevelCodeDecl translateTopLevelCodeDecl(const swift::TopLevelCodeDecl& decl) {
63+
TopLevelCodeDecl entry{dispatcher_.assignNewLabel(decl)};
64+
assert(decl.getBody() && "Expect top level code to have body");
65+
entry.body = dispatcher_.fetchLabel(decl.getBody());
66+
return entry;
6267
}
6368

64-
void translatePatternBindingDecl(swift::PatternBindingDecl* decl,
65-
codeql::PatternBindingDecl* entry) {
66-
entry->id = dispatcher_.assignNewLabel(decl);
67-
for (unsigned i = 0; i < decl->getNumPatternEntries(); ++i) {
68-
auto pattern = decl->getPattern(i);
69+
codeql::PatternBindingDecl translatePatternBindingDecl(const swift::PatternBindingDecl& decl) {
70+
PatternBindingDecl entry{dispatcher_.assignNewLabel(decl)};
71+
for (unsigned i = 0; i < decl.getNumPatternEntries(); ++i) {
72+
auto pattern = decl.getPattern(i);
6973
assert(pattern && "Expect pattern binding decl to have all patterns");
70-
entry->patterns.push_back(dispatcher_.fetchLabel(pattern));
71-
entry->inits.push_back(dispatcher_.fetchOptionalLabel(decl->getInit(i)));
74+
entry.patterns.push_back(dispatcher_.fetchLabel(pattern));
75+
entry.inits.push_back(dispatcher_.fetchOptionalLabel(decl.getInit(i)));
7276
}
77+
return entry;
7378
}
7479

75-
void translateVarDecl(swift::VarDecl* decl, codeql::ConcreteVarDecl* entry) {
76-
entry->id = dispatcher_.assignNewLabel(decl);
77-
entry->introducer_int = static_cast<uint8_t>(decl->getIntroducer());
80+
codeql::ConcreteVarDecl translateVarDecl(const swift::VarDecl& decl) {
81+
ConcreteVarDecl entry{dispatcher_.assignNewLabel(decl)};
82+
entry.introducer_int = static_cast<uint8_t>(decl.getIntroducer());
7883
fillVarDecl(decl, entry);
84+
return entry;
7985
}
8086

81-
void translateStructDecl(swift::StructDecl* decl, codeql::StructDecl* entry) {
82-
entry->id = dispatcher_.assignNewLabel(decl);
87+
codeql::StructDecl translateStructDecl(const swift::StructDecl& decl) {
88+
StructDecl entry{dispatcher_.assignNewLabel(decl)};
8389
fillNominalTypeDecl(decl, entry);
90+
return entry;
8491
}
8592

86-
void translateClassDecl(swift::ClassDecl* decl, codeql::ClassDecl* entry) {
87-
entry->id = dispatcher_.assignNewLabel(decl);
93+
codeql::ClassDecl translateClassDecl(const swift::ClassDecl& decl) {
94+
ClassDecl entry{dispatcher_.assignNewLabel(decl)};
8895
fillNominalTypeDecl(decl, entry);
96+
return entry;
8997
}
9098

91-
void translateEnumDecl(swift::EnumDecl* decl, codeql::EnumDecl* entry) {
92-
entry->id = dispatcher_.assignNewLabel(decl);
99+
codeql::EnumDecl translateEnumDecl(const swift::EnumDecl& decl) {
100+
EnumDecl entry{dispatcher_.assignNewLabel(decl)};
93101
fillNominalTypeDecl(decl, entry);
102+
return entry;
94103
}
95104

96-
void translateProtocolDecl(swift::ProtocolDecl* decl, codeql::ProtocolDecl* entry) {
97-
entry->id = dispatcher_.assignNewLabel(decl);
105+
codeql::ProtocolDecl translateProtocolDecl(const swift::ProtocolDecl& decl) {
106+
ProtocolDecl entry{dispatcher_.assignNewLabel(decl)};
98107
fillNominalTypeDecl(decl, entry);
108+
return entry;
99109
}
100110

101-
void translateEnumCaseDecl(swift::EnumCaseDecl* decl, codeql::EnumCaseDecl* entry) {
102-
entry->id = dispatcher_.assignNewLabel(decl);
103-
entry->elements = dispatcher_.fetchRepeatedLabels(decl->getElements());
111+
codeql::EnumCaseDecl translateEnumCaseDecl(const swift::EnumCaseDecl& decl) {
112+
EnumCaseDecl entry{dispatcher_.assignNewLabel(decl)};
113+
entry.elements = dispatcher_.fetchRepeatedLabels(decl.getElements());
114+
return entry;
104115
}
105116

106-
void translateEnumElementDecl(swift::EnumElementDecl* decl, codeql::EnumElementDecl* entry) {
107-
entry->id = dispatcher_.assignNewLabel(decl);
108-
entry->name = decl->getNameStr().str();
109-
if (decl->hasParameterList()) {
110-
entry->params = dispatcher_.fetchRepeatedLabels(*decl->getParameterList());
117+
codeql::EnumElementDecl translateEnumElementDecl(const swift::EnumElementDecl& decl) {
118+
EnumElementDecl entry{dispatcher_.assignNewLabel(decl)};
119+
entry.name = decl.getNameStr().str();
120+
if (decl.hasParameterList()) {
121+
entry.params = dispatcher_.fetchRepeatedLabels(*decl.getParameterList());
111122
}
112123
fillValueDecl(decl, entry);
124+
return entry;
113125
}
114126

115-
void translateGenericTypeParamDecl(swift::GenericTypeParamDecl* decl,
116-
GenericTypeParamDecl* entry) {
117-
entry->id = dispatcher_.assignNewLabel(decl);
127+
codeql::GenericTypeParamDecl translateGenericTypeParamDecl(
128+
const swift::GenericTypeParamDecl& decl) {
129+
GenericTypeParamDecl entry{dispatcher_.assignNewLabel(decl)};
118130
fillTypeDecl(decl, entry);
131+
return entry;
119132
}
120133

121-
void translateAssociatedTypeDecl(swift::AssociatedTypeDecl* decl,
122-
codeql::AssociatedTypeDecl* entry) {
123-
entry->id = dispatcher_.assignNewLabel(decl);
134+
codeql::AssociatedTypeDecl translateAssociatedTypeDecl(const swift::AssociatedTypeDecl& decl) {
135+
AssociatedTypeDecl entry{dispatcher_.assignNewLabel(decl)};
124136
fillTypeDecl(decl, entry);
137+
return entry;
125138
}
126139

127-
void translateTypeAliasDecl(swift::TypeAliasDecl* decl, codeql::TypeAliasDecl* entry) {
128-
entry->id = dispatcher_.assignNewLabel(decl);
140+
codeql::TypeAliasDecl translateTypeAliasDecl(const swift::TypeAliasDecl& decl) {
141+
TypeAliasDecl entry{dispatcher_.assignNewLabel(decl)};
129142
fillTypeDecl(decl, entry);
143+
return entry;
130144
}
131145

132-
void translateAccessorDecl(swift::AccessorDecl* decl, codeql::AccessorDecl* entry) {
133-
entry->id = dispatcher_.assignNewLabel(decl);
134-
switch (decl->getAccessorKind()) {
146+
codeql::AccessorDecl translateAccessorDecl(const swift::AccessorDecl& decl) {
147+
AccessorDecl entry{dispatcher_.assignNewLabel(decl)};
148+
switch (decl.getAccessorKind()) {
135149
case swift::AccessorKind::Get:
136-
entry->is_getter = true;
150+
entry.is_getter = true;
137151
break;
138152
case swift::AccessorKind::Set:
139-
entry->is_setter = true;
153+
entry.is_setter = true;
140154
break;
141155
case swift::AccessorKind::WillSet:
142-
entry->is_will_set = true;
156+
entry.is_will_set = true;
143157
break;
144158
case swift::AccessorKind::DidSet:
145-
entry->is_did_set = true;
159+
entry.is_did_set = true;
146160
break;
147161
}
148162
fillAbstractFunctionDecl(decl, entry);
163+
return entry;
149164
}
150165

151-
void translateSubscriptDecl(swift::SubscriptDecl* decl, codeql::SubscriptDecl* entry) {
152-
entry->id = dispatcher_.assignNewLabel(decl);
153-
entry->element_type = dispatcher_.fetchLabel(decl->getElementInterfaceType());
154-
if (auto indices = decl->getIndices()) {
155-
entry->params = dispatcher_.fetchRepeatedLabels(*indices);
166+
codeql::SubscriptDecl translateSubscriptDecl(const swift::SubscriptDecl& decl) {
167+
SubscriptDecl entry{dispatcher_.assignNewLabel(decl)};
168+
entry.element_type = dispatcher_.fetchLabel(decl.getElementInterfaceType());
169+
if (auto indices = decl.getIndices()) {
170+
entry.params = dispatcher_.fetchRepeatedLabels(*indices);
156171
}
157172
fillAbstractStorageDecl(decl, entry);
173+
return entry;
158174
}
159175

160176
private:
161-
void fillAbstractFunctionDecl(swift::AbstractFunctionDecl* decl,
162-
codeql::AbstractFunctionDecl* entry) {
163-
assert(decl->hasParameterList() && "Expect functions to have a parameter list");
164-
entry->name = !decl->hasName() || decl->getName().isSpecial() ? "(unnamed function decl)"
165-
: decl->getNameStr().str();
166-
entry->body = dispatcher_.fetchOptionalLabel(decl->getBody());
167-
entry->params = dispatcher_.fetchRepeatedLabels(*decl->getParameters());
177+
void fillAbstractFunctionDecl(const swift::AbstractFunctionDecl& decl,
178+
codeql::AbstractFunctionDecl& entry) {
179+
assert(decl.hasParameterList() && "Expect functions to have a parameter list");
180+
entry.name = !decl.hasName() || decl.getName().isSpecial() ? "(unnamed function decl)"
181+
: decl.getNameStr().str();
182+
entry.body = dispatcher_.fetchOptionalLabel(decl.getBody());
183+
entry.params = dispatcher_.fetchRepeatedLabels(*decl.getParameters());
168184
fillValueDecl(decl, entry);
169185
fillGenericContext(decl, entry);
170186
}
171187

172-
void fillOperatorDecl(swift::OperatorDecl* decl, codeql::OperatorDecl* entry) {
173-
entry->name = decl->getName().str().str();
188+
void fillOperatorDecl(const swift::OperatorDecl& decl, codeql::OperatorDecl& entry) {
189+
entry.name = decl.getName().str().str();
174190
}
175191

176-
void fillTypeDecl(swift::TypeDecl* decl, codeql::TypeDecl* entry) {
177-
entry->name = decl->getNameStr().str();
178-
for (auto& typeLoc : decl->getInherited()) {
192+
void fillTypeDecl(const swift::TypeDecl& decl, codeql::TypeDecl& entry) {
193+
entry.name = decl.getNameStr().str();
194+
for (auto& typeLoc : decl.getInherited()) {
179195
if (auto type = typeLoc.getType()) {
180-
entry->base_types.push_back(dispatcher_.fetchLabel(type));
196+
entry.base_types.push_back(dispatcher_.fetchLabel(type));
181197
}
182198
}
183199
fillValueDecl(decl, entry);
184200
}
185201

186-
void fillIterableDeclContext(swift::IterableDeclContext* decl,
187-
codeql::IterableDeclContext* entry) {
188-
entry->members = dispatcher_.fetchRepeatedLabels(decl->getAllMembers());
202+
void fillIterableDeclContext(const swift::IterableDeclContext& decl,
203+
codeql::IterableDeclContext& entry) {
204+
entry.members = dispatcher_.fetchRepeatedLabels(decl.getAllMembers());
189205
}
190206

191-
void fillVarDecl(swift::VarDecl* decl, codeql::VarDecl* entry) {
192-
entry->name = decl->getNameStr().str();
193-
entry->type = dispatcher_.fetchLabel(decl->getType());
194-
entry->parent_pattern = dispatcher_.fetchOptionalLabel(decl->getParentPattern());
195-
entry->parent_initializer = dispatcher_.fetchOptionalLabel(decl->getParentInitializer());
196-
if (decl->hasAttachedPropertyWrapper()) {
197-
entry->attached_property_wrapper_type =
198-
dispatcher_.fetchOptionalLabel(decl->getPropertyWrapperBackingPropertyType());
207+
void fillVarDecl(const swift::VarDecl& decl, codeql::VarDecl& entry) {
208+
entry.name = decl.getNameStr().str();
209+
entry.type = dispatcher_.fetchLabel(decl.getType());
210+
entry.parent_pattern = dispatcher_.fetchOptionalLabel(decl.getParentPattern());
211+
entry.parent_initializer = dispatcher_.fetchOptionalLabel(decl.getParentInitializer());
212+
if (decl.hasAttachedPropertyWrapper()) {
213+
entry.attached_property_wrapper_type =
214+
dispatcher_.fetchOptionalLabel(decl.getPropertyWrapperBackingPropertyType());
199215
}
200216
fillAbstractStorageDecl(decl, entry);
201217
}
202218

203-
void fillNominalTypeDecl(swift::NominalTypeDecl* decl, codeql::NominalTypeDecl* entry) {
204-
entry->type = dispatcher_.fetchLabel(decl->getDeclaredType());
219+
void fillNominalTypeDecl(const swift::NominalTypeDecl& decl, codeql::NominalTypeDecl& entry) {
220+
entry.type = dispatcher_.fetchLabel(decl.getDeclaredType());
205221
fillGenericContext(decl, entry);
206222
fillIterableDeclContext(decl, entry);
207223
fillTypeDecl(decl, entry);
208224
}
209225

210-
void fillGenericContext(swift::GenericContext* decl, codeql::GenericContext* entry) {
211-
if (auto params = decl->getGenericParams()) {
212-
entry->generic_type_params = dispatcher_.fetchRepeatedLabels(*params);
226+
void fillGenericContext(const swift::GenericContext& decl, codeql::GenericContext& entry) {
227+
if (auto params = decl.getGenericParams()) {
228+
entry.generic_type_params = dispatcher_.fetchRepeatedLabels(*params);
213229
}
214230
}
215231

216-
void fillValueDecl(swift::ValueDecl* decl, codeql::ValueDecl* entry) {
217-
assert(decl->getInterfaceType() && "Expect ValueDecl to have InterfaceType");
218-
entry->interface_type = dispatcher_.fetchLabel(decl->getInterfaceType());
232+
void fillValueDecl(const swift::ValueDecl& decl, codeql::ValueDecl& entry) {
233+
assert(decl.getInterfaceType() && "Expect ValueDecl to have InterfaceType");
234+
entry.interface_type = dispatcher_.fetchLabel(decl.getInterfaceType());
219235
}
220236

221-
void fillAbstractStorageDecl(swift::AbstractStorageDecl* decl,
222-
codeql::AbstractStorageDecl* entry) {
223-
entry->accessor_decls = dispatcher_.fetchRepeatedLabels(decl->getAllAccessors());
237+
void fillAbstractStorageDecl(const swift::AbstractStorageDecl& decl,
238+
codeql::AbstractStorageDecl& entry) {
239+
entry.accessor_decls = dispatcher_.fetchRepeatedLabels(decl.getAllAccessors());
224240
fillValueDecl(decl, entry);
225241
}
226242
};

0 commit comments

Comments
 (0)