
# What the build checks

The generator fails the build, naming the member and what to change, when an annotation is on a member it cannot follow.

## Why

The bean's proxy is a generated class that extends the bean's class and overrides its members. A member it cannot override would be a field that silently tells nobody. So the mistake is a build error, not a stale screen.

## Example

```dart
@Component()
class Basket {
  @Signal()
  final List<Book> items = [];   // fails the build: a final field

  @Signal()
  String? _coupon;               // fails the build: a private field
}
```

## What fails the build

| Annotation | Fails on |
|---|---|
| `@Signal` | A private, static or `final` field; a getter or a method |
| `@Computed` | A field; a private or static member; a method with parameters or without a value |
| `@Effect` | A private or static method; a method with parameters, or with a value |
| Any of them | An abstract member; a member that overrides a followed one without repeating its annotation; a member the proxy cannot override (an operator, a field of a private type) |
| Any of them | A class with such members that a generated class cannot extend: `final`, `sealed`, generic, a factory constructor |

Members must be public because the proxy is generated in another library.

## Where the annotations do not go

The annotations work on the members of a component class (`@Component`, `@Service`, a `@Repository` class with a body), of its base classes and of its mixins. Anywhere else nothing would follow them, so the build fails there too:

| Where | What to do instead |
|---|---|
| A class that is no bean: a widget, a `State`, a data class | Make it a component, or keep the state in one |
| A `@Configuration` or `@ConfigurationProperties` class | Keep the state in a component (one that reads the properties) |
| The class a `@Bean` method returns | Declare the class as a component |
| A repository (`DataRepository`) or an HTTP client (`@FeignClient`): their methods are written by the generator | Call the method in a `@Computed` getter of a component |
| A bean the container does not proxy: an `@Aspect`, a post-processor | Move the member into a component of its own |
| An enum, an extension, a top-level variable or function | Move it into a component |

```dart
abstract interface class BookRepository implements DataRepository<Book, int> {
  @Computed()                                   // fails the build
  Future<List<Book>> findByGenre(String genre);
}

@Service()
class Catalog {
  Catalog(this.repository);
  final BookRepository repository;

  @Signal()
  String genre = 'fiction';

  @Computed()                                   // the place for it
  Future<List<Book>> get books => repository.findByGenre(genre);
}
```

An abstract class and a mixin may declare followed members for the components that extend them. A member that overrides a followed one repeats its annotation.

## What is not checked

Not checked by the build: a field read after an `await` in an asynchronous `@Computed` getter. It compiles, and the value is not loaded again when that field changes. Read what the value depends on before the first `await` (see [Asynchronous state](async-state.md#what-it-depends-on-is-read-before-the-first-await)).

## At the start

A bean with such members must be made by the container and proxied. One that is not advised stops the start with a message that names it: the application must be built by the generator with proxies (`aop_proxies: all`, the default), and the bean made by the container.

## See also

- [Fields and computed values](fields-and-computed.md)
- [Effects](effects.md)
- [AOP in spring_core_dart](../spring-core-dart/aop/index.md)
