Convert opt-in elements to legacy when resolving annotations.

Change-Id: Ifc32ec66e9e45dcaa206c662785bb7d4c054b701
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/133166
Reviewed-by: Brian Wilkerson <brianwilkerson@google.com>
Commit-Queue: Konstantin Shcheglov <scheglov@google.com>

Author: scheglov

pkg/analyzer/lib/src/generated/element_resolver.dart

@@ -1094,6 +1094,7 @@ class ElementResolver extends SimpleAstVisitor<void> {
       if (element1 is ClassElement) {
         constructor = _instantiateAnnotationClass(element1)
             .lookUpConstructor(null, _definingLibrary);
+        constructor = _resolver.toLegacyElement(constructor);
       } else if (element1 == null) {
         undefined = true;
       }
@@ -1107,6 +1108,7 @@ class ElementResolver extends SimpleAstVisitor<void> {
       // Class.CONST - not resolved yet
       if (element1 is ClassElement) {
         element2 = element1.lookUpGetter(nameNode2.name, _definingLibrary);
+        element2 = _resolver.toLegacyElement(element2);
       }
       // prefix.CONST or Class.CONST
       if (element2 is PropertyAccessorElement) {
@@ -1118,11 +1120,13 @@ class ElementResolver extends SimpleAstVisitor<void> {
       // prefix.Class()
       if (element2 is ClassElement) {
         constructor = element2.unnamedConstructor;
+        constructor = _resolver.toLegacyElement(constructor);
       }
       // Class.constructor(args)
       if (element1 is ClassElement) {
         constructor = _instantiateAnnotationClass(element1)
             .lookUpConstructor(nameNode2.name, _definingLibrary);
+        constructor = _resolver.toLegacyElement(constructor);
         nameNode2.staticElement = constructor;
       }
       if (element1 == null && element2 == null) {
@@ -1141,6 +1145,7 @@ class ElementResolver extends SimpleAstVisitor<void> {
         PropertyAccessorElement getter =
             element2.lookUpGetter(name3, _definingLibrary);
         if (getter != null) {
+          getter = _resolver.toLegacyElement(getter);
           nameNode3.staticElement = getter;
           annotation.element = getter;
           _resolveAnnotationElementGetter(annotation, getter);
@@ -1149,6 +1154,7 @@ class ElementResolver extends SimpleAstVisitor<void> {
         // prefix.Class.constructor(args)
         constructor = _instantiateAnnotationClass(element2)
             .lookUpConstructor(name3, _definingLibrary);
+        constructor = _resolver.toLegacyElement(constructor);
         nameNode3.staticElement = constructor;
       } else if (element2 == null) {
         undefined = true;

pkg/analyzer/test/src/dart/resolution/metadata_test.dart

@@ -2,7 +2,10 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+import 'package:analyzer/dart/analysis/features.dart';
 import 'package:analyzer/dart/ast/ast.dart';
+import 'package:analyzer/src/generated/engine.dart';
+import 'package:analyzer/src/test_utilities/find_element.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
@@ -12,6 +15,7 @@ import 'driver_resolution.dart';
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(MetadataResolutionTest);
+    defineReflectiveTests(MetadataResolutionWithNnbdTest);
   });
 }
 
@@ -174,3 +178,220 @@ class B {}
     return buffer.toString();
   }
 }
+
+@reflectiveTest
+class MetadataResolutionWithNnbdTest extends DriverResolutionTest {
+  @override
+  AnalysisOptionsImpl get analysisOptions => AnalysisOptionsImpl()
+    ..contextFeatures = FeatureSet.forTesting(
+        sdkVersion: '2.7.0', additionalFeatures: [Feature.non_nullable]);
+
+  ImportFindElement get import_a {
+    return findElement.importFind('package:test/a.dart');
+  }
+
+  @override
+  bool get typeToStringWithNullability => true;
+
+  test_optIn_fromOptOut_class() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A {
+  const A(int a);
+}
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart';
+
+@A(0)
+void f() {}
+''');
+
+    assertElement2(
+      findNode.simple('A('),
+      declaration: import_a.class_('A'),
+    );
+
+    assertElement2(
+      findNode.annotation('@A'),
+      declaration: import_a.unnamedConstructor('A'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_class_constructor() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A {
+  const A.named(int a);
+}
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart';
+
+@A.named(0)
+void f() {}
+''');
+
+    assertElement2(
+      findNode.simple('A.named('),
+      declaration: import_a.class_('A'),
+    );
+
+    assertElement2(
+      findNode.annotation('@A'),
+      declaration: import_a.constructor('named', of: 'A'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_class_getter() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A {
+  const foo = 0;
+}
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart';
+
+@A.foo
+void f() {}
+''');
+
+    assertElement2(
+      findNode.simple('A.foo'),
+      declaration: import_a.class_('A'),
+    );
+
+    assertElement2(
+      findNode.annotation('@A.foo'),
+      declaration: import_a.getter('foo'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_getter() async {
+    newFile('/test/lib/a.dart', content: r'''
+const foo = 0;
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart';
+
+@foo
+void f() {}
+''');
+
+    assertElement2(
+      findNode.annotation('@foo'),
+      declaration: import_a.topGet('foo'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_prefix_class() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A {
+  const A(int a);
+}
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart' as a;
+
+@a.A(0)
+void f() {}
+''');
+
+    assertElement2(
+      findNode.simple('A('),
+      declaration: import_a.class_('A'),
+    );
+
+    assertElement2(
+      findNode.annotation('@a.A'),
+      declaration: import_a.unnamedConstructor('A'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_prefix_class_constructor() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A {
+  const A.named(int a);
+}
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart' as a;
+
+@a.A.named(0)
+void f() {}
+''');
+
+    assertElement2(
+      findNode.simple('A.named('),
+      declaration: import_a.class_('A'),
+    );
+
+    assertElement2(
+      findNode.annotation('@a.A'),
+      declaration: import_a.constructor('named', of: 'A'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_prefix_class_getter() async {
+    newFile('/test/lib/a.dart', content: r'''
+class A {
+  const foo = 0;
+}
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart' as a;
+
+@a.A.foo
+void f() {}
+''');
+
+    assertElement2(
+      findNode.simple('A.foo'),
+      declaration: import_a.class_('A'),
+    );
+
+    assertElement2(
+      findNode.annotation('@a.A'),
+      declaration: import_a.getter('foo'),
+      isLegacy: true,
+    );
+  }
+
+  test_optIn_fromOptOut_prefix_getter() async {
+    newFile('/test/lib/a.dart', content: r'''
+const foo = 0;
+''');
+
+    await assertNoErrorsInCode(r'''
+// @dart = 2.7
+import 'a.dart' as a;
+
+@a.foo
+void f() {}
+''');
+
+    assertElement2(
+      findNode.annotation('@a.foo'),
+      declaration: import_a.topGet('foo'),
+      isLegacy: true,
+    );
+  }
+}

pkg/analyzer/test/src/dart/resolution/resolution.dart

@@ -143,6 +143,32 @@ mixin ResolutionTest implements ResourceProviderMixin {
     expect(actual, same(expected));
   }
 
+  void assertElement2(
+    Object nodeOrElement, {
+    @required Element declaration,
+    bool isLegacy = false,
+    Map<String, String> substitution = const {},
+  }) {
+    Element element;
+    if (nodeOrElement is AstNode) {
+      element = getNodeElement(nodeOrElement);
+    } else {
+      element = nodeOrElement as Element;
+    }
+
+    var actualDeclaration = element?.declaration;
+    expect(actualDeclaration, same(declaration));
+
+    if (element is Member) {
+      expect(element.isLegacy, isLegacy);
+      assertSubstitution(element.substitution, substitution);
+    } else {
+      if (isLegacy || substitution.isNotEmpty) {
+        fail('Expected to be a Member: (${element.runtimeType}) $element');
+      }
+    }
+  }
+
   void assertElementLibraryUri(Element element, String expected) {
     var uri = element.library.source.uri;
     expect('$uri', expected);