Nor is it clear that it ought to. According to the specification:

  Let C be a concrete class that does not declare its own noSuchMethod() method and is
  not annotated with a metadata declaration of the form @­proxy where proxy is declared
  in dart:core.

  It is a static warning if the implicit interface of C includes an instance member m of type
  F and C does not declare or inherit a corresponding instance member m of type F’ such
  that F’ <: F.

The question is, does "of the form" mean that it has to be the same identifier, or does it mean "evaluates to the same value as". The analyzer does not execute Dart code. This is a special case that it could handle because, as far as I can think, this simple form of aliasing is the only kind of evaluation that would need to be done, but I'd rather not be required to perform even that much execution.

I'm changing this to a Language issue until this question is resolved. If we need to cover this case, please set it back to being an Analyzer issue.

Removed Area-Analyzer label.
Added Area-Language label.

I think it should work.
Metadata are constants values, and they should be treated as values. Looking at them syntactically is never the right thing to do.

It should be possible to do:

  class Foo extends Deprecated {
    final String author;
    const Foo(this.author, String until): super(until);
  }

and then do:
  @­Foo("Me", "Forever!")
  int fisk = 42;

and have the "fisk" variable be deprecated - because it is annotated by a value that implements Deprecated.

That might require tracking constant values, not names.

I've been meaning to add tests for this for a while, so good job Johnni :)

The spec says:

" ... a constant identical to the constant @­proxy defined in dart:core. "

so I'm sending this bug to analyzer land.

Set owner to @gbracha.
Removed Area-Language label.
Added Area-Analyzer, Area-dart2js, Accepted labels.

Removed the owner.
Removed Priority-Unassigned, Area-dart2js labels.
Added Priority-Medium label.

Set owner to @stereotype441.
Added Started label.

I did some preliminary work on this ages ago. The plan was to:

1. Don't report warnings that can be suppressed by @proxy in the resolver; instead, store enough information in the AST that the errors can be reported later by the ErrorVerifier.
2. Use constant evaluation to determine the values of annotations.
3. In the ErrorVerifier, make use of the constant evaluation results to determine whether a class is annotated with @proxy, and use that to decide whether to issue the warning or not.

I believe steps 1 and 2 have been completed.