Every call a call-context query found, flat, each carrying the kind and subkind it was found under
rather than leaving them as the two levels of record the result nests them in.
Every key and result of one query, typed as that query reports them.
The one result of a query that was asked for one thing, undefined when it reported none.
The result of one query under one key, undefined when it reported none.
Every finding a linter query reported, flat, each carrying the rule that reported it.
Run a single query and answer with what it reported, without grouping, retries, or a QueryResults
to index into. For a query marked SupportedQuery#perQueryResults, this is the one entry of its
results, e.g. the slice and reconstruction of a static-slice query. A failing query throws.
Other than executeQueries, it does not retry and merges nothing, so give it exactly one query.
Virtual queries (like compound) are not supported, as they unfold into several queries, so use executeQueries for them.
Most callers want analyzer.query(query), which does the same for an analyzer and also applies the gas bounds of the call.
Every result of one query, for when the keys are not what you are after.
const out = await executeQueries({ analyzer }, [{ type: 'static-slice', criteria: ['2@x'] }]);
Query.get(out, 'static-slice', '2@x'); // the slice taken at `2@x`
Query.first(out, 'static-slice'); // the only slice, when one was asked for
for(const [criterion, slice] of Query.entries(out, 'static-slice')) { ... }
Running queries and reading what they reported, without
Object.entriesand the casts it forces. Reading changes nothing: the results keep the shape they are serialized in.