28460339749

Committed 30 Jun 2026 04:35PM UTC coverage: 90.401% (-0.1%) from 90.53%

Build # 28460339749

Build Type

Pull #44

github

Committed by

rieske

Commit Message

Simplify struct field codegen to FieldAddress only

Drop FieldLoad/FieldStore; materialize the field address then reuse
Dereference for reads and LvalueAssign for writes. Keep a single
baseIsPointer flag on FieldAddress for dot vs arrow.

Pull Request Pull Request #44: Implement C structs with member access

Coverage Stats

236 of 282 new or added lines in 12 files covered. (83.69%)

7 existing lines in 2 files now uncovered.

5349 of 5917 relevant lines covered (90.4%)

235740.3 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.11

/src/ast/AbstractSyntaxTreeBuilderContext.cpp

#include "AbstractSyntaxTreeBuilderContext.h"

namespace ast {

AbstractSyntaxTreeBuilderContext::AbstractSyntaxTreeBuilderContext() {
}

void AbstractSyntaxTreeBuilderContext::pushTerminal(TerminalSymbol terminal) {
    terminalSymbols.push(terminal);
}

TerminalSymbol AbstractSyntaxTreeBuilderContext::popTerminal() {
    auto terminal = terminalSymbols.top();
    terminalSymbols.pop();
    return terminal;
}

void AbstractSyntaxTreeBuilderContext::pushTypeSpecifier(TypeSpecifier typeSpecifier) {
    typeSpecifiers.push(typeSpecifier);
}

TypeSpecifier AbstractSyntaxTreeBuilderContext::popTypeSpecifier() {
    auto typeSpecifier = typeSpecifiers.top();
    typeSpecifiers.pop();
    return typeSpecifier;
}

void AbstractSyntaxTreeBuilderContext::pushStorageSpecifier(StorageSpecifier storageSpecifier) {
    storageSpecifiers.push(storageSpecifier);
}

StorageSpecifier AbstractSyntaxTreeBuilderContext::popStorageSpecifier() {
    auto storageSpecifier = storageSpecifiers.top();
    storageSpecifiers.pop();
    return storageSpecifier;
}

void AbstractSyntaxTreeBuilderContext::pushTypeQualifier(type::Qualifier typeQualifier) {
    typeQualifiers.push(typeQualifier);
}

type::Qualifier AbstractSyntaxTreeBuilderContext::popTypeQualifier() {
    auto typeQualifier = typeQualifiers.top();
    typeQualifiers.pop();
    return typeQualifier;
}

void AbstractSyntaxTreeBuilderContext::pushConstant(Constant constant) {
    constants.push(constant);
}

Constant AbstractSyntaxTreeBuilderContext::popConstant() {
    auto constant = constants.top();
    constants.pop();
    return constant;
}

void AbstractSyntaxTreeBuilderContext::pushExpression(std::unique_ptr<Expression> expression) {
    expressionStack.push(std::move(expression));
}

std::unique_ptr<Expression> AbstractSyntaxTreeBuilderContext::popExpression() {
    auto expression = std::move(expressionStack.top());
    expressionStack.pop();
    return expression;
}

void AbstractSyntaxTreeBuilderContext::newActualArgumentsList(std::unique_ptr<Expression> argument) {
    std::vector<std::unique_ptr<Expression>> arguments;
    arguments.push_back(std::move(argument));
    actualArgumentLists.push(std::move(arguments));
}

void AbstractSyntaxTreeBuilderContext::addToActualArgumentsList(std::unique_ptr<Expression> argument) {
    actualArgumentLists.top().push_back(std::move(argument));
}

std::vector<std::unique_ptr<Expression>> AbstractSyntaxTreeBuilderContext::popActualArgumentsList() {
    auto arguments = std::move(actualArgumentLists.top());
    actualArgumentLists.pop();
    return arguments;
}

void AbstractSyntaxTreeBuilderContext::newPointer(Pointer pointer) {
    pointerStack.push(std::vector<Pointer> { pointer });
}

void AbstractSyntaxTreeBuilderContext::pointerToPointer(Pointer pointer) {
    pointerStack.top().push_back(pointer);
}

std::vector<Pointer> AbstractSyntaxTreeBuilderContext::popPointers() {
    auto pointers = pointerStack.top();
    pointerStack.pop();
    return pointers;
}

void AbstractSyntaxTreeBuilderContext::pushStatement(std::unique_ptr<AbstractSyntaxTreeNode> statement) {
    statementStack.push(std::move(statement));
}

std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popStatement() {
    auto statement = std::move(statementStack.top());
    statementStack.pop();
    return statement;
}

void AbstractSyntaxTreeBuilderContext::pushDirectDeclarator(std::unique_ptr<DirectDeclarator> declarator) {
    directDeclarators.push(std::move(declarator));
}

std::unique_ptr<DirectDeclarator> AbstractSyntaxTreeBuilderContext::popDirectDeclarator() {
    auto declarator = std::move(directDeclarators.top());
    directDeclarators.pop();
    return declarator;
}

void AbstractSyntaxTreeBuilderContext::pushDeclarator(std::unique_ptr<Declarator> declarator) {
    declarators.push(std::move(declarator));
}

std::unique_ptr<Declarator> AbstractSyntaxTreeBuilderContext::popDeclarator() {
    auto declarator = std::move(declarators.top());
    declarators.pop();
    return declarator;
}

void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarator(std::unique_ptr<InitializedDeclarator> initializedDeclarator) {
    initializedDeclarators.push(std::move(initializedDeclarator));
}

std::unique_ptr<InitializedDeclarator> AbstractSyntaxTreeBuilderContext::popInitializedDeclarator() {
    auto initializedDeclarator = std::move(initializedDeclarators.top());
    initializedDeclarators.pop();
    return initializedDeclarator;
}

void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarators(std::vector<std::unique_ptr<InitializedDeclarator> > declarators) {
    initializedDeclaratorLists.push(std::move(declarators));
}

std::vector<std::unique_ptr<InitializedDeclarator> > AbstractSyntaxTreeBuilderContext::popInitializedDeclarators() {
    auto declarators = std::move(initializedDeclaratorLists.top());
    initializedDeclaratorLists.pop();
    return declarators;
}

void AbstractSyntaxTreeBuilderContext::pushDeclarationList(std::vector<std::unique_ptr<Declaration>> declarationList) {
    declarationLists.push(std::move(declarationList));
}

std::vector<std::unique_ptr<Declaration>> AbstractSyntaxTreeBuilderContext::popDeclarationList() {
    auto declarationList = std::move(declarationLists.top());
    declarationLists.pop();
    return declarationList;
}

void AbstractSyntaxTreeBuilderContext::pushFormalArgument(FormalArgument formalArgument) {
    formalArguments.push(std::move(formalArgument));
}

FormalArgument AbstractSyntaxTreeBuilderContext::popFormalArgument() {
    auto parameter = std::move(formalArguments.top());
    formalArguments.pop();
    return parameter;
}

void AbstractSyntaxTreeBuilderContext::pushFormalArguments(FormalArguments formalArguments) {
    formalArgumentLists.push(std::move(formalArguments));
}

FormalArguments AbstractSyntaxTreeBuilderContext::popFormalArguments() {
    auto formalArguments = std::move(formalArgumentLists.top());
    formalArgumentLists.pop();
    return formalArguments;
}

void AbstractSyntaxTreeBuilderContext::pushArgumentsDeclaration(std::pair<FormalArguments, bool> argumentsDeclaration) {
    argumentsDeclarations.push(std::move(argumentsDeclaration));
}

std::pair<FormalArguments, bool> AbstractSyntaxTreeBuilderContext::popArgumentsDeclaration() {
    auto argumentsDeclaration = std::move(argumentsDeclarations.top());
    argumentsDeclarations.pop();
    return argumentsDeclaration;
}

void AbstractSyntaxTreeBuilderContext::pushDeclarationSpecifiers(DeclarationSpecifiers declarationSpecifiers) {
    declarationSpecifiersStack.push(std::move(declarationSpecifiers));
}

DeclarationSpecifiers AbstractSyntaxTreeBuilderContext::popDeclarationSpecifiers() {
    auto declarationSpecifiers = std::move(declarationSpecifiersStack.top());
    declarationSpecifiersStack.pop();
    return declarationSpecifiers;
}

void AbstractSyntaxTreeBuilderContext::pushDeclaration(std::unique_ptr<Declaration> declaration) {
    declarations.push(std::move(declaration));
}

void AbstractSyntaxTreeBuilderContext::newTypeQualifierList(type::Qualifier qualifier) {
    typeQualifierLists.push( { qualifier });
}

void AbstractSyntaxTreeBuilderContext::addToTypeQualifierList(type::Qualifier qualifier) {
    typeQualifierLists.top().push_back(qualifier);
}

std::vector<type::Qualifier> AbstractSyntaxTreeBuilderContext::popTypeQualifierList() {
    auto qualifiers = typeQualifierLists.top();
    typeQualifierLists.pop();
    return qualifiers;
}

std::unique_ptr<Declaration> AbstractSyntaxTreeBuilderContext::popDeclaration() {
    auto declaration = std::move(declarations.top());
    declarations.pop();
    return declaration;
}

void AbstractSyntaxTreeBuilderContext::newStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {
    std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> statements;
    statements.push_back(std::move(statement));
    statementLists.push(std::move(statements));
}

void AbstractSyntaxTreeBuilderContext::addToStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {
    statementLists.top().push_back(std::move(statement));
}

std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> AbstractSyntaxTreeBuilderContext::popStatementList() {
    auto statements = std::move(statementLists.top());
    statementLists.pop();
    return statements;
}

void AbstractSyntaxTreeBuilderContext::pushExternalDeclaration(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {
    externalDeclarations.push(std::move(externalDeclaration));
}

std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popExternalDeclaration() {
    auto externalDeclaration = std::move(externalDeclarations.top());
    externalDeclarations.pop();
    return externalDeclaration;
}

void AbstractSyntaxTreeBuilderContext::addToTranslationUnit(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {
    translationUnit.push_back(std::move(externalDeclaration));
}

std::vector<std::unique_ptr<AbstractSyntaxTreeNode> > AbstractSyntaxTreeBuilderContext::popTranslationUnit() {
    return std::move(translationUnit);
}

void AbstractSyntaxTreeBuilderContext::newStructMemberList() {
    structMemberLists.push({});
}

void AbstractSyntaxTreeBuilderContext::addStructMember(std::string name, type::Type type) {
    if (structMemberLists.empty()) {
        structMemberLists.push({});
    }
    structMemberLists.top().emplace_back(std::move(name), std::move(type));
}

void AbstractSyntaxTreeBuilderContext::addStructMembersFromList(std::vector<std::pair<std::string, type::Type>> members) {
    for (auto& m : members) {
        structMemberLists.top().push_back(std::move(m));
    }
}

std::vector<std::pair<std::string, type::Type>> AbstractSyntaxTreeBuilderContext::popStructMemberList() {
    auto list = std::move(structMemberLists.top());
    structMemberLists.pop();
    return list;
}

void AbstractSyntaxTreeBuilderContext::pushStructMemberList(std::vector<std::pair<std::string, type::Type>> members) {
    structMemberLists.push(std::move(members));
}


void AbstractSyntaxTreeBuilderContext::newStructDeclaratorNameList() {
    structDeclaratorNameLists.push({});
}

void AbstractSyntaxTreeBuilderContext::addStructDeclaratorName(std::string name) {
    if (structDeclaratorNameLists.empty()) {
        structDeclaratorNameLists.push({});
    }
    structDeclaratorNameLists.top().push_back(std::move(name));
}

std::vector<std::string> AbstractSyntaxTreeBuilderContext::popStructDeclaratorNameList() {
    auto list = std::move(structDeclaratorNameLists.top());
    structDeclaratorNameLists.pop();
    return list;
}


void AbstractSyntaxTreeBuilderContext::defineStructTag(const std::string& tag, type::Type type) {
    if (!tag.empty()) {
        structTags.insert_or_assign(tag, std::move(type));
    }
}

std::optional<type::Type> AbstractSyntaxTreeBuilderContext::lookupStructTag(const std::string& tag) const {
    auto it = structTags.find(tag);
    if (it == structTags.end()) {
        return std::nullopt;
    }
    return it->second;
}

} // namespace ast

1	#include "AbstractSyntaxTreeBuilderContext.h"
2
3	namespace ast {
4
5	AbstractSyntaxTreeBuilderContext::AbstractSyntaxTreeBuilderContext() {	384 ✔
6	}	384 ✔
7
8	void AbstractSyntaxTreeBuilderContext::pushTerminal(TerminalSymbol terminal) {	17,324 ✔
9	terminalSymbols.push(terminal);	17,324 ✔
10	}	17,324 ✔
11
12	TerminalSymbol AbstractSyntaxTreeBuilderContext::popTerminal() {	17,254 ✔
13	auto terminal = terminalSymbols.top();	17,254 ✔
14	terminalSymbols.pop();	17,254 ✔
15	return terminal;	17,254 ✔
16	}
17
18	void AbstractSyntaxTreeBuilderContext::pushTypeSpecifier(TypeSpecifier typeSpecifier) {	1,162 ✔
19	typeSpecifiers.push(typeSpecifier);	1,162 ✔
20	}	1,162 ✔
21
22	TypeSpecifier AbstractSyntaxTreeBuilderContext::popTypeSpecifier() {	1,162 ✔
23	auto typeSpecifier = typeSpecifiers.top();	1,162 ✔
24	typeSpecifiers.pop();	1,162 ✔
25	return typeSpecifier;	1,162 ✔
26	}
27
28	void AbstractSyntaxTreeBuilderContext::pushStorageSpecifier(StorageSpecifier storageSpecifier) {	×
29	storageSpecifiers.push(storageSpecifier);	×
30	}	×
31
32	StorageSpecifier AbstractSyntaxTreeBuilderContext::popStorageSpecifier() {	×
33	auto storageSpecifier = storageSpecifiers.top();	×
34	storageSpecifiers.pop();	×
35	return storageSpecifier;	×
36	}
37
38	void AbstractSyntaxTreeBuilderContext::pushTypeQualifier(type::Qualifier typeQualifier) {	×
39	typeQualifiers.push(typeQualifier);	×
40	}	×
41
42	type::Qualifier AbstractSyntaxTreeBuilderContext::popTypeQualifier() {	×
43	auto typeQualifier = typeQualifiers.top();	×
44	typeQualifiers.pop();	×
45	return typeQualifier;	×
46	}
47
48	void AbstractSyntaxTreeBuilderContext::pushConstant(Constant constant) {	1,260 ✔
49	constants.push(constant);	1,260 ✔
50	}	1,260 ✔
51
52	Constant AbstractSyntaxTreeBuilderContext::popConstant() {	1,260 ✔
53	auto constant = constants.top();	1,260 ✔
54	constants.pop();	1,260 ✔
55	return constant;	1,260 ✔
56	}
57
58	void AbstractSyntaxTreeBuilderContext::pushExpression(std::unique_ptr<Expression> expression) {	7,122 ✔
59	expressionStack.push(std::move(expression));	7,122 ✔
60	}	7,122 ✔
61
62	std::unique_ptr<Expression> AbstractSyntaxTreeBuilderContext::popExpression() {	7,120 ✔
63	auto expression = std::move(expressionStack.top());	7,120 ✔
64	expressionStack.pop();	7,120 ✔
65	return expression;	7,120 ✔
66	}
67
68	void AbstractSyntaxTreeBuilderContext::newActualArgumentsList(std::unique_ptr<Expression> argument) {	888 ✔
69	std::vector<std::unique_ptr<Expression>> arguments;	888 ✔
70	arguments.push_back(std::move(argument));	888 ✔
71	actualArgumentLists.push(std::move(arguments));	888 ✔
72	}	888 ✔
73
74	void AbstractSyntaxTreeBuilderContext::addToActualArgumentsList(std::unique_ptr<Expression> argument) {	1,094 ✔
75	actualArgumentLists.top().push_back(std::move(argument));	1,094 ✔
76	}	1,094 ✔
77
78	std::vector<std::unique_ptr<Expression>> AbstractSyntaxTreeBuilderContext::popActualArgumentsList() {	888 ✔
79	auto arguments = std::move(actualArgumentLists.top());	888 ✔
80	actualArgumentLists.pop();	888 ✔
81	return arguments;	888 ✔
82	}
83
84	void AbstractSyntaxTreeBuilderContext::newPointer(Pointer pointer) {	68 ✔
85	pointerStack.push(std::vector<Pointer> { pointer });	204 ✔
86	}	136 ✔
87
88	void AbstractSyntaxTreeBuilderContext::pointerToPointer(Pointer pointer) {	×
89	pointerStack.top().push_back(pointer);	×
90	}	×
91
92	std::vector<Pointer> AbstractSyntaxTreeBuilderContext::popPointers() {	68 ✔
93	auto pointers = pointerStack.top();	68 ✔
94	pointerStack.pop();	68 ✔
95	return pointers;	68 ✔
96	}
97
98	void AbstractSyntaxTreeBuilderContext::pushStatement(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	2,938 ✔
99	statementStack.push(std::move(statement));	2,938 ✔
100	}	2,938 ✔
101
102	std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popStatement() {	2,938 ✔
103	auto statement = std::move(statementStack.top());	2,938 ✔
104	statementStack.pop();	2,938 ✔
105	return statement;	2,938 ✔
106	}
107
108	void AbstractSyntaxTreeBuilderContext::pushDirectDeclarator(std::unique_ptr<DirectDeclarator> declarator) {	1,752 ✔
109	directDeclarators.push(std::move(declarator));	1,752 ✔
110	}	1,752 ✔
111
112	std::unique_ptr<DirectDeclarator> AbstractSyntaxTreeBuilderContext::popDirectDeclarator() {	1,752 ✔
113	auto declarator = std::move(directDeclarators.top());	1,752 ✔
114	directDeclarators.pop();	1,752 ✔
115	return declarator;	1,752 ✔
116	}
117
118	void AbstractSyntaxTreeBuilderContext::pushDeclarator(std::unique_ptr<Declarator> declarator) {	1,276 ✔
119	declarators.push(std::move(declarator));	1,276 ✔
120	}	1,276 ✔
121
122	std::unique_ptr<Declarator> AbstractSyntaxTreeBuilderContext::popDeclarator() {	1,274 ✔
123	auto declarator = std::move(declarators.top());	1,274 ✔
124	declarators.pop();	1,274 ✔
125	return declarator;	1,274 ✔
126	}
127
128	void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarator(std::unique_ptr<InitializedDeclarator> initializedDeclarator) {	620 ✔
129	initializedDeclarators.push(std::move(initializedDeclarator));	620 ✔
130	}	620 ✔
131
132	std::unique_ptr<InitializedDeclarator> AbstractSyntaxTreeBuilderContext::popInitializedDeclarator() {	620 ✔
133	auto initializedDeclarator = std::move(initializedDeclarators.top());	620 ✔
134	initializedDeclarators.pop();	620 ✔
135	return initializedDeclarator;	620 ✔
136	}
137
138	void AbstractSyntaxTreeBuilderContext::pushInitializedDeclarators(std::vector<std::unique_ptr<InitializedDeclarator> > declarators) {	620 ✔
139	initializedDeclaratorLists.push(std::move(declarators));	620 ✔
140	}	620 ✔
141
142	std::vector<std::unique_ptr<InitializedDeclarator> > AbstractSyntaxTreeBuilderContext::popInitializedDeclarators() {	620 ✔
143	auto declarators = std::move(initializedDeclaratorLists.top());	620 ✔
144	initializedDeclaratorLists.pop();	620 ✔
145	return declarators;	620 ✔
146	}
147
148	void AbstractSyntaxTreeBuilderContext::pushDeclarationList(std::vector<std::unique_ptr<Declaration>> declarationList) {	382 ✔
149	declarationLists.push(std::move(declarationList));	382 ✔
150	}	382 ✔
151
152	std::vector<std::unique_ptr<Declaration>> AbstractSyntaxTreeBuilderContext::popDeclarationList() {	382 ✔
153	auto declarationList = std::move(declarationLists.top());	382 ✔
154	declarationLists.pop();	382 ✔
155	return declarationList;	382 ✔
156	}
157
158	void AbstractSyntaxTreeBuilderContext::pushFormalArgument(FormalArgument formalArgument) {	170 ✔
159	formalArguments.push(std::move(formalArgument));	170 ✔
160	}	170 ✔
161
162	FormalArgument AbstractSyntaxTreeBuilderContext::popFormalArgument() {	170 ✔
163	auto parameter = std::move(formalArguments.top());	170 ✔
164	formalArguments.pop();	170 ✔
165	return parameter;	170 ✔
166	}
167
168	void AbstractSyntaxTreeBuilderContext::pushFormalArguments(FormalArguments formalArguments) {	170 ✔
169	formalArgumentLists.push(std::move(formalArguments));	170 ✔
170	}	170 ✔
171
172	FormalArguments AbstractSyntaxTreeBuilderContext::popFormalArguments() {	170 ✔
173	auto formalArguments = std::move(formalArgumentLists.top());	170 ✔
174	formalArgumentLists.pop();	170 ✔
175	return formalArguments;	170 ✔
176	}
177
178	void AbstractSyntaxTreeBuilderContext::pushArgumentsDeclaration(std::pair<FormalArguments, bool> argumentsDeclaration) {	70 ✔
179	argumentsDeclarations.push(std::move(argumentsDeclaration));	70 ✔
180	}	70 ✔
181
182	std::pair<FormalArguments, bool> AbstractSyntaxTreeBuilderContext::popArgumentsDeclaration() {	70 ✔
183	auto argumentsDeclaration = std::move(argumentsDeclarations.top());	70 ✔
184	argumentsDeclarations.pop();	70 ✔
185	return argumentsDeclaration;	70 ✔
186	}
187
188	void AbstractSyntaxTreeBuilderContext::pushDeclarationSpecifiers(DeclarationSpecifiers declarationSpecifiers) {	1,150 ✔
189	declarationSpecifiersStack.push(std::move(declarationSpecifiers));	1,150 ✔
190	}	1,150 ✔
191
192	DeclarationSpecifiers AbstractSyntaxTreeBuilderContext::popDeclarationSpecifiers() {	1,148 ✔
193	auto declarationSpecifiers = std::move(declarationSpecifiersStack.top());	1,148 ✔
194	declarationSpecifiersStack.pop();	1,148 ✔
195	return declarationSpecifiers;	1,148 ✔
196	}
197
198	void AbstractSyntaxTreeBuilderContext::pushDeclaration(std::unique_ptr<Declaration> declaration) {	504 ✔
199	declarations.push(std::move(declaration));	504 ✔
200	}	504 ✔
201
202	void AbstractSyntaxTreeBuilderContext::newTypeQualifierList(type::Qualifier qualifier) {	×
203	typeQualifierLists.push( { qualifier });	×
204	}	×
205
206	void AbstractSyntaxTreeBuilderContext::addToTypeQualifierList(type::Qualifier qualifier) {	×
207	typeQualifierLists.top().push_back(qualifier);	×
208	}	×
209
210	std::vector<type::Qualifier> AbstractSyntaxTreeBuilderContext::popTypeQualifierList() {	×
211	auto qualifiers = typeQualifierLists.top();	×
212	typeQualifierLists.pop();	×
213	return qualifiers;	×
214	}
215
216	std::unique_ptr<Declaration> AbstractSyntaxTreeBuilderContext::popDeclaration() {	504 ✔
217	auto declaration = std::move(declarations.top());	504 ✔
218	declarations.pop();	504 ✔
219	return declaration;	504 ✔
220	}
221
222	void AbstractSyntaxTreeBuilderContext::newStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	574 ✔
223	std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> statements;	574 ✔
224	statements.push_back(std::move(statement));	574 ✔
225	statementLists.push(std::move(statements));	574 ✔
226	}	574 ✔
227
228	void AbstractSyntaxTreeBuilderContext::addToStatementList(std::unique_ptr<AbstractSyntaxTreeNode> statement) {	1,314 ✔
229	statementLists.top().push_back(std::move(statement));	1,314 ✔
230	}	1,314 ✔
231
232	std::vector<std::unique_ptr<AbstractSyntaxTreeNode>> AbstractSyntaxTreeBuilderContext::popStatementList() {	574 ✔
233	auto statements = std::move(statementLists.top());	574 ✔
234	statementLists.pop();	574 ✔
235	return statements;	574 ✔
236	}
237
238	void AbstractSyntaxTreeBuilderContext::pushExternalDeclaration(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {	596 ✔
239	externalDeclarations.push(std::move(externalDeclaration));	596 ✔
240	}	596 ✔
241
242	std::unique_ptr<AbstractSyntaxTreeNode> AbstractSyntaxTreeBuilderContext::popExternalDeclaration() {	596 ✔
243	auto externalDeclaration = std::move(externalDeclarations.top());	596 ✔
244	externalDeclarations.pop();	596 ✔
245	return externalDeclaration;	596 ✔
246	}
247
248	void AbstractSyntaxTreeBuilderContext::addToTranslationUnit(std::unique_ptr<AbstractSyntaxTreeNode> externalDeclaration) {	596 ✔
249	translationUnit.push_back(std::move(externalDeclaration));	596 ✔
250	}	596 ✔
251
252	std::vector<std::unique_ptr<AbstractSyntaxTreeNode> > AbstractSyntaxTreeBuilderContext::popTranslationUnit() {	382 ✔
253	return std::move(translationUnit);	382 ✔
254	}
255
NEW 256	void AbstractSyntaxTreeBuilderContext::newStructMemberList() {	×
NEW 257	structMemberLists.push({});	×
NEW 258	}	×
259
260	void AbstractSyntaxTreeBuilderContext::addStructMember(std::string name, type::Type type) {	12 ✔
261	if (structMemberLists.empty()) {	12 ✔
262	structMemberLists.push({});	6 ✔
263	}
264	structMemberLists.top().emplace_back(std::move(name), std::move(type));	12 ✔
265	}	12 ✔
266
NEW 267	void AbstractSyntaxTreeBuilderContext::addStructMembersFromList(std::vector<std::pair<std::string, type::Type>> members) {	×
NEW 268	for (auto& m : members) {	×
NEW 269	structMemberLists.top().push_back(std::move(m));	×
270	}
NEW 271	}	×
272
273	std::vector<std::pair<std::string, type::Type>> AbstractSyntaxTreeBuilderContext::popStructMemberList() {	6 ✔
274	auto list = std::move(structMemberLists.top());	6 ✔
275	structMemberLists.pop();	6 ✔
276	return list;	6 ✔
277	}
278
NEW 279	void AbstractSyntaxTreeBuilderContext::pushStructMemberList(std::vector<std::pair<std::string, type::Type>> members) {	×
NEW 280	structMemberLists.push(std::move(members));	×
NEW 281	}	×
282
283
NEW 284	void AbstractSyntaxTreeBuilderContext::newStructDeclaratorNameList() {	×
NEW 285	structDeclaratorNameLists.push({});	×
NEW 286	}	×
287
288	void AbstractSyntaxTreeBuilderContext::addStructDeclaratorName(std::string name) {	12 ✔
289	if (structDeclaratorNameLists.empty()) {	12 ✔
290	structDeclaratorNameLists.push({});	12 ✔
291	}
292	structDeclaratorNameLists.top().push_back(std::move(name));	12 ✔
293	}	12 ✔
294
295	std::vector<std::string> AbstractSyntaxTreeBuilderContext::popStructDeclaratorNameList() {	12 ✔
296	auto list = std::move(structDeclaratorNameLists.top());	12 ✔
297	structDeclaratorNameLists.pop();	12 ✔
298	return list;	12 ✔
299	}
300
301
302	void AbstractSyntaxTreeBuilderContext::defineStructTag(const std::string& tag, type::Type type) {	6 ✔
303	if (!tag.empty()) {	6 ✔
304	structTags.insert_or_assign(tag, std::move(type));	6 ✔
305	}
306	}	6 ✔
307
308	std::optional<type::Type> AbstractSyntaxTreeBuilderContext::lookupStructTag(const std::string& tag) const {	8 ✔
309	auto it = structTags.find(tag);	8 ✔
310	if (it == structTags.end()) {	8 ✔
NEW 311	return std::nullopt;	×
312	}
313	return it->second;	8 ✔
314	}
315
316	} // namespace ast

rieske / trans / 28460339749

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous