GCC Code Coverage Report

Directory: ../
File: src/typechecker/FunctionManager.cpp
Date: 2025-11-03 22:22:45
Coverage Exec Excl Total
Lines: 97.6% 248 0 254
Functions: 100.0% 18 0 18
Branches: 64.2% 294 0 458
Line Branch Exec Source
1 // Copyright (c) 2021-2025 ChilliBits. All rights reserved.
2
3 #include "FunctionManager.h"
4
5 #include <ast/ASTNodes.h>
6 #include <exception/SemanticError.h>
7 #include <model/GenericType.h>
8 #include <symboltablebuilder/Scope.h>
9 #include <symboltablebuilder/SymbolTableBuilder.h>
10 #include <typechecker/TypeChecker.h>
11 #include <typechecker/TypeMatcher.h>
12 #include <util/CodeLoc.h>
13 #include <util/CustomHashFunctions.h>
14
15 namespace spice::compiler {
16
17 // Static member initialization
18 std::unordered_map<uint64_t, Function *> FunctionManager::lookupCache = {};
19 size_t FunctionManager::lookupCacheHits = 0;
20 size_t FunctionManager::lookupCacheMisses = 0;
21
22 12919 Function *FunctionManager::insert(Scope *insertScope, const Function &baseFunction, std::vector<Function *> *nodeFunctionList) {
23 // Open a new manifestation list for the function definition
24
3/6
✓ Branch 2 → 3 taken 12919 times.
✗ Branch 2 → 43 not taken.
✓ Branch 3 → 4 taken 12919 times.
✗ Branch 3 → 40 not taken.
✓ Branch 4 → 5 taken 12919 times.
✗ Branch 4 → 38 not taken.
 12919 const std::string fctId = baseFunction.name + ":" + baseFunction.declNode->codeLoc.toPrettyLineAndColumn();
25
2/4
✓ Branch 8 → 9 taken 12919 times.
✗ Branch 8 → 46 not taken.
✓ Branch 9 → 10 taken 12919 times.
✗ Branch 9 → 44 not taken.
 12919 insertScope->functions.insert({fctId, FunctionManifestationList()});
26
27 // Collect substantiations
28 12919 std::vector<Function> manifestations;
29
1/2
✓ Branch 12 → 13 taken 12919 times.
✗ Branch 12 → 51 not taken.
 12919 substantiateOptionalParams(baseFunction, manifestations);
30
1/2
✗ Branch 14 → 15 not taken.
✓ Branch 14 → 16 taken 12919 times.
 12919 assert(!manifestations.empty());
31
32 // Save substantiations in declaration node
33 12919 Function *manifestationPtr = nullptr;
34
2/2
✓ Branch 26 → 18 taken 13789 times.
✓ Branch 26 → 27 taken 12917 times.
 26706 for (const Function &manifestation : manifestations) {
35
2/2
✓ Branch 19 → 20 taken 13787 times.
✓ Branch 19 → 50 taken 2 times.
 13789 manifestationPtr = insertSubstantiation(insertScope, manifestation, baseFunction.declNode);
36
1/2
✗ Branch 20 → 21 not taken.
✓ Branch 20 → 22 taken 13787 times.
 13787 assert(manifestationPtr != nullptr);
37
1/2
✓ Branch 22 → 23 taken 13787 times.
✗ Branch 22 → 24 not taken.
 13787 if (nodeFunctionList)
38
1/2
✓ Branch 23 → 24 taken 13787 times.
✗ Branch 23 → 50 not taken.
 13787 nodeFunctionList->push_back(manifestationPtr);
39 }
40
41
1/2
✗ Branch 27 → 28 not taken.
✓ Branch 27 → 29 taken 12917 times.
 12917 if (!nodeFunctionList)
42 ✗ return manifestationPtr;
43
44
1/2
✗ Branch 30 → 31 not taken.
✓ Branch 30 → 32 taken 12917 times.
 12917 assert(!nodeFunctionList->empty());
45 12917 return nodeFunctionList->front();
46 12921 }
47
48 /**
49 * Create definite functions from ambiguous ones, in regard to optional arguments.
50 *
51 * Example:
52 * int testFunc(string, int?, double?)
53 * gets
54 * int testFunc(string)
55 * int testFunc(string, int)
56 * int testFunc(string, int, double)
57 *
58 * This method also accepts functions, that are already definite, but does nothing to them.
59 *
60 * @param baseFunction Ambiguous base function
61 * @param manifestations Vector to store the definite manifestations
62 * @return True, if there were optional arguments found
63 */
64 12919 void FunctionManager::substantiateOptionalParams(const Function &baseFunction, std::vector<Function> &manifestations) {
65 // Handle the case of no parameters -> simply return the base function
66
2/2
✓ Branch 3 → 4 taken 3113 times.
✓ Branch 3 → 6 taken 9806 times.
 12919 if (baseFunction.paramList.empty()) {
67
1/2
✓ Branch 4 → 5 taken 3113 times.
✗ Branch 4 → 39 not taken.
 3113 manifestations.push_back(baseFunction);
68 3113 return;
69 }
70
71 9806 ParamList currentFunctionParamTypes;
72
1/2
✓ Branch 7 → 8 taken 9806 times.
✗ Branch 7 → 37 not taken.
 9806 currentFunctionParamTypes.reserve(baseFunction.paramList.size());
73 9806 bool metFirstOptionalParam = false;
74
1/2
✓ Branch 8 → 9 taken 9806 times.
✗ Branch 8 → 37 not taken.
 9806 Function manifestation = baseFunction;
75
76 // Loop over all parameters
77
2/2
✓ Branch 24 → 11 taken 15163 times.
✓ Branch 24 → 25 taken 9806 times.
 24969 for (const auto &[qualType, isOptional] : baseFunction.paramList) {
78 // Check if we have a mandatory parameter
79
2/2
✓ Branch 12 → 13 taken 14293 times.
✓ Branch 12 → 15 taken 870 times.
 15163 if (!isOptional) {
80
1/2
✓ Branch 13 → 14 taken 14293 times.
✗ Branch 13 → 32 not taken.
 14293 currentFunctionParamTypes.push_back({qualType, /*optional=*/false});
81 14293 continue;
82 }
83
84 // Add substantiation without the optional parameter
85
2/2
✓ Branch 15 → 16 taken 864 times.
✓ Branch 15 → 19 taken 6 times.
 870 if (!metFirstOptionalParam) {
86
1/2
✓ Branch 16 → 17 taken 864 times.
✗ Branch 16 → 34 not taken.
 864 manifestation.paramList = currentFunctionParamTypes;
87
1/2
✓ Branch 17 → 18 taken 864 times.
✗ Branch 17 → 34 not taken.
 864 manifestations.push_back(manifestation);
88 // Now we cannot accept mandatory parameters anymore
89 864 metFirstOptionalParam = true;
90 }
91
92 // Add substantiation with the optional parameter
93
1/2
✓ Branch 19 → 20 taken 870 times.
✗ Branch 19 → 33 not taken.
 870 currentFunctionParamTypes.push_back({qualType, /*optional=*/false});
94
1/2
✓ Branch 20 → 21 taken 870 times.
✗ Branch 20 → 34 not taken.
 870 manifestation.paramList = currentFunctionParamTypes;
95
1/2
✓ Branch 21 → 22 taken 870 times.
✗ Branch 21 → 34 not taken.
 870 manifestations.push_back(manifestation);
96 }
97
98 // Ensure at least once manifestation
99
2/2
✓ Branch 26 → 27 taken 8942 times.
✓ Branch 26 → 28 taken 864 times.
 9806 if (manifestations.empty())
100
1/2
✓ Branch 27 → 28 taken 8942 times.
✗ Branch 27 → 35 not taken.
 8942 manifestations.push_back(baseFunction);
101 9806 }
102
103 3 Function FunctionManager::createMainFunction(SymbolTableEntry *entry, const QualTypeList &paramTypes, ASTNode *declNode) {
104 3 ParamList paramList;
105
2/2
✓ Branch 8 → 4 taken 2 times.
✓ Branch 8 → 9 taken 3 times.
 5 for (const QualType &paramType : paramTypes)
106
1/2
✓ Branch 5 → 6 taken 2 times.
✗ Branch 5 → 24 not taken.
 2 paramList.push_back({paramType, false});
107
4/8
✓ Branch 11 → 12 taken 3 times.
✗ Branch 11 → 31 not taken.
✓ Branch 12 → 13 taken 3 times.
✗ Branch 12 → 28 not taken.
✓ Branch 13 → 14 taken 3 times.
✗ Branch 13 → 27 not taken.
✓ Branch 14 → 15 taken 3 times.
✗ Branch 14 → 26 not taken.
 6 return {MAIN_FUNCTION_NAME, entry, QualType(TY_DYN), QualType(TY_INT), paramList, {}, declNode};
108 3 }
109
110 16002 Function *FunctionManager::insertSubstantiation(Scope *insertScope, const Function &newManifestation, const ASTNode *declNode) {
111
2/4
✓ Branch 2 → 3 taken 16002 times.
✗ Branch 2 → 65 not taken.
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 16002 times.
 16002 assert(newManifestation.hasSubstantiatedParams());
112
113
1/2
✓ Branch 5 → 6 taken 16002 times.
✗ Branch 5 → 65 not taken.
 16002 const std::string signature = newManifestation.getSignature(true, false);
114
115 // Check if the function exists already
116
5/8
✓ Branch 6 → 7 taken 16002 times.
✗ Branch 6 → 54 not taken.
✓ Branch 7 → 8 taken 16002 times.
✗ Branch 7 → 54 not taken.
✓ Branch 8 → 9 taken 16002 times.
✗ Branch 8 → 54 not taken.
✓ Branch 28 → 10 taken 222043 times.
✓ Branch 28 → 29 taken 15999 times.
 238042 for (const auto &manifestations : insertScope->functions | std::views::values) {
117
3/4
✓ Branch 11 → 12 taken 222043 times.
✗ Branch 11 → 54 not taken.
✓ Branch 12 → 13 taken 3 times.
✓ Branch 12 → 26 taken 222040 times.
 222043 if (manifestations.contains(signature)) {
118
2/2
✓ Branch 16 → 17 taken 1 time.
✓ Branch 16 → 18 taken 2 times.
 3 const SemanticErrorType errorType = newManifestation.isFunction() ? FUNCTION_DECLARED_TWICE : PROCEDURE_DECLARED_TWICE;
119
3/6
✓ Branch 20 → 21 taken 3 times.
✗ Branch 20 → 49 not taken.
✓ Branch 21 → 22 taken 3 times.
✗ Branch 21 → 47 not taken.
✓ Branch 22 → 23 taken 3 times.
✗ Branch 22 → 45 not taken.
 3 throw SemanticError(declNode, errorType, "'" + signature + "' is declared twice");
120 }
121 }
122
123 // Retrieve the matching manifestation list of the scope
124
3/6
✓ Branch 29 → 30 taken 15999 times.
✗ Branch 29 → 60 not taken.
✓ Branch 30 → 31 taken 15999 times.
✗ Branch 30 → 57 not taken.
✓ Branch 31 → 32 taken 15999 times.
✗ Branch 31 → 55 not taken.
 15999 const std::string fctId = newManifestation.name + ":" + declNode->codeLoc.toPrettyLineAndColumn();
125
2/4
✓ Branch 34 → 35 taken 15999 times.
✗ Branch 34 → 61 not taken.
✗ Branch 35 → 36 not taken.
✓ Branch 35 → 37 taken 15999 times.
 15999 assert(insertScope->functions.contains(fctId));
126
1/2
✓ Branch 37 → 38 taken 15999 times.
✗ Branch 37 → 61 not taken.
 15999 FunctionManifestationList &manifestationList = insertScope->functions.at(fctId);
127
128 // Add substantiated function
129
1/2
✓ Branch 38 → 39 taken 15999 times.
✗ Branch 38 → 61 not taken.
 15999 manifestationList.emplace(signature, newManifestation);
130
1/2
✓ Branch 39 → 40 taken 15999 times.
✗ Branch 39 → 61 not taken.
 31998 return &manifestationList.at(signature);
131 16002 }
132
133 /**
134 * Checks if a function exists by matching it, but not setting it to used
135 *
136 * @param matchScope Scope to match against
137 * @param reqName Function name requirement
138 * @param reqThisType This type requirement
139 * @param reqArgs Argument requirement
140 * @param strictQualifierMatching Match argument and this type qualifiers strictly
141 * @return Found function or nullptr
142 */
143 11954 const Function *FunctionManager::lookup(Scope *matchScope, const std::string &reqName, const QualType &reqThisType,
144 const ArgList &reqArgs, bool strictQualifierMatching) {
145
2/4
✓ Branch 2 → 3 taken 11954 times.
✗ Branch 2 → 66 not taken.
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 11954 times.
 11954 assert(reqThisType.isOneOf({TY_DYN, TY_STRUCT}));
146
147 // Do cache lookup
148
1/2
✓ Branch 6 → 7 taken 11954 times.
✗ Branch 6 → 67 not taken.
 11954 const uint64_t cacheKey = getCacheKey(matchScope, reqName, reqThisType, reqArgs, {});
149
3/4
✓ Branch 8 → 9 taken 11954 times.
✗ Branch 8 → 83 not taken.
✓ Branch 9 → 10 taken 3316 times.
✓ Branch 9 → 12 taken 8638 times.
 11954 if (lookupCache.contains(cacheKey)) {
150 3316 lookupCacheHits++;
151
1/2
✓ Branch 10 → 11 taken 3316 times.
✗ Branch 10 → 83 not taken.
 3316 return lookupCache.at(cacheKey);
152 }
153 8638 lookupCacheMisses++;
154
155 2554 const auto pred = [&](const Arg &arg) { return arg.first.hasAnyGenericParts(); };
156
5/8
✓ Branch 12 → 13 taken 8638 times.
✗ Branch 12 → 83 not taken.
✓ Branch 13 → 14 taken 8398 times.
✓ Branch 13 → 17 taken 240 times.
✓ Branch 14 → 15 taken 8398 times.
✗ Branch 14 → 83 not taken.
✓ Branch 15 → 16 taken 8398 times.
✗ Branch 15 → 17 not taken.
 8638 const bool requestedFullySubstantiated = !reqThisType.hasAnyGenericParts() && std::ranges::none_of(reqArgs, pred);
157
158 // Copy the registry to prevent iterating over items, that are created within the loop
159
1/2
✓ Branch 18 → 19 taken 8638 times.
✗ Branch 18 → 83 not taken.
 8638 const FunctionRegistry functionRegistry = matchScope->functions;
160 // Loop over function registry to find functions, that match the requirements of the call
161 8638 std::vector<const Function *> matches;
162
2/2
✓ Branch 55 → 21 taken 71143 times.
✓ Branch 55 → 56 taken 8638 times.
 79781 for (const auto &[defCodeLocStr, m] : functionRegistry) {
163 // Copy the manifestation list to prevent iterating over items, that are created within the loop
164
1/2
✓ Branch 24 → 25 taken 71143 times.
✗ Branch 24 → 77 not taken.
 71143 const FunctionManifestationList manifestations = m;
165
2/2
✓ Branch 51 → 27 taken 80789 times.
✓ Branch 51 → 52 taken 25940 times.
 106729 for (const auto &[signature, presetFunction] : manifestations) {
166
2/4
✓ Branch 30 → 31 taken 80789 times.
✗ Branch 30 → 73 not taken.
✗ Branch 31 → 32 not taken.
✓ Branch 31 → 33 taken 80789 times.
 80789 assert(presetFunction.hasSubstantiatedParams()); // No optional params are allowed at this point
167
168 // - search for concrete fct: Only match against fully substantiated versions to prevent double matching of a function
169 // - search for generic fct: Only match against generic preset functions
170
3/4
✓ Branch 33 → 34 taken 80789 times.
✗ Branch 33 → 73 not taken.
✓ Branch 34 → 35 taken 29595 times.
✓ Branch 34 → 36 taken 51194 times.
 80789 if (presetFunction.isFullySubstantiated() != requestedFullySubstantiated)
171 35586 continue;
172
173 // Copy the function to be able to substantiate types
174
1/2
✓ Branch 36 → 37 taken 51194 times.
✗ Branch 36 → 73 not taken.
 51194 Function candidate = presetFunction;
175
176 // Create empty type mapping
177 51194 TypeMapping &typeMapping = candidate.typeMapping;
178
179 51194 bool forceSubstantiation = false;
180
1/2
✓ Branch 37 → 38 taken 51194 times.
✗ Branch 37 → 71 not taken.
 51194 const MatchResult matchResult = matchManifestation(candidate, matchScope, reqName, reqThisType, reqArgs, typeMapping,
181 strictQualifierMatching, forceSubstantiation, nullptr);
182
2/2
✓ Branch 38 → 39 taken 43918 times.
✓ Branch 38 → 40 taken 7276 times.
 51194 if (matchResult == MatchResult::SKIP_FUNCTION)
183 43918 break; // Leave the whole function
184
2/2
✓ Branch 40 → 41 taken 5991 times.
✓ Branch 40 → 42 taken 1285 times.
 7276 if (matchResult == MatchResult::SKIP_MANIFESTATION)
185 5991 continue; // Leave this manifestation and try the next one
186
187 // Add to matches
188
3/6
✓ Branch 42 → 43 taken 1285 times.
✗ Branch 42 → 70 not taken.
✓ Branch 43 → 44 taken 1285 times.
✗ Branch 43 → 70 not taken.
✓ Branch 44 → 45 taken 1285 times.
✗ Branch 44 → 70 not taken.
 1285 matches.push_back(&matchScope->functions.at(defCodeLocStr).at(signature));
189
190 1285 break; // Leave the whole manifestation list to not double-match the manifestation
191
2/2
✓ Branch 47 → 48 taken 5991 times.
✓ Branch 47 → 49 taken 45203 times.
 51194 }
192 71143 }
193
194 // Return the very match or a nullptr
195
2/2
✓ Branch 57 → 58 taken 1285 times.
✓ Branch 57 → 60 taken 7353 times.
 8638 return !matches.empty() ? matches.front() : nullptr;
196 8638 }
197
198 /**
199 * Check if there is a function in the scope, fulfilling all given requirements and if found, return it.
200 * If more than one function matches the requirement, an error gets thrown.
201 *
202 * @param matchScope Scope to match against
203 * @param reqName Function name requirement
204 * @param reqThisType This type requirement
205 * @param reqArgs Argument requirement
206 * @param templateTypeHints Template type requirement
207 * @param strictQualifierMatching Match argument and this type qualifiers strictly
208 * @param callNode Call AST node for printing error messages
209 * @return Matched function or nullptr
210 */
211 71812 Function *FunctionManager::match(Scope *matchScope, const std::string &reqName, const QualType &reqThisType,
212 const ArgList &reqArgs, const QualTypeList &templateTypeHints, bool strictQualifierMatching,
213 const ASTNode *callNode) {
214
2/4
✓ Branch 2 → 3 taken 71812 times.
✗ Branch 2 → 152 not taken.
✗ Branch 3 → 4 not taken.
✓ Branch 3 → 5 taken 71812 times.
 71812 assert(reqThisType.isOneOf({TY_DYN, TY_STRUCT, TY_INTERFACE}));
215
216 // Do cache lookup
217
1/2
✓ Branch 5 → 6 taken 71812 times.
✗ Branch 5 → 187 not taken.
 71812 const uint64_t cacheKey = getCacheKey(matchScope, reqName, reqThisType, reqArgs, templateTypeHints);
218
3/4
✓ Branch 6 → 7 taken 71812 times.
✗ Branch 6 → 187 not taken.
✓ Branch 7 → 8 taken 11656 times.
✓ Branch 7 → 10 taken 60156 times.
 71812 if (lookupCache.contains(cacheKey)) {
219 11656 lookupCacheHits++;
220
1/2
✓ Branch 8 → 9 taken 11656 times.
✗ Branch 8 → 187 not taken.
 11656 return lookupCache.at(cacheKey);
221 }
222 60156 lookupCacheMisses++;
223
224 // Copy the registry to prevent iterating over items, that are created within the loop
225
1/2
✓ Branch 10 → 11 taken 60156 times.
✗ Branch 10 → 187 not taken.
 60156 FunctionRegistry functionRegistry = matchScope->functions;
226 // Loop over function registry to find functions, that match the requirements of the call
227 60156 std::vector<Function *> matches;
228
2/2
✓ Branch 137 → 13 taken 732572 times.
✓ Branch 137 → 138 taken 60154 times.
 792726 for (const auto &[fctId, m] : functionRegistry) {
229 // Copy the manifestation list to prevent iterating over items, that are created within the loop
230
1/2
✓ Branch 16 → 17 taken 732572 times.
✗ Branch 16 → 181 not taken.
 732572 const FunctionManifestationList manifestations = m;
231
2/2
✓ Branch 133 → 19 taken 742144 times.
✓ Branch 133 → 134 taken 44307 times.
 786451 for (const auto &[signature, presetFunction] : manifestations) {
232
2/4
✓ Branch 22 → 23 taken 742144 times.
✗ Branch 22 → 177 not taken.
✗ Branch 23 → 24 not taken.
✓ Branch 23 → 25 taken 742144 times.
 742144 assert(presetFunction.hasSubstantiatedParams()); // No optional params are allowed at this point
233
234 // Skip generic substantiations to prevent double matching of a function
235
3/4
✓ Branch 25 → 26 taken 742144 times.
✗ Branch 25 → 177 not taken.
✓ Branch 26 → 27 taken 7571 times.
✓ Branch 26 → 28 taken 734573 times.
 742144 if (presetFunction.isGenericSubstantiation())
236 53879 continue;
237
238 // Copy the function to be able to substantiate types
239
1/2
✓ Branch 28 → 29 taken 734573 times.
✗ Branch 28 → 177 not taken.
 734573 Function candidate = presetFunction;
240
241 // Prepare type mapping, based on the given initial type mapping
242 734573 TypeMapping &typeMapping = candidate.typeMapping;
243 734573 typeMapping.clear();
244
2/2
✓ Branch 41 → 31 taken 3613 times.
✓ Branch 41 → 42 taken 734573 times.
 738186 for (size_t i = 0; i < std::min(templateTypeHints.size(), candidate.templateTypes.size()); i++) {
245
2/4
✓ Branch 31 → 32 taken 3613 times.
✗ Branch 31 → 175 not taken.
✓ Branch 32 → 33 taken 3613 times.
✗ Branch 32 → 175 not taken.
 3613 const std::string &typeName = candidate.templateTypes.at(i).getSubType();
246
1/2
✓ Branch 33 → 34 taken 3613 times.
✗ Branch 33 → 175 not taken.
 3613 const QualType &templateType = templateTypeHints.at(i);
247
2/4
✓ Branch 34 → 35 taken 3613 times.
✗ Branch 34 → 155 not taken.
✓ Branch 35 → 36 taken 3613 times.
✗ Branch 35 → 153 not taken.
 3613 typeMapping.insert({typeName, templateType});
248 }
249
250 734573 bool forceSubstantiation = false;
251
2/2
✓ Branch 42 → 43 taken 734572 times.
✓ Branch 42 → 175 taken 1 time.
 734573 const MatchResult matchResult = matchManifestation(candidate, matchScope, reqName, reqThisType, reqArgs, typeMapping,
252 strictQualifierMatching, forceSubstantiation, callNode);
253
2/2
✓ Branch 43 → 44 taken 685887 times.
✓ Branch 43 → 45 taken 48685 times.
 734572 if (matchResult == MatchResult::SKIP_FUNCTION)
254 685887 break; // Leave the whole function
255
2/2
✓ Branch 45 → 46 taken 40919 times.
✓ Branch 45 → 47 taken 7766 times.
 48685 if (matchResult == MatchResult::SKIP_MANIFESTATION)
256 40919 continue; // Leave this manifestation and try the next one
257
258 // We found a match! -> Set the actual candidate and its entry to used
259 7766 candidate.used = true;
260 7766 candidate.entry->used = true;
261
262 // Check if the function is generic needs to be substantiated
263
6/6
✓ Branch 48 → 49 taken 5467 times.
✓ Branch 48 → 51 taken 2299 times.
✓ Branch 49 → 50 taken 5389 times.
✓ Branch 49 → 51 taken 78 times.
✓ Branch 52 → 53 taken 5389 times.
✓ Branch 52 → 65 taken 2377 times.
 7766 if (presetFunction.templateTypes.empty() && !forceSubstantiation) {
264
5/10
✓ Branch 53 → 54 taken 5389 times.
✗ Branch 53 → 175 not taken.
✓ Branch 54 → 55 taken 5389 times.
✗ Branch 54 → 59 not taken.
✓ Branch 55 → 56 taken 5389 times.
✗ Branch 55 → 175 not taken.
✓ Branch 56 → 57 taken 5389 times.
✗ Branch 56 → 175 not taken.
✓ Branch 57 → 58 taken 5389 times.
✗ Branch 57 → 59 not taken.
 5389 assert(matchScope->functions.contains(fctId) && matchScope->functions.at(fctId).contains(signature));
265
3/6
✓ Branch 60 → 61 taken 5389 times.
✗ Branch 60 → 156 not taken.
✓ Branch 61 → 62 taken 5389 times.
✗ Branch 61 → 156 not taken.
✓ Branch 62 → 63 taken 5389 times.
✗ Branch 62 → 156 not taken.
 5389 matches.push_back(&matchScope->functions.at(fctId).at(signature));
266 5389 matches.back()->used = true;
267 5389 continue; // Match was successful -> match the next function
268 }
269
270 // Check if we already have this manifestation and can simply re-use it
271
1/2
✓ Branch 65 → 66 taken 2377 times.
✗ Branch 65 → 175 not taken.
 2377 const std::string nonGenericSignature = candidate.getSignature(true, false);
272
4/6
✓ Branch 66 → 67 taken 2377 times.
✗ Branch 66 → 173 not taken.
✓ Branch 67 → 68 taken 2377 times.
✗ Branch 67 → 173 not taken.
✓ Branch 68 → 69 taken 164 times.
✓ Branch 68 → 73 taken 2213 times.
 2377 if (matchScope->functions.at(fctId).contains(nonGenericSignature)) {
273
3/6
✓ Branch 69 → 70 taken 164 times.
✗ Branch 69 → 157 not taken.
✓ Branch 70 → 71 taken 164 times.
✗ Branch 70 → 157 not taken.
✓ Branch 71 → 72 taken 164 times.
✗ Branch 71 → 157 not taken.
 164 matches.push_back(&matchScope->functions.at(fctId).at(nonGenericSignature));
274 164 break; // Leave the whole manifestation list to not double-match the manifestation
275 }
276
277 // Insert the substantiated version if required
278
2/2
✓ Branch 73 → 74 taken 2212 times.
✓ Branch 73 → 173 taken 1 time.
 2213 Function *substantiatedFunction = insertSubstantiation(matchScope, candidate, presetFunction.declNode);
279
2/4
✓ Branch 74 → 75 taken 2212 times.
✗ Branch 74 → 173 not taken.
✓ Branch 75 → 76 taken 2212 times.
✗ Branch 75 → 173 not taken.
 2212 substantiatedFunction->genericPreset = &matchScope->functions.at(fctId).at(signature);
280 2212 substantiatedFunction->alreadyTypeChecked = false;
281
2/4
✓ Branch 76 → 77 taken 2212 times.
✗ Branch 76 → 173 not taken.
✓ Branch 77 → 78 taken 2212 times.
✗ Branch 77 → 173 not taken.
 2212 substantiatedFunction->declNode->getFctManifestations(reqName)->push_back(substantiatedFunction);
282
283 // Copy function entry
284
1/2
✓ Branch 78 → 79 taken 2212 times.
✗ Branch 78 → 173 not taken.
 2212 const std::string newSignature = substantiatedFunction->getSignature(false);
285
1/2
✓ Branch 79 → 80 taken 2212 times.
✗ Branch 79 → 171 not taken.
 2212 matchScope->lookupStrict(presetFunction.entry->name)->used = true;
286
1/2
✓ Branch 82 → 83 taken 2212 times.
✗ Branch 82 → 171 not taken.
 2212 substantiatedFunction->entry = matchScope->symbolTable.copySymbol(presetFunction.entry->name, newSignature);
287
1/2
✗ Branch 83 → 84 not taken.
✓ Branch 83 → 85 taken 2212 times.
 2212 assert(substantiatedFunction->entry != nullptr);
288
289 // Copy function scope
290
1/2
✓ Branch 85 → 86 taken 2212 times.
✗ Branch 85 → 171 not taken.
 2212 const std::string oldSignature = presetFunction.getSignature(false);
291
1/2
✓ Branch 86 → 87 taken 2212 times.
✗ Branch 86 → 169 not taken.
 2212 Scope *childScope = matchScope->copyChildScope(oldSignature, newSignature);
292
1/2
✗ Branch 87 → 88 not taken.
✓ Branch 87 → 89 taken 2212 times.
 2212 assert(childScope != nullptr);
293 2212 childScope->isGenericScope = false;
294 2212 substantiatedFunction->bodyScope = childScope;
295
296 // Insert symbols for generic type names with concrete types into the child block
297
2/2
✓ Branch 99 → 91 taken 2607 times.
✓ Branch 99 → 100 taken 2212 times.
 4819 for (const auto &[typeName, concreteType] : substantiatedFunction->typeMapping)
298
2/4
✓ Branch 94 → 95 taken 2607 times.
✗ Branch 94 → 160 not taken.
✓ Branch 95 → 96 taken 2607 times.
✗ Branch 95 → 158 not taken.
 2607 childScope->insertGenericType(typeName, GenericType(concreteType));
299
300 // Substantiate the 'this' entry in the new function scope
301
6/6
✓ Branch 103 → 104 taken 1792 times.
✓ Branch 103 → 107 taken 420 times.
✓ Branch 105 → 106 taken 1791 times.
✓ Branch 105 → 107 taken 1 time.
✓ Branch 108 → 109 taken 1791 times.
✓ Branch 108 → 122 taken 421 times.
 2212 if (presetFunction.isMethod() && !presetFunction.templateTypes.empty()) {
302
1/2
✓ Branch 111 → 112 taken 1791 times.
✗ Branch 111 → 164 not taken.
 5373 SymbolTableEntry *thisEntry = childScope->lookupStrict(THIS_VARIABLE_NAME);
303
1/2
✗ Branch 117 → 118 not taken.
✓ Branch 117 → 119 taken 1791 times.
 1791 assert(thisEntry != nullptr);
304
2/4
✓ Branch 119 → 120 taken 1791 times.
✗ Branch 119 → 168 not taken.
✓ Branch 120 → 121 taken 1791 times.
✗ Branch 120 → 168 not taken.
 1791 thisEntry->updateType(candidate.thisType.toPtr(callNode), /*overwriteExistingType=*/true);
305 }
306
307 // Add to matched functions
308
1/2
✓ Branch 122 → 123 taken 2212 times.
✗ Branch 122 → 169 not taken.
 2212 matches.push_back(substantiatedFunction);
309
310 2212 break; // Leave the whole manifestation list to not double-match the manifestation
311
2/2
✓ Branch 129 → 130 taken 46308 times.
✓ Branch 129 → 131 taken 688263 times.
 736950 }
312 732572 }
313
314 // If no matches were found, return a nullptr
315
2/2
✓ Branch 139 → 140 taken 52390 times.
✓ Branch 139 → 141 taken 7764 times.
 60154 if (matches.empty())
316 52390 return nullptr;
317
318
1/2
✗ Branch 142 → 143 not taken.
✓ Branch 142 → 144 taken 7764 times.
 7764 assert(matches.size() == 1);
319 7764 Function *matchedFunction = matches.front();
320
321 // Insert into cache
322
1/2
✓ Branch 145 → 146 taken 7764 times.
✗ Branch 145 → 183 not taken.
 7764 lookupCache[cacheKey] = matchedFunction;
323
324 // Trigger revisit in type checker if required
325
1/2
✓ Branch 146 → 147 taken 7764 times.
✗ Branch 146 → 183 not taken.
 7764 TypeChecker::requestRevisitIfRequired(matchedFunction);
326
327 // Return the very match
328 7764 return matchedFunction;
329 60158 }
330
331 785767 MatchResult FunctionManager::matchManifestation(Function &candidate, Scope *&matchScope, const std::string &reqName,
332 const QualType &reqThisType, const ArgList &reqArgs, TypeMapping &typeMapping,
333 bool strictQualifierMatching, bool &forceSubstantiation,
334 const ASTNode *callNode) {
335 // Check name requirement
336
2/2
✓ Branch 3 → 4 taken 729805 times.
✓ Branch 3 → 5 taken 55962 times.
 785767 if (!matchName(candidate, reqName))
337 729805 return MatchResult::SKIP_FUNCTION; // Leave the whole manifestation list, because all have the same name
338
339 // Check 'this' type requirement
340
1/2
✗ Branch 6 → 7 not taken.
✓ Branch 6 → 8 taken 55962 times.
 55962 if (!matchThisType(candidate, reqThisType, typeMapping, strictQualifierMatching, callNode))
341 ✗ return MatchResult::SKIP_MANIFESTATION; // Leave this manifestation and try the next one
342
343 // Check arg types requirement
344
2/2
✓ Branch 9 → 10 taken 46909 times.
✓ Branch 9 → 11 taken 9052 times.
 55962 if (!matchArgTypes(candidate, reqArgs, typeMapping, strictQualifierMatching, forceSubstantiation, callNode))
345 46909 return MatchResult::SKIP_MANIFESTATION; // Leave this manifestation and try the next one
346
347 // Check if there are unresolved generic types
348
2/2
✓ Branch 13 → 14 taken 1 time.
✓ Branch 13 → 15 taken 9051 times.
 9052 if (typeMapping.size() < candidate.templateTypes.size())
349 1 return MatchResult::SKIP_MANIFESTATION; // Leave this manifestation and try the next one
350
351 // Substantiate return type
352 9051 substantiateReturnType(candidate, typeMapping, callNode);
353
354 // Set the match scope to the scope of the concrete substantiation
355 9051 const QualType &thisType = candidate.thisType;
356
2/2
✓ Branch 17 → 18 taken 5575 times.
✓ Branch 17 → 25 taken 3476 times.
 9051 if (!thisType.is(TY_DYN)) {
357 // If we only have the generic struct scope, lookup the concrete manifestation scope
358
2/2
✓ Branch 18 → 19 taken 62 times.
✓ Branch 18 → 23 taken 5513 times.
 5575 if (matchScope->isGenericScope) {
359 62 const Struct *spiceStruct = thisType.getStruct(candidate.declNode);
360
1/2
✗ Branch 20 → 21 not taken.
✓ Branch 20 → 22 taken 62 times.
 62 assert(spiceStruct != nullptr);
361 62 matchScope = spiceStruct->scope;
362 }
363
1/2
✓ Branch 23 → 24 taken 5575 times.
✗ Branch 23 → 27 not taken.
 5575 candidate.thisType = candidate.thisType.getWithBodyScope(matchScope);
364 }
365
366 9051 return MatchResult::MATCHED;
367 }
368
369 /**
370 * Checks if the matching candidate fulfills the name requirement
371 *
372 * @param candidate Matching candidate function
373 * @param reqName Requested function name
374 * @return Fulfilled or not
375 */
376 785767 bool FunctionManager::matchName(const Function &candidate, const std::string &reqName) { return candidate.name == reqName; }
377
378 /**
379 * Checks if the matching candidate fulfills the 'this' type requirement
380 *
381 * @param candidate Matching candidate function
382 * @param reqThisType Requested 'this' type
383 * @param typeMapping Concrete template type mapping
384 * @param strictQualifierMatching Match qualifiers strictly
385 * @param callNode Call AST node for printing error messages
386 * @return Fulfilled or not
387 */
388 55962 bool FunctionManager::matchThisType(Function &candidate, const QualType &reqThisType, TypeMapping &typeMapping,
389 bool strictQualifierMatching, const ASTNode *callNode) {
390 55962 QualType &candidateThisType = candidate.thisType;
391
392 // Shortcut for procedures
393
7/10
✓ Branch 2 → 3 taken 55962 times.
✗ Branch 2 → 23 not taken.
✓ Branch 3 → 4 taken 38394 times.
✓ Branch 3 → 7 taken 17568 times.
✓ Branch 4 → 5 taken 38394 times.
✗ Branch 4 → 23 not taken.
✓ Branch 5 → 6 taken 38394 times.
✗ Branch 5 → 7 not taken.
✓ Branch 8 → 9 taken 38394 times.
✓ Branch 8 → 10 taken 17568 times.
 55962 if (candidateThisType.is(TY_DYN) && reqThisType.is(TY_DYN))
394 38394 return true;
395
396 // Give the type matcher a way to retrieve instances of GenericType by their name
397 37881 TypeMatcher::ResolverFct genericTypeResolver = [&](const std::string &genericTypeName) {
398 2745 return getGenericTypeOfCandidateByName(candidate, genericTypeName);
399 17568 };
400
401 // Check if the requested 'this' type matches the candidate 'this' type. The type mapping may be extended
402
2/4
✓ Branch 11 → 12 taken 17568 times.
✗ Branch 11 → 21 not taken.
✗ Branch 12 → 13 not taken.
✓ Branch 12 → 14 taken 17568 times.
 17568 if (!TypeMatcher::matchRequestedToCandidateType(candidateThisType, reqThisType, typeMapping, genericTypeResolver,
403 strictQualifierMatching))
404 ✗ return false;
405
406 // Substantiate the candidate param type, based on the type mapping
407
3/4
✓ Branch 14 → 15 taken 17568 times.
✗ Branch 14 → 21 not taken.
✓ Branch 15 → 16 taken 2901 times.
✓ Branch 15 → 17 taken 14667 times.
 17568 if (candidateThisType.hasAnyGenericParts())
408
1/2
✓ Branch 16 → 17 taken 2901 times.
✗ Branch 16 → 21 not taken.
 2901 TypeMatcher::substantiateTypeWithTypeMapping(candidateThisType, typeMapping, callNode);
409
410 17568 return true;
411 17568 }
412
413 /**
414 * Checks if the matching candidate fulfills the argument types requirement
415 *
416 * @param candidate Matching candidate function
417 * @param reqArgs Requested argument types
418 * @param typeMapping Concrete template type mapping
419 * @param strictQualifierMatching Match qualifiers strictly
420 * @param needsSubstantiation We want to create a substantiation after successfully matching
421 * @param callNode Call AST node for printing error messages
422 * @return Fulfilled or not
423 */
424 55962 bool FunctionManager::matchArgTypes(Function &candidate, const ArgList &reqArgs, TypeMapping &typeMapping,
425 bool strictQualifierMatching, bool &needsSubstantiation, const ASTNode *callNode) {
426 55962 std::vector<Param> &candidateParamList = candidate.paramList;
427
428 // If the number of arguments does not match with the number of params, the matching fails
429
6/6
✓ Branch 2 → 3 taken 55887 times.
✓ Branch 2 → 7 taken 75 times.
✓ Branch 5 → 6 taken 7322 times.
✓ Branch 5 → 7 taken 48565 times.
✓ Branch 8 → 9 taken 7322 times.
✓ Branch 8 → 10 taken 48640 times.
 55962 if (!candidate.isVararg && reqArgs.size() != candidateParamList.size())
430 7322 return false;
431 // In the case of a vararg function, we only disallow fewer arguments than parameters
432
4/6
✓ Branch 10 → 11 taken 75 times.
✓ Branch 10 → 15 taken 48565 times.
✗ Branch 13 → 14 not taken.
✓ Branch 13 → 15 taken 75 times.
✗ Branch 16 → 17 not taken.
✓ Branch 16 → 18 taken 48640 times.
 48640 if (candidate.isVararg && reqArgs.size() < candidateParamList.size())
433 ✗ return false;
434
435 // Give the type matcher a way to retrieve instances of GenericType by their name
436 101493 TypeMatcher::ResolverFct genericTypeResolver = [&](const std::string &genericTypeName) {
437 4213 return getGenericTypeOfCandidateByName(candidate, genericTypeName);
438 48640 };
439
440 // Loop over all parameters
441
2/2
✓ Branch 66 → 20 taken 51504 times.
✓ Branch 66 → 67 taken 9052 times.
 60556 for (size_t i = 0; i < reqArgs.size(); i++) {
442 // In the case of a vararg function candidate, we can accept additional arguments, that are not defined in the candidate,
443 // but we need to modify the candidate param list to accept them
444
6/6
✓ Branch 20 → 21 taken 300 times.
✓ Branch 20 → 24 taken 51204 times.
✓ Branch 22 → 23 taken 75 times.
✓ Branch 22 → 24 taken 225 times.
✓ Branch 25 → 26 taken 75 times.
✓ Branch 25 → 29 taken 51429 times.
 51504 if (candidate.isVararg && i >= candidateParamList.size()) {
445
2/4
✓ Branch 26 → 27 taken 75 times.
✗ Branch 26 → 71 not taken.
✓ Branch 27 → 28 taken 75 times.
✗ Branch 27 → 71 not taken.
 75 candidateParamList.push_back(Param(reqArgs.at(i).first, false));
446 75 needsSubstantiation = true; // We need to modify the candidate param types
447 75 continue;
448 }
449
450 // Retrieve actual and requested types
451
2/4
✓ Branch 29 → 30 taken 51429 times.
✗ Branch 29 → 84 not taken.
✗ Branch 30 → 31 not taken.
✓ Branch 30 → 32 taken 51429 times.
 51429 assert(!candidateParamList.at(i).isOptional);
452
1/2
✓ Branch 32 → 33 taken 51429 times.
✗ Branch 32 → 84 not taken.
 51429 QualType &candidateType = candidateParamList.at(i).qualType;
453
1/2
✓ Branch 33 → 34 taken 51429 times.
✗ Branch 33 → 84 not taken.
 51429 const auto &[requestedType, isArgTemporary] = reqArgs.at(i);
454
455 // Check if the requested param type matches the candidate param type. The type mapping may be extended
456
3/4
✓ Branch 36 → 37 taken 51429 times.
✗ Branch 36 → 84 not taken.
✓ Branch 37 → 38 taken 39587 times.
✓ Branch 37 → 39 taken 11842 times.
 51429 if (!TypeMatcher::matchRequestedToCandidateType(candidateType, requestedType, typeMapping, genericTypeResolver,
457 strictQualifierMatching))
458 39587 return false;
459
460 // Substantiate the candidate param type, based on the type mapping
461
3/4
✓ Branch 39 → 40 taken 11842 times.
✗ Branch 39 → 84 not taken.
✓ Branch 40 → 41 taken 1942 times.
✓ Branch 40 → 42 taken 9900 times.
 11842 if (candidateType.hasAnyGenericParts())
462
1/2
✓ Branch 41 → 42 taken 1942 times.
✗ Branch 41 → 84 not taken.
 1942 TypeMatcher::substantiateTypeWithTypeMapping(candidateType, typeMapping, callNode);
463
464 // Check if we try to bind a non-ref temporary to a non-const ref parameter
465
3/4
✓ Branch 42 → 43 taken 11842 times.
✗ Branch 42 → 84 not taken.
✓ Branch 43 → 44 taken 1 time.
✓ Branch 43 → 54 taken 11841 times.
 11842 if (!candidateType.canBind(requestedType, isArgTemporary)) {
466
1/2
✓ Branch 44 → 45 taken 1 time.
✗ Branch 44 → 53 not taken.
 1 if (callNode)
467
2/4
✓ Branch 48 → 49 taken 1 time.
✗ Branch 48 → 75 not taken.
✓ Branch 49 → 50 taken 1 time.
✗ Branch 49 → 72 not taken.
 3 throw SemanticError(callNode, TEMP_TO_NON_CONST_REF, "Temporary values can only be bound to const reference parameters");
468 ✗ return false;
469 }
470
471 // If we have a function/procedure type we need to take care of the information, if it takes captures
472
9/12
✓ Branch 54 → 55 taken 11841 times.
✗ Branch 54 → 81 not taken.
✓ Branch 55 → 56 taken 11841 times.
✗ Branch 55 → 81 not taken.
✓ Branch 56 → 57 taken 23 times.
✓ Branch 56 → 60 taken 11818 times.
✓ Branch 57 → 58 taken 23 times.
✗ Branch 57 → 81 not taken.
✓ Branch 58 → 59 taken 4 times.
✓ Branch 58 → 60 taken 19 times.
✓ Branch 61 → 62 taken 4 times.
✓ Branch 61 → 64 taken 11837 times.
 11841 if (requestedType.getBase().isOneOf({TY_FUNCTION, TY_PROCEDURE}) && requestedType.hasLambdaCaptures()) {
473
1/2
✓ Branch 62 → 63 taken 4 times.
✗ Branch 62 → 83 not taken.
 4 candidateType = candidateType.getWithLambdaCaptures();
474 4 needsSubstantiation = true;
475 }
476 }
477
478 9052 return true;
479 48640 }
480
481 /**
482 * Substantiates the candidate return type, based on the given type mapping
483 *
484 * @param candidate Matching candidate function
485 * @param typeMapping Concrete template type mapping
486 * @param callNode AST node for error messages
487 */
488 9051 void FunctionManager::substantiateReturnType(Function &candidate, const TypeMapping &typeMapping, const ASTNode *callNode) {
489
2/2
✓ Branch 3 → 4 taken 686 times.
✓ Branch 3 → 5 taken 8365 times.
 9051 if (candidate.returnType.hasAnyGenericParts())
490 686 TypeMatcher::substantiateTypeWithTypeMapping(candidate.returnType, typeMapping, callNode);
491 9051 }
492
493 /**
494 * Searches the candidate template types for a generic type object with a certain name and return it
495 *
496 * @param candidate Matching candidate function
497 * @param templateTypeName Template type name
498 * @return Generic type object
499 */
500 6958 const GenericType *FunctionManager::getGenericTypeOfCandidateByName(const Function &candidate,
501 const std::string &templateTypeName) {
502
1/2
✓ Branch 11 → 4 taken 7560 times.
✗ Branch 11 → 12 not taken.
 7560 for (const GenericType &templateType : candidate.templateTypes) {
503
3/4
✓ Branch 5 → 6 taken 7560 times.
✗ Branch 5 → 14 not taken.
✓ Branch 7 → 8 taken 6958 times.
✓ Branch 7 → 9 taken 602 times.
 7560 if (templateType.getSubType() == templateTypeName)
504 6958 return &templateType;
505 }
506 ✗ return nullptr;
507 }
508
509 /**
510 * Calculate the cache key for the function lookup cache
511 *
512 * @param scope Scope to match against
513 * @param name Function name requirement
514 * @param thisType This type requirement
515 * @param args Argument requirement
516 * @param templateTypes Template type requirement
517 * @return Cache key
518 */
519 83766 uint64_t FunctionManager::getCacheKey(Scope *scope, const std::string &name, const QualType &thisType, const ArgList &args,
520 const QualTypeList &templateTypes) {
521 83766 uint64_t acc = 1469598103934665603ull;
522
1/2
✓ Branch 3 → 4 taken 83766 times.
✗ Branch 3 → 30 not taken.
 83766 acc = hash_combine64(acc, std::hash<Scope *>{}(scope));
523
1/2
✓ Branch 5 → 6 taken 83766 times.
✗ Branch 5 → 31 not taken.
 83766 acc = hash_combine64(acc, std::hash<std::string>{}(name));
524
1/2
✓ Branch 7 → 8 taken 83766 times.
✗ Branch 7 → 32 not taken.
 83766 acc = hash_combine64(acc, std::hash<QualType>{}(thisType));
525
2/2
✓ Branch 19 → 10 taken 124414 times.
✓ Branch 19 → 20 taken 83766 times.
 208180 for (const auto &[first, second] : args) {
526
1/2
✓ Branch 14 → 15 taken 124414 times.
✗ Branch 14 → 33 not taken.
 124414 acc = hash_combine64(acc, std::hash<QualType>{}(first));
527
1/2
✓ Branch 16 → 17 taken 124414 times.
✗ Branch 16 → 34 not taken.
 124414 acc = hash_combine64(acc, std::hash<bool>{}(second));
528 }
529
2/2
✓ Branch 27 → 22 taken 744 times.
✓ Branch 27 → 28 taken 83766 times.
 84510 for (const QualType &qt : templateTypes)
530
1/2
✓ Branch 24 → 25 taken 744 times.
✗ Branch 24 → 36 not taken.
 744 acc = hash_combine64(acc, std::hash<QualType>{}(qt));
531 83766 return acc;
532 }
533
534 /**
535 * Clear the lookup cache
536 */
537 422 void FunctionManager::cleanup() {
538 422 lookupCache.clear();
539 422 lookupCacheHits = 0;
540 422 lookupCacheMisses = 0;
541 422 }
542
543 /**
544 * Dump usage statistics for the lookup cache
545 */
546 198 std::string FunctionManager::dumpLookupCacheStatistics() {
547
1/2
✓ Branch 2 → 3 taken 198 times.
✗ Branch 2 → 22 not taken.
 198 std::stringstream stats;
548
2/4
✓ Branch 3 → 4 taken 198 times.
✗ Branch 3 → 20 not taken.
✓ Branch 4 → 5 taken 198 times.
✗ Branch 4 → 20 not taken.
 198 stats << "FunctionManager lookup cache statistics:" << std::endl;
549
3/6
✓ Branch 5 → 6 taken 198 times.
✗ Branch 5 → 20 not taken.
✓ Branch 7 → 8 taken 198 times.
✗ Branch 7 → 20 not taken.
✓ Branch 8 → 9 taken 198 times.
✗ Branch 8 → 20 not taken.
 198 stats << " lookup cache entries: " << lookupCache.size() << std::endl;
550
3/6
✓ Branch 9 → 10 taken 198 times.
✗ Branch 9 → 20 not taken.
✓ Branch 10 → 11 taken 198 times.
✗ Branch 10 → 20 not taken.
✓ Branch 11 → 12 taken 198 times.
✗ Branch 11 → 20 not taken.
 198 stats << " lookup cache hits: " << lookupCacheHits << std::endl;
551
3/6
✓ Branch 12 → 13 taken 198 times.
✗ Branch 12 → 20 not taken.
✓ Branch 13 → 14 taken 198 times.
✗ Branch 13 → 20 not taken.
✓ Branch 14 → 15 taken 198 times.
✗ Branch 14 → 20 not taken.
 198 stats << " lookup cache misses: " << lookupCacheMisses << std::endl;
552
1/2
✓ Branch 15 → 16 taken 198 times.
✗ Branch 15 → 20 not taken.
 396 return stats.str();
553 198 }
554
555 } // namespace spice::compiler
556