Scoping behavior of annotations disagrees with spec

[stereotype441]

The following weird program is accepted by both the analyzer and the CFE:

class A {
  const A(void Function() x);
}
class C<@A(B) T> {
  static void B() {}
}
main() {
  new C<int>();
}

This seems to contradict the spec, which says "Type parameters are declared in the type parameter scope of a class or function" (15 Generics) and "The constant expression given in an annotation is type checked and evaluated in the scope surrounding the declaration being annotated" (16 Metadata). Together these seems to imply that the reference to B in @A(B) should be an error, because there is no declaration of B in scope.

[stereotype441]

Digging a little deeper, the analyzer and CFE seem to be using different mechanisms to perform the (IMHO erroneous) resolution of B. The analyzer seems to resolve it via an implicit reference to this (which seems wrong, because this isn't available in annotations), and the CFE seems to resolve it via the class scope (which seems wrong, because the annotation is outside the class body). You can see the difference if you try analyzing/compiling this example:

class A {
  const A(void Function() x);
}
class B {}
class C<@A(B) T extends B> {
  static void B() {}
}
main() {
  new C<B>();
}

This example is accepted by the CFE, but rejected by the analyzer. The analyzer gives this error message:

error • test.dart:5:12 • The argument type 'Type' can't be assigned to the parameter type 'void Function()'. • argument_type_not_assignable

The fact that the CFE accepts this code strongly suggests that it is interpreting the B in @A(B) as referring to static void B() (otherwise there would be a type mismatch in the call to A's constructor), but it is interpreting the B in extends B as referring to class B (otherwise new C<B>() would not work).

The analyzer's error message strongly suggests that it is interpreting the B in both @A(B) and extends B as referring to class B.

My understanding of the spec is that the analyzer's interpretation is correct.

[stereotype441]

@eernstg Is my interpretation of the spec correct here? I believe the first example should be an unresolved identifier error (because there is no B in scope at the site of @A(B)), and the second example should be a type mismatch error (because the B in @A(B) should be interpreted as referring to class B)

[stereotype441]

Note: here is a further illustration that the analyzer is resolving annotations on type arguments via implicit this:

class A {
  const A(void Function() x);
}
class C {
  static void B() {}
}
extension E<@A(B) T> on C {}
main() {}

The analyzer reports no error for this, because the B in @A(B) is resolved to the static method C.B. The CFE rejects it, reporting Error: Getter not found: 'B'.

[eernstg]

Good catch! ;-)

the first example should be an unresolved identifier error ..
the second example should be a type mismatch error

Agreed.

[stereotype441]

In discussion with @leafpetersen the other day, we decided that it's extremely unlikely that anyone is taking advantage of this scoping bug, so there's no need to tie the fix to a particular language version to assist folks in migrating. We can just fix it, provided that we make a note in the changelog.

I just ran an experimental fix (https://dart-review.googlesource.com/c/sdk/+/209940/2) through google3 and found no failures, confirming that no one is taking advantage of this bug anywhere in internal sources. So I'm going to proceed with the full bug fix.

[stereotype441]

Fixed by dart-lang/sdk@f5a3bce