Supported language

Java

AtlasArc recognizes Java dependencies from compiled JVM bytecode. This is what that covers, and which source-looking relationships are deliberately out of scope.

AtlasArc builds its dependency graph from compiled JVM bytecode, not from a source-text scan. Every construct below is read from the same place your compiler and runtime see it, so what AtlasArc draws is the structure your code actually has after compilation, free of imports it never uses and edges that only exist on paper.

This means AtlasArc analyzes the dependencies that are visible in compiled output rather than every form a relationship can take in source. A few source-looking relationships are erased, inlined, or generated only at runtime, and those are called out under Known boundaries at the end of this page.

For calls, method references, and lambdas, AtlasArc retains each correlated source member, target member, and dependency kind. Member identity includes its owner, name, and erased descriptor, so one overload or lambda target does not broaden the evidence to unrelated members.

How to read this

Each Java construct falls into one of three states:

Recognized: the construct produces a package dependency edge, and that behaviour is locked down by AtlasArc's dependency-acquisition test suite.
Out of scope: deliberately not modelled, because the relationship does not exist as a static JVM dependency.
Not supported: does not produce a reliable package edge today.

Construct support

Construct	Recognition	Notes
Method calls	Recognized	A call creates an edge to the owner class's package.
Constructor calls	Recognized	Creates an edge to the constructed class's package.
Field type declarations	Recognized	A field's declared type creates an edge to that type's package.
Field access	Recognized	Reading a non-constant static field creates an edge to the field owner's package.
Inheritance and implemented interfaces	Recognized	Superclass and interface relationships are structural edges.
Generic type arguments	Recognized	Type arguments in a generic signature are retained as edges.
Annotation types	Recognized	Dependencies on annotation classes are recognized when the annotation is retained in bytecode.
Throws declarations	Recognized	Declared checked-exception types create edges.
Class literals	Recognized	`PluginContract.class` creates an edge to that class's package.
`instanceof` checks and casts	Recognized	Runtime type checks and casts create edges to the checked or cast type's package.
Fully qualified type references	Recognized	Fully qualified constructor and type references create edges without requiring an import.
Method references	Recognized	A method reference creates an edge to the referenced member's owner package.
Lambda with an explicit functional-interface type	Recognized	The written SAM (single-abstract-method) type is recognized.
Lambda inferred from a parameter type	Recognized	Both the call target and the inferred SAM type's package are recognized, even when they live in different packages.
Reflection by string name (`Class.forName("...")`)	Out of scope	String literals are not treated as static architectural dependencies.
Dynamically generated bytecode and proxies	Out of scope	Runtime-only relationships sit outside static acquisition.
`static final` compile-time constants	Out of scope	The constant value is inlined into the caller, so no edge to the declaring class survives in bytecode.
Source-retention annotations	Out of scope	`RetentionPolicy.SOURCE` annotations are discarded by the compiler before AtlasArc ever sees the bytecode.
Debug-only local variable types	Out of scope	A local variable's type that is never otherwise used lives only in debug metadata, not as a structural edge.
`module-info.java` (JPMS)	Out of scope	Module descriptors are a module-level concern, not package or class dependency edges.

Known boundaries

AtlasArc intentionally models the static dependencies present in compiled output. Some relationships are real to a human reader but leave no trace a static analyzer can trust:

Reflection and configuration. Class names resolved from strings, service lookups, and framework attributes in XML, YAML, or annotations are not treated as ordinary edges.
Runtime-generated relationships. Proxies and wiring created by frameworks such as Spring, Hibernate, or Mockito are produced at runtime and are not part of the static graph.
Inlined constants. A static final compile-time constant is copied into each caller, leaving no dependency on the class that declared it.
Source-only annotations. Annotations with SOURCE retention never reach bytecode.

When a relationship matters to your architecture, prefer expressing it in a way the compiler preserves, such as a typed field, a method signature, or a constructor call, so it shows up where AtlasArc can see it.