Zig

The registry row this page is generated from

Read at render time from the same family row the register reads, so nothing in this block can disagree with it.

Extensions

.zig

Registry names

zig

Recorded symbols

functions · structs · enums · constants

Relationship types this analyzer constructs

8 of 14 constructed, read from this analyzer's source and re-derived by the languages gate. Each row below is one of the engine's types, in the engine's own order.

8 constructed, 6 not constructed. All 6 absent types are recorded as ruled absent: the written reason and the corpus measurement behind each are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• Zig has no class inheritance, so there is no extends, implements or override edge. Composition is a field named after the other type and usingnamespace mixes names into a scope — neither is a subtype relation, and neither is recorded as one.
• A builtin call publishes no call edge: @intCast and friends are compile-time intrinsics with no declaration in any repository behind them, so there is nothing for an edge to point at.
• Instantiation is recorded only for a type declared in the same file, so ArrayList(u8) over a standard-library type records nothing at all rather than a construction with an unresolvable target.

Every line above was written against Zig’s own analyzer module and is named against a construct in it, so it can be checked against the source. Nothing here is inherited from a template, or from another language’s page.

Where you meet it in a repository

Recognised by extension — .zig. Everything below is about where those files actually sit in a working repository.

• A build.zig at the root of a Zig project is a program, not only configuration, so its statements are part of the build graph.
• Generic code is written once and monomorphised, so one body is written against several concrete types.
• Almost everything in the standard library arrives through a single @import("std"), so a file's dependency usually terminates at the standard library rather than at a symbol.

Questions this index answers

Phrased as retrievals, because that is what an index can honestly do: it holds the symbols and the edges between them, and hands them back with the evidence attached.

1. Which fields does this struct carry?
2. Which modules does this file import from?
3. Which functions are declared inside this container?
4. Which error set members does this function declare?

What the analyzer sees in code like this

pub const Point = struct {          // bb records: struct Point · property x
    x: f64,
    pub fn norm(self: Point) f64 { return @sqrt(self.x * self.x); }
};

pub const Err = error{ NotFound };     // bb records: enum Err · member NotFound

const std = @import("std");            // bb records: an import of "std"

Symbols are stored with the file they came from and the bytes they span, so a hit points at a line rather than at a guess. The annotations in the sample are commentary for the reader, not strings the index would store.

Languages that turn up in the same repository

Application & systems — the count beside each name is how many relationship types that family’s analyzer constructs.

• TypeScript14 types
• JavaScript12 types
• Python11 types
• Rust14 types
• Go12 types
• Java10 types
• C++11 types
• C9 types
• C#11 types
• Swift11 types
• Kotlin11 types
• Dart13 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types