# proxy top-level constant

const proxy = const _Proxy()

This annotation is deprecated and will be removed in Dart 2.

Dart 2 has a more restrictive type system than Dart 1, and it requires method access to be either through a known interface or by using dynamic invocations. The original intent of `@proxy` (to implement a class that isn't known statically, as documented at the end of this text), is not supported by Dart 2. To continue to perform dynamic invocations on an object, it should be accessed through a reference of type `dynamic`.

The annotation `@proxy` marks a class as implementing members dynamically through `noSuchMethod`.

The annotation applies to any class. It is inherited by subclasses from both superclass and interfaces.

If a class is annotated with `@proxy`, or it implements any class that is annotated, then all member accesses are allowed on an object of that type. As such, it is not a static type warning to access any member of the object which is not implemented by the class, or to call a method with a different number of parameters than it is declared with.

The annotation does not change which classes the annotated class implements, and does not prevent static warnings for assigning an object to a variable with a static type not implemented by the object.

The suppression of warnings only affect static type warnings about member access. The runtime type of the object is unaffected. It is not considered to implement any special interfaces, so assigning it to a typed variable may fail in checked mode, and testing it with the `is` operator will only return true for types it actually implements or extends. Accessing a member which isn't implemented by the class will cause the `noSuchMethod` method to be called normally, the `@proxy` annotation merely states the intent to handle (some of) those `noSuchMethod` calls gracefully.

A class that marked as `@proxy` should override the `noSuchMethod` declared on Object.

The intent of the `@proxy` notation is to create objects that implement a type (or multiple types) that are not known at compile time. If the types are known at compile time, a class can be written that implements these types.

## Implementation

    const Object proxy = _Proxy()