29861581689

Committed 21 Jul 2026 07:27PM UTC coverage: 91.142% (+0.4%) from 90.735%

Build # 29861581689

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #52 from rieske/tests/fuzz

Fuzz test and fix issues

Coverage Stats

86 of 110 new or added lines in 9 files covered. (78.18%)

5371 of 5893 relevant lines covered (91.14%)

368978.84 hits per line

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

78.79

/src/ast/FunctionDeclarator.cpp

#include "FunctionDeclarator.h"

#include "AbstractSyntaxTreeVisitor.h"

namespace ast {

FunctionDeclarator::FunctionDeclarator(std::unique_ptr<DirectDeclarator> declarator) :
        DirectDeclarator(declarator->getName(), declarator->getContext()),
        nested { std::move(declarator) }
{
}

FunctionDeclarator::FunctionDeclarator(std::unique_ptr<DirectDeclarator> declarator, FormalArguments formalArguments) :
        DirectDeclarator(declarator->getName(), declarator->getContext()),
        nested { std::move(declarator) },
        formalArguments { std::move(formalArguments) }
{
}

void FunctionDeclarator::accept(AbstractSyntaxTreeVisitor& visitor) {
    visitor.visit(*this);
}

void FunctionDeclarator::visitFormalArguments(AbstractSyntaxTreeVisitor& visitor) {
    for (auto& argument : formalArguments) {
        argument.accept(visitor);
    }
}

void FunctionDeclarator::visitNestedDeclarator(AbstractSyntaxTreeVisitor& visitor) {
    if (nested) {
        nested->accept(visitor);
    }
}

const FormalArguments& ast::FunctionDeclarator::getFormalArguments() const {
    return formalArguments;
}

type::Type FunctionDeclarator::getFundamentalType(std::vector<Pointer> indirection, const type::Type& returnType) {
    // Outer pointers apply to the return type: `int *f()` is a function returning int*.
    type::Type actualReturn = returnType;
    for (Pointer pointer : indirection) {
        actualReturn = type::pointer(actualReturn, pointer.getQualifiers());
    }
    std::vector<type::Type> argumentTypes;
    for (const auto& argument : formalArguments) {
        argumentTypes.push_back(argument.getType());
    }
    type::Type functionType = type::function(actualReturn, argumentTypes);
    // Nested declarator may wrap further (e.g. `int (*f)()` → pointer to function).
    return nested->getFundamentalType({}, functionType);
}

} // namespace ast


1	#include "FunctionDeclarator.h"
2
3	#include "AbstractSyntaxTreeVisitor.h"
4
5	namespace ast {
6
7	FunctionDeclarator::FunctionDeclarator(std::unique_ptr<DirectDeclarator> declarator) :	444✔
8	DirectDeclarator(declarator->getName(), declarator->getContext()),	888✔
9	nested { std::move(declarator) }	1,332✔
10	{
11	}	444✔
12
13	FunctionDeclarator::FunctionDeclarator(std::unique_ptr<DirectDeclarator> declarator, FormalArguments formalArguments) :	80✔
14	DirectDeclarator(declarator->getName(), declarator->getContext()),	160✔
15	nested { std::move(declarator) },	80✔
16	formalArguments { std::move(formalArguments) }	320✔
17	{
18	}	80✔
19
20	void FunctionDeclarator::accept(AbstractSyntaxTreeVisitor& visitor) {	1,534✔
21	visitor.visit(*this);	1,534✔
22	}	1,534✔
23
24	void FunctionDeclarator::visitFormalArguments(AbstractSyntaxTreeVisitor& visitor) {	1,534✔
25	for (auto& argument : formalArguments) {	2,076✔
26	argument.accept(visitor);	542✔
27	}
28	}	1,534✔
29
NEW 30	void FunctionDeclarator::visitNestedDeclarator(AbstractSyntaxTreeVisitor& visitor) {	×
NEW 31	if (nested) {	×
NEW 32	nested->accept(visitor);	×
33	}
NEW 34	}	×
35
36	const FormalArguments& ast::FunctionDeclarator::getFormalArguments() const {	522✔
37	return formalArguments;	522✔
38	}
39
40	type::Type FunctionDeclarator::getFundamentalType(std::vector<Pointer> indirection, const type::Type& returnType) {	2✔
41	// Outer pointers apply to the return type: `int f()` is a function returning int.
42	type::Type actualReturn = returnType;	2✔
43	for (Pointer pointer : indirection) {	2✔
NEW 44	actualReturn = type::pointer(actualReturn, pointer.getQualifiers());	×
NEW 45	}	×
46	std::vector<type::Type> argumentTypes;	2✔
47	for (const auto& argument : formalArguments) {	2✔
48	argumentTypes.push_back(argument.getType());	×
49	}
50	type::Type functionType = type::function(actualReturn, argumentTypes);	2✔
51	// Nested declarator may wrap further (e.g. `int (*f)()` → pointer to function).
52	return nested->getFundamentalType({}, functionType);	4✔
53	}	2✔
54
55	} // namespace ast
56

rieske / trans / 29861581689

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