The property grammar already emitted module-level aliases, but those aliases
were mostly declarations in the generated source. Function annotations were
still generated from the underlying type grammar directly, so many alias
resolution paths were not exercised by the differential test.

Make aliases real leaves in the generated type-expression grammar. Alias
definitions now keep the generated target metadata alongside the rendered
source, and `_type_expr` can choose those aliases anywhere it can choose a base
leaf. That means Hypothesis can now produce compound annotations such as
`Optional[Alias]`, `list[Alias]`, `Annotated[Alias, ...]`, and return types that
refer to aliases.

Generate both implicit assignments (`Alias = T`) and explicit PEP 613 aliases
(`Alias: TypeAlias = T`) because the analyzer's collection path supports both
and the runtime treats both as valid module patterns. PEP 695 aliases keep the
same generated-target metadata and are also exposed as leaves on Python
versions that can parse that syntax.

For example, the generator can now emit source like:

```python
from typing import Annotated, Optional, TypeAlias

AliasA: TypeAlias = str

@dagger.object_type
class Foo:
    @dagger.function
    def greet(self, name: Optional[AliasA]) -> AliasA:
        ...
```

Top-level alias targets continue to avoid `Annotated[...]` for now. Nested
`Annotated` shapes still appear in generated function annotations, but an alias
whose right-hand side is `Annotated[...]` has separate metadata-flattening
semantics that are not part of this alias-expansion fix.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Add `Self` to the generated annotation grammar as a leaf that resolves to the
enclosing `Foo` object. The runtime introspection side already understands
`typing_extensions.Self`, and the AST analyzer has a dedicated resolver path
for it, but the property generator could previously miss regressions there
because it only generated the literal forward reference `"Foo"`.

The generator now imports `Self` and may place it anywhere a nested leaf is
valid. For example:

```python
from typing_extensions import Self

@dagger.object_type
class Foo:
    @dagger.function
    def chain(self, next: Optional[Self] = None) -> Self:
        ...
```

`Self` is only selected below the top level, matching the existing forward
reference guard that avoids producing invalid top-level string annotations in
contexts where Python would evaluate them too early.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Broaden the property grammar to cover the method shapes that users can write on
Dagger objects. Until now every generated function was an instance method with
`self` as the first parameter, so the differential test did not exercise the
analyzer's handling of decorator stacks and receiver stripping for
`@staticmethod` and `@classmethod`.

Generated functions now carry a `method_kind` and render one of these shapes:

```python
@dagger.function
def instance(self, value: str) -> str:
    ...

@staticmethod
@dagger.function
def static(value: str) -> str:
    ...

@classmethod
@dagger.function
def from_cls(cls, value: str) -> str:
    ...
```

The generator biases toward instance methods so the common case remains common,
but static and class methods appear often enough for Hypothesis to catch
regressions in first-parameter handling and decorator recognition.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Broaden the property grammar to cover modules that import the `dagger` package
under another name. The analyzer has alias-aware decorator and field detection,
but the generated modules previously always used the plain `dagger` name, so
the differential test did not exercise that import path.

The generator now sometimes renders both `import dagger` and
`import dagger as dgr` or `import dagger as dgmod`. The plain import remains
available because type annotations are still generated with the literal
`dagger.Directory` and `dagger.Container` spelling. The alias is used for the
Dagger decorators and helper field calls.

For example, Hypothesis can now emit source like:

```python
import dagger
import dagger as dgr

@dgr.object_type
class Foo:
    @staticmethod
    @dgr.function
    def build(src: dagger.Directory) -> dagger.Container:
        ...
```

This is separate from the alias-expansion parser fix. It only increases the
runtime/analyzer conformance surface for import alias handling.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Broaden the property grammar to cover class-level `dagger.field(default=...)`
declarations on the generated `Foo` object. Fields use a different analyzer
path from function parameters: they are class-body annotated assignments, can
carry defaults through `dagger.field`, and are discovered before methods are
parsed. The property test should exercise that surface instead of only
generating functions.

The generated fields use primitive annotations with JSON-serializable literal
defaults. For example:

```python
@dagger.object_type
class Foo:
    enabled: bool = dagger.field(default=True)
    retries: int = dagger.field(default=3)

    @dagger.function
    def run(self) -> str:
        ...
```

Field names are kept distinct from generated method names and from the package
name used for decorators (`dagger`, `dgr`, or `dgmod`). That last guard matters
because Python evaluates class bodies sequentially: a class attribute named
`dgr` would shadow the imported `dgr` package alias for later
`@dgr.function` decorators or `dgr.field(...)` calls in the same class.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Broaden the property grammar to cover parameter defaults that reference
module-level constants. The analyzer has a static constant evaluator for
defaults, while runtime introspection sees the evaluated Python value directly.
The differential test should compare those paths for named constants, not only
inline literals.

The generator now emits primitive constants before aliases and may use a
matching constant as a parameter default. For example:

```python
CONST_RETRIES = 3
CONST_NAME = "demo"

@dagger.object_type
class Foo:
    @dagger.function
    def run(self, retries: int = CONST_RETRIES, name: str = CONST_NAME) -> str:
        ...
```

Constants are matched by their underlying primitive base so the generated
default remains type-compatible with the parameter annotation. List defaults are
still avoided for function parameters because `default_factory` only applies to
field declarations, not function signatures.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Broaden the property grammar to cover the quoted forms involved in alias
resolution. These are valid Python module patterns and runtime introspection
resolves them through `typing.get_type_hints`, so the AST analyzer needs to
match them.

There are two distinct quoted surfaces:

* A quoted alias leaf inside a larger annotation, such as
  `Optional["AliasA"]`.
* A whole annotation rendered as one string, such as `"Optional[AliasA]"`.

For example, Hypothesis can now emit source like:

```python
from typing import Optional, TypeAlias

AliasA: TypeAlias = str

@dagger.object_type
class Foo:
    @dagger.function
    def greet(self, name: "Optional[AliasA]" = None) -> AliasA:
        ...
```

The generator also lets `Annotated` metadata strings reuse generated alias
names. That intentionally creates examples like
`Annotated[AliasA, Name("AliasA")]`, where the first `AliasA` is a type
position but the string `"AliasA"` is value metadata. This distinction is the
core parser boundary that the implementation fix must respect.

Verified with:

* `uv run ruff check tests/mod/_strategies.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Add focused AST analyzer tests for the two alias expansion bugs that motivated
the parser fix. The property grammar can now generate these shapes, but these
fixtures make the exact contract obvious and keep the failure mode easy to
understand during review.

The first fixture uses:

```python
Alias: TypeAlias = str

def greet(self, name: Annotated[Alias, Name("Alias")]) -> str:
    ...
```

`Alias` in the first `Annotated` argument is a type position and should resolve
to `str`. The string `"Alias"` inside `Name(...)` is metadata and should remain
the exported API name.

The second fixture uses:

```python
Alias: TypeAlias = str

def greet(self, name: "Optional[Alias]" = None) -> str:
    ...
```

The analyzer should parse the whole-string annotation, expand `Alias` inside
the parsed `Optional[...]`, and resolve the parameter as optional `str`.

Before the parser fix, both fixtures fail by resolving as fallback object
types: one as unresolved `Alias`, the other as unresolved `Optional[Alias]`.

Verified before the parser fix:

* `uv run ruff check tests/mod/test_ast_analyzer.py`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

Print Hypothesis statistics in pytest output so property-test runs show how
many generated module sources were exercised. This is useful for this stack
because several commits expand the grammar, and `1 passed` only means one
`@given` test function passed.

For example, a thorough run reports:

```text
500 passing examples, 0 failing examples
Stopped because settings.max_examples=500
```

This changes test output only; it does not change the generated grammar or the
analyzer.

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>

The AST analyzer expands module-level type aliases before resolving function
arguments, fields, and return types. The previous implementation only handled
bare aliases and a small recursive case for pipe unions. That left valid
compound annotations such as `Optional[Alias]`, `list[Alias]`, quoted
annotations, and aliases nested under `Annotated` dependent on ad hoc cases.

Move alias expansion to a dedicated AST transformer that walks annotation type
positions and replaces each alias name with a deep copy of the alias target.
The transformer keeps the existing cross-file behavior by switching file
context when expanding an alias imported from another parsed file, and it keeps
cycle protection with a `(file, name)` seen set.

The important boundary is `Annotated`. In `Annotated[T, ...]`, only the first
argument is a type expression. Later arguments are metadata values. For example:

```python
Alias: TypeAlias = str

def greet(self, name: Annotated[Alias, Name("Alias")]) -> str:
    ...
```

The first `Alias` must expand to `str`, but the string `"Alias"` inside
`Name(...)` must stay unchanged because runtime introspection uses it as the
API name. The transformer now explicitly visits only the first `Annotated`
argument and stops at metadata calls.

The other reviewed failure involved whole-string annotations:

```python
Alias: TypeAlias = str

def greet(self, name: "Optional[Alias]" = None) -> str:
    ...
```

The analyzer parses the string into an AST and visits it. If a child is
expanded in place but the parsed root node remains the same object, returning
the original string constant discards the child replacement. The transformer now
returns the parsed AST after visiting string type positions, preserving
in-place child expansions for quoted compound annotations.

Alias targets are deep copied before recursive expansion so the cached
module-level alias map cannot be mutated across calls. Replacement nodes also
inherit the original source location to keep diagnostics anchored to the user's
annotation.

Verified with:

* `uv run ruff check src/dagger/mod/_analyzer/parser.py tests/mod/_strategies.py tests/mod/test_ast_analyzer.py`
* `uv run pytest tests/mod/test_ast_analyzer.py -k "type_alias"`
* `uv run pytest tests/mod/test_property.py --hypothesis-profile=thorough`

Signed-off-by: Guillaume de Rouville <guillaume@dagger.io>