validation of @nonvirtual use

see: #34378

Change-Id: I0fe67c56bf7c08f211b6bf89d84c5495e32601a7
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/122742
Reviewed-by: Konstantin Shcheglov <[email protected]>
Commit-Queue: Phil Quitslund <[email protected]>

Author: pq

pkg/analyzer/lib/dart/element/element.dart

@@ -706,6 +706,10 @@ abstract class ElementAnnotation implements ConstantEvaluationTarget {
   /// overriding methods to call super.
   bool get isMustCallSuper;
 
+  /// Return `true` if this annotation marks the associated member as being
+  /// non-virtual.
+  bool get isNonVirtual;
+
   /// Return `true` if this annotation marks the associated type as
   /// having "optional" type arguments.
   bool get isOptionalTypeArgs;

pkg/analyzer/lib/error/error.dart

@@ -370,6 +370,7 @@ const List<ErrorCode> errorCodeValues = const [
   HintCode.INVALID_FACTORY_METHOD_IMPL,
   HintCode.INVALID_IMMUTABLE_ANNOTATION,
   HintCode.INVALID_LITERAL_ANNOTATION,
+  HintCode.INVALID_NON_VIRTUAL_ANNOTATION,
   HintCode.INVALID_REQUIRED_NAMED_PARAM,
   HintCode.INVALID_REQUIRED_OPTIONAL_POSITIONAL_PARAM,
   // ignore: deprecated_member_use_from_same_package

pkg/analyzer/lib/src/dart/element/element.dart

@@ -2431,6 +2431,9 @@ class ElementAnnotationImpl implements ElementAnnotation {
   /// annotations.
   static String _NG_META_LIB_NAME = "angular.meta";
 
+  /// The name of the top-level variable used to mark a member as being nonVirtual.
+  static String _NON_VIRTUAL_VARIABLE_NAME = "nonVirtual";
+
   /// The name of the top-level variable used to mark a method as being expected
   /// to override an inherited method.
   static String _OVERRIDE_VARIABLE_NAME = "override";
@@ -2554,6 +2557,12 @@ class ElementAnnotationImpl implements ElementAnnotation {
       element.name == _MUST_CALL_SUPER_VARIABLE_NAME &&
       element.library?.name == _META_LIB_NAME;
 
+  @override
+  bool get isNonVirtual =>
+      element is PropertyAccessorElement &&
+      element.name == _NON_VIRTUAL_VARIABLE_NAME &&
+      element.library?.name == _META_LIB_NAME;
+
   @override
   bool get isOptionalTypeArgs =>
       element is PropertyAccessorElement &&

pkg/analyzer/lib/src/dart/error/hint_codes.dart

@@ -356,6 +356,19 @@ class HintCode extends AnalyzerErrorCode {
       "Only const constructors can have the `@literal` annotation.",
       hasPublishedDocs: true);
 
+  /**
+   * This hint is generated anywhere where `@nonVirtual` annotates something
+   * other than a non-abstract instance member in a class or mixin.
+   *
+   * Parameters:
+   * 0: the name of the member
+   */
+  static const HintCode INVALID_NON_VIRTUAL_ANNOTATION = const HintCode(
+      'INVALID_NON_VIRTUAL_ANNOTATION',
+      "The member '{0}' is annotated with '@nonVirtual' but only concrete "
+          "instance members of classes or mixins can be annotated with it.",
+      correction: "Remove @nonVirtual.");
+
   /**
    * This hint is generated anywhere where `@required` annotates a named
    * parameter with a default value.

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

@@ -155,6 +155,27 @@ class BestPracticesVerifier extends RecursiveAstVisitor<void> {
         _errorReporter
             .reportErrorForNode(HintCode.INVALID_LITERAL_ANNOTATION, node, []);
       }
+    } else if (element?.isNonVirtual == true) {
+      if (parent is FieldDeclaration) {
+        if (parent.isStatic) {
+          _errorReporter.reportErrorForNode(
+              HintCode.INVALID_NON_VIRTUAL_ANNOTATION,
+              node,
+              [node.element.name]);
+        }
+      } else if (parent is MethodDeclaration) {
+        if (parent.parent is ExtensionDeclaration ||
+            parent.isStatic ||
+            parent.isAbstract) {
+          _errorReporter.reportErrorForNode(
+              HintCode.INVALID_NON_VIRTUAL_ANNOTATION,
+              node,
+              [node.element.name]);
+        }
+      } else {
+        _errorReporter.reportErrorForNode(
+            HintCode.INVALID_NON_VIRTUAL_ANNOTATION, node, [node.element.name]);
+      }
     } else if (element?.isSealed == true) {
       if (!(parent is ClassDeclaration || parent is ClassTypeAlias)) {
         _errorReporter.reportErrorForNode(

pkg/analyzer/lib/src/test_utilities/package_mixin.dart

@@ -33,6 +33,7 @@ const _Factory factory = const _Factory();
 const Immutable immutable = const Immutable();
 const _Literal literal = const _Literal();
 const _MustCallSuper mustCallSuper = const _MustCallSuper();
+const _NonVirtual nonVirtual = const _NonVirtual();
 const _OptionalTypeArgs optionalTypeArgs = const _OptionalTypeArgs();
 const _Protected protected = const _Protected();
 const Required required = const Required();
@@ -55,6 +56,9 @@ class _Literal {
 class _MustCallSuper {
   const _MustCallSuper();
 }
+class _NonVirtual {
+  const _NonVirtual();
+}
 class _OptionalTypeArgs {
   const _OptionalTypeArgs();
 }

pkg/analyzer/test/src/diagnostics/invalid_nonVirtual_annotation_test.dart

@@ -0,0 +1,282 @@
+// Copyright (c) 2019, the Dart project authors. Please see the AUTHORS file
+// 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/src/error/codes.dart';
+import 'package:analyzer/src/test_utilities/package_mixin.dart';
+import 'package:test_reflective_loader/test_reflective_loader.dart';
+
+import '../dart/resolution/driver_resolution.dart';
+
+main() {
+  defineReflectiveSuite(() {
+    defineReflectiveTests(InvalidNonVirtualAnnotationTest);
+  });
+}
+
+@reflectiveTest
+class InvalidNonVirtualAnnotationTest extends DriverResolutionTest
+    with PackageMixin {
+  setUp() {
+    super.setUp();
+    addMetaPackage();
+  }
+
+  test_class() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+class C {}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_class_abstract_member() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+abstract class C {
+  @nonVirtual
+  void m();
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 55, 11),
+    ]);
+  }
+
+  test_class_getter() async {
+    await assertNoErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+class C {
+  @nonVirtual
+  int get g => 0;
+}
+''');
+  }
+
+  test_class_instance_field() async {
+    await assertNoErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+class C {
+  @nonVirtual
+  int f;
+}
+''');
+  }
+
+  test_class_instance_member() async {
+    await assertNoErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+class C {
+  @nonVirtual
+  void m() {
+  }
+}
+''');
+  }
+
+  test_class_setter() async {
+    await assertNoErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+class C {
+  @nonVirtual
+  set s(int v) {}
+}
+''');
+  }
+
+  test_class_static_field() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+class C {
+   @nonVirtual
+   static int f;
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 47, 11),
+    ]);
+  }
+
+  test_class_static_method() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+class C {
+   @nonVirtual
+   static void m() {}
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 47, 11),
+    ]);
+  }
+
+  test_enum() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+enum E {
+  a, b, c
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_enum_constant() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+enum E {
+  @nonVirtual
+  a,
+  b, c
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 45, 11),
+    ]);
+  }
+
+  test_extension() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+extension E on Object {}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_extension_member() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+extension E on Object {
+   @nonVirtual
+   void m() {}
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 61, 11),
+    ]);
+  }
+
+  test_import() async {
+    await assertErrorsInCode(r'''
+@nonVirtual
+import 'package:meta/meta.dart';
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 0, 11),
+    ]);
+  }
+
+  test_mixin() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+mixin M {}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_mixin_instance_member() async {
+    await assertNoErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+mixin M {
+  @nonVirtual
+  void m() {}
+}
+''');
+  }
+
+  test_mixin_static_field() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+mixin M {
+  @nonVirtual
+  static int f;
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 46, 11),
+    ]);
+  }
+
+  test_mixin_static_method() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+mixin M {
+  @nonVirtual
+  static void m() {}
+}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 46, 11),
+    ]);
+  }
+
+  test_top_level_function() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+m() {}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_top_level_getter() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+int get g =>  0;
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_top_level_setter() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+set s(int v) {}
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_top_level_var() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+int x;
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+
+  test_typedef() async {
+    await assertErrorsInCode(r'''
+import 'package:meta/meta.dart';
+
+@nonVirtual
+typedef bool predicate(Object o);
+''', [
+      error(HintCode.INVALID_NON_VIRTUAL_ANNOTATION, 34, 11),
+    ]);
+  }
+}