Dart

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

.dart

Registry names

dart

Recorded symbols

classes · enums · methods · constructors

Relationship types this analyzer constructs

13 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.

13 constructed, 1 not constructed. The absent type is recorded as ruled absent: the written reason and the corpus measurement behind it are in this family's completeness record. The register explains what each label means.

What this analyzer does not resolve

• A named constructor declared in another file stays a call to its leaf: construction is recognised only inside the translation unit that declares it.
• An extension method records its target type as metadata rather than as an edge from the extension to that type, so the graph does not connect the two.
• Box<String>('x') misparses as a relational expression in the pinned grammar. That is an upstream grammar ambiguity, so no edge is drawn and no text workaround is applied to paper over it.

Every line above was written against Dart’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 — .dart. Everything below is about where those files actually sit in a working repository.

• Flutter code separates widget, model and generated code, with part / part of tying a generated file back to the library it belongs to.
• A mixin carries behaviour the class body never wrote, so reading the class alone understates what the type can do.
• Build runners emit .g.dart and .freezed.dart files that are ordinary Dart to the analyzer and are often the bulk of a project's file count.

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 mixins does this class apply?
2. Which interfaces does this type implement?
3. Where is this named constructor called from?
4. Which extension methods exist for this type?

What the analyzer sees in code like this

mixin Loggable on Shape {                     // bb records: mixin Loggable · extends Shape
  void log() {}
}

class Poly with Loggable implements Shape {   // bb records: class Poly · implements Shape
  final double sides;                        // bb records: property sides
  factory Poly.unit() = Poly;                // bb records: a factory redirect to Poly
}

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
• Zig8 types
• Objective-C11 types
• Visual Basic11 types
• VBA9 types