Groovy

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

.groovy, .gradle

Registry names

groovy

Recorded symbols

classes · interfaces · methods

Relationship types this analyzer constructs

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

11 constructed, 3 not constructed. All 3 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

• A trait is published as an interface, not as a trait. trait Auditable { … } and interface Auditable { … } produce the same symbol kind here, so anything that has to tell them apart has to read the source rather than the index — a deliberate reading of the language rather than an omission.
• An import is a reference, and no package symbol is published for it. import com.acme.Billing records a reference edge to the full module path at confidence 0.9, so Groovy has no namespace node in the graph and a package's own members cannot be reached by walking into it.
• Only fully-qualified names become declared-type references. Fields, parameters, locals, throws, instanceof, casts and return types all publish, and an unqualified type name is refused, because every row of the lane's hand-audited truth set is qualified — a bare Name is a name this file does not spell out. And no synthetic members are recorded: a property's generated getter and setter, the implicit log field and a closure's it are absent because the source does not write them.

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

• A Jenkinsfile is a .groovy file and indexes as one, as does a buildSrc/ helper written in Groovy — so delivery logic sits in the same graph as the classes it names. Gradle build logic is mostly .gradle rather than .groovy, so the build script itself is not in this family's file set.
• Spock specifications write their test names as strings (def "addition works"() { … }), and those are recorded as methods on the specification class, so a spec is queryable as a set of test methods.
• An anonymous inner class has no spelling, so its body is filed under a synthesized name of the form anonymous_<Supertype> carrying synthesized: true. That name exists so the members have an owner; it is not a declaration in your source and should not be read as one.

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 classes implement this trait, and which methods do they override?
2. What does this class extend, and which methods does it override?
3. Which constants does this enum declare?
4. Which types do this method's parameters and return value declare?

What the analyzer sees in code like this

trait Auditable {                          // bb records: interface Auditable
  String auditTag() { "pay" }          // bb records: method auditTag on Auditable
}

class PaymentService implements Auditable {   // bb records: class PaymentService + implements edge
  Status status                       // bb records: property status on PaymentService
  String auditTag() { "pay-${status}" }   // bb records: method auditTag on PaymentService
}

enum Status { PENDING, SETTLED }             // bb records: enum Status + members PENDING, SETTLED

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

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

• Ruby10 types
• PHP12 types
• Lua10 types
• R11 types
• Bash8 types
• PowerShell11 types
• Perl11 types