Merge pull request #1002 from Workiva/remove-mirrors

FED-4507 Analyzer plugin: fix in Dart 3, support analyzer 6.x

Author: btr-rmconsole-1[bot]

CHANGELOG.md

@@ -1,5 +1,10 @@
 # OverReact Changelog
 
+## Unreleased
+- Analyzer plugin
+  - Fix startup error (AOT compilation) in Dart 3
+  - Allow analyzer 6.x, allowing parsing language versions <=3.7  
+
 ## 5.6.1
 - Allow w_common 4 #1004 https://github.com/Workiva/over_react/pull/1004
 

lib/src/builder/parsing/meta.dart

@@ -12,38 +12,27 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import 'dart:mirrors' as mirrors;
-
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:build/build.dart' show log;
 import 'package:collection/collection.dart' show IterableExtension;
-import 'package:over_react/src/builder/vendor/transformer_utils/transformer_utils.dart';
 
-import 'ast_util.dart';
+import 'package:over_react/src/component_declaration/annotations.dart' as a;
 
-/// Uses reflection to instantiate and return the first annotation on [member] of type
-/// [T], or null if no matching annotations are found.
-///
-/// > See [instantiateAnnotation] for more information.
-T? instantiateAnnotationTyped<T>(AnnotatedNode member,
-    {dynamic Function(Expression argument)? onUnsupportedArgument}) {
-  return instantiateAnnotation(member, T, onUnsupportedArgument: onUnsupportedArgument) as T?;
-}
+import '../vendor/transformer_utils/src/analyzer_helpers.dart';
 
-/// Returns the first annotation AST node on [member] of type [annotationType],
+/// Returns the first annotation AST node on [node] of type [T],
 /// or null if no matching annotations are found.
-Annotation? _getMatchingAnnotation(AnnotatedNode member, Type annotationType) {
-  // Be sure to use `originalDeclaration` so that generic parameters work.
-  final classMirror = mirrors.reflectClass(annotationType).originalDeclaration;
-  final className = mirrors.MirrorSystem.getName(classMirror.simpleName);
-  return member.getAnnotationWithName(className);
-}
+Annotation? _getMatchingAnnotationFromGeneric<T extends Object>(AnnotatedNode node) =>
+    _getMatchingAnnotation(_AnnotationClass.fromGeneric<T>(), node);
+
+/// Returns the first annotation AST node on [node] of type [annotationClass],
+/// or null if no matching annotations are found.
+Annotation? _getMatchingAnnotation(_AnnotationClass annotationClass, AnnotatedNode node) =>
+    node.metadata.firstWhereOrNull((m) => m.name.name == annotationClass.className);
 
 /// Utility class that allows partial instantiation of annotations, to support reading
 /// annotation data in a context without a resolved AST. See [isIncomplete] for more info.
-///
-/// Based off of [NodeWithMeta].
-class InstantiatedMeta<TMeta> {
+class InstantiatedMeta<TMeta extends Object> {
   /// The node of the [TMeta] annotation, if it exists.
   final Annotation metaNode;
 
@@ -62,8 +51,8 @@ class InstantiatedMeta<TMeta> {
   /// The original node will be available via [node].
   ///
   /// The instantiated annotation will be available via [value].
-  static InstantiatedMeta<T>? fromNode<T>(AnnotatedNode node) {
-    final metaNode = _getMatchingAnnotation(node, T);
+  static InstantiatedMeta<T>? fromNode<T extends Object>(AnnotatedNode node) {
+    final metaNode = _getMatchingAnnotationFromGeneric<T>(node);
     if (metaNode == null) return null;
 
     final unsupportedArguments = <Expression>[];
@@ -99,7 +88,7 @@ class InstantiatedMeta<TMeta> {
 /// Utility that allows partial instantiation of a `Component`/`Component2` annotation.
 ///
 /// See superclass for more information.
-class InstantiatedComponentMeta<TMeta> extends InstantiatedMeta<TMeta> {
+class InstantiatedComponentMeta<TMeta extends Object> extends InstantiatedMeta<TMeta> {
   static const String _subtypeOfParamName = 'subtypeOf';
 
   final Identifier? subtypeOfValue;
@@ -108,7 +97,7 @@ class InstantiatedComponentMeta<TMeta> extends InstantiatedMeta<TMeta> {
       Annotation metaNode, TMeta meta, List<Expression> unsupportedArguments, this.subtypeOfValue)
       : super._(metaNode, meta, unsupportedArguments);
 
-  static InstantiatedComponentMeta<T>? fromNode<T>(AnnotatedNode node) {
+  static InstantiatedComponentMeta<T>? fromNode<T extends Object>(AnnotatedNode node) {
     try {
       final instantiated = InstantiatedMeta.fromNode<T>(node);
       if (instantiated == null) return null;
@@ -140,3 +129,106 @@ class InstantiatedComponentMeta<TMeta> extends InstantiatedMeta<TMeta> {
     }
   }
 }
+
+T? instantiateAnnotationTyped<T extends Object>(
+  AnnotatedNode node, {
+  dynamic Function(Expression argument)? onUnsupportedArgument,
+}) {
+  final annotationClass = _AnnotationClass.fromGeneric<T>();
+
+  final annotation = _getMatchingAnnotation(annotationClass, node);
+  if (annotation == null) return null;
+
+  final args = parseAnnotationArgs(annotation, onUnsupportedArgument: onUnsupportedArgument);
+  S namedArg<S>(String name) => args.named[name] as S;
+
+  switch (annotationClass) {
+    case _AnnotationClass.props:
+      return a.Props(
+        keyNamespace: namedArg('keyNamespace'),
+        disableRequiredPropValidation: namedArg('disableRequiredPropValidation'),
+        disableValidationForClassDefaultProps:
+            namedArg('disableValidationForClassDefaultProps') ?? true,
+      ) as T;
+    case _AnnotationClass.abstractProps:
+      return a.AbstractProps(
+        keyNamespace: namedArg('keyNamespace'),
+      ) as T;
+    case _AnnotationClass.propsMixin:
+      // ignore: deprecated_member_use_from_same_package
+      return a.PropsMixin(
+        keyNamespace: namedArg('keyNamespace'),
+      ) as T;
+    case _AnnotationClass.state:
+      return a.State(
+        keyNamespace: namedArg('keyNamespace'),
+      ) as T;
+    case _AnnotationClass.abstractState:
+      return a.AbstractState(
+        keyNamespace: namedArg('keyNamespace'),
+      ) as T;
+    case _AnnotationClass.stateMixin:
+      // ignore: deprecated_member_use_from_same_package
+      return a.StateMixin(
+        keyNamespace: namedArg('keyNamespace'),
+      ) as T;
+    case _AnnotationClass.component2:
+      return a.Component2(
+        isWrapper: namedArg('isWrapper') ?? false,
+        subtypeOf: namedArg('subtypeOf'),
+        isErrorBoundary: namedArg('isErrorBoundary') ?? false,
+      ) as T;
+    case _AnnotationClass.component:
+      // ignore: deprecated_member_use_from_same_package
+      return a.Component(
+        isWrapper: namedArg('isWrapper') ?? false,
+        subtypeOf: namedArg('subtypeOf'),
+      ) as T;
+    case _AnnotationClass.accessor:
+      return a.Accessor(
+        key: namedArg('key'),
+        keyNamespace: namedArg('keyNamespace'),
+        isRequired: namedArg('isRequired') ?? false,
+        isNullable: namedArg('isNullable') ?? false,
+        requiredErrorMessage: namedArg('requiredErrorMessage'),
+        doNotGenerate: namedArg('doNotGenerate') ?? false,
+      ) as T;
+  }
+}
+
+enum _AnnotationClass {
+  props('Props'),
+  abstractProps('AbstractProps'),
+  propsMixin('PropsMixin'),
+  state('State'),
+  abstractState('AbstractState'),
+  stateMixin('StateMixin'),
+  component2('Component2'),
+  component('Component'),
+  accessor('Accessor');
+
+  final String className;
+
+  const _AnnotationClass(this.className);
+
+  static _AnnotationClass fromGeneric<T>() {
+    if (_isSubtypeOf<T, a.Props>()) return _AnnotationClass.props;
+    if (_isSubtypeOf<T, a.AbstractProps>()) return _AnnotationClass.abstractProps;
+    // ignore: deprecated_member_use_from_same_package
+    if (_isSubtypeOf<T, a.PropsMixin>()) return _AnnotationClass.propsMixin;
+    if (_isSubtypeOf<T, a.State>()) return _AnnotationClass.state;
+    if (_isSubtypeOf<T, a.AbstractState>()) return _AnnotationClass.abstractState;
+    // ignore: deprecated_member_use_from_same_package
+    if (_isSubtypeOf<T, a.StateMixin>()) return _AnnotationClass.stateMixin;
+    if (_isSubtypeOf<T, a.Component2>()) return _AnnotationClass.component2;
+    // ignore: deprecated_member_use_from_same_package
+    if (_isSubtypeOf<T, a.Component>()) return _AnnotationClass.component;
+    if (_isSubtypeOf<T, a.Accessor>()) return _AnnotationClass.accessor;
+
+    throw ArgumentError('Unsupported generic: $T. Must correspond to a type in this enum.');
+  }
+}
+
+bool _isSubtypeOf<T, S>() => _SubtypeOfHelper<T>() is _SubtypeOfHelper<S>;
+
+class _SubtypeOfHelper<T> {}

lib/src/builder/util.dart

@@ -12,8 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import 'dart:mirrors';
-
 import 'package:analyzer/dart/ast/ast.dart';
 import 'package:build/build.dart' show AssetId;
 import 'package:over_react/src/builder/parsing.dart';
@@ -26,10 +24,6 @@ const privateSourcePrefix = r'_$';
 const privatePrefix = r'_';
 const publicGeneratedPrefix = r'$';
 
-String getName(Type type) {
-  return MirrorSystem.getName(reflectType(type).simpleName);
-}
-
 /// Converts [id] to a "package:" URI.
 ///
 /// This will return a schemeless URI if [id] doesn't represent a library in

lib/src/builder/vendor/transformer_utils/src/analyzer_helpers.dart

@@ -16,10 +16,7 @@
 
 library;
 
-import 'dart:mirrors' as mirrors;
-
 import 'package:analyzer/dart/ast/ast.dart';
-import 'package:collection/collection.dart' show IterableExtension;
 
 /// Returns a copy of a class [member] declaration with [body] as a new
 /// implementation.
@@ -38,19 +35,6 @@ String copyClassMember(ClassMember? member, String body) {
       'Only FieldDeclaration and MethodDeclaration are supported.');
 }
 
-/// Finds and returns all declarations within a compilation [unit] that are
-/// annotated with the given [annotation] class.
-///
-/// If this is being leveraged within a transformer, you can associate the
-/// returned [DeclarationWithMeta] instance with the asset in which it is
-/// located by passing in an [assetId].
-Iterable<CompilationUnitMember> getDeclarationsAnnotatedBy(CompilationUnit unit, Type annotation) {
-  var annotationName = _getReflectedName(annotation);
-  return unit.declarations.where((member) {
-    return member.metadata.any((meta) => meta.name.name == annotationName);
-  });
-}
-
 /// Returns the value of the specified [expression] AST node if it represents a literal.
 ///
 /// For non-literal nodes, the return value will be the result of calling [onUnsupportedExpression] with [expression].
@@ -85,78 +69,42 @@ dynamic getValue(Expression expression,
       'Must be a uninterpolated string, boolean, integer, or null literal.');
 }
 
-/// Returns the first annotation AST node on [member] of type [annotationType],
-/// or null if no matching annotations are found.
-Annotation? getMatchingAnnotation(AnnotatedNode member, Type annotationType) {
-  // Be sure to use `originalDeclaration` so that generic parameters work.
-  final classMirror =
-      mirrors.reflectClass(annotationType).originalDeclaration as mirrors.ClassMirror;
-  String className = mirrors.MirrorSystem.getName(classMirror.simpleName);
-
-  // Find the annotation that matches [type]'s name.
-  return member.metadata.firstWhereOrNull((annotation) {
-    return _getClassName(annotation) == className;
-  });
+/// The parsed arguments of an annotation constructor call, from [parseAnnotationArgs].
+class AnnotationArgs {
+  final Map<String, dynamic> named;
+  final List<dynamic> positional;
+
+  AnnotationArgs({required this.named, required this.positional});
 }
 
-/// Uses reflection to instantiate and returns the first annotation on [member] of type
-/// [annotationType], or null if no matching annotations are found.
-///
-/// Annotation constructors are currently limited to the values supported by [getValue].
-///
-/// Naively assumes that the name of the [annotationType] class is canonical.
-dynamic instantiateAnnotation(AnnotatedNode member, Type annotationType,
+/// Returns annotation class constructor arguments parsed from [annotation],
+/// converting supported literal values via [getValue], and passing unsupported
+/// argument values through [onUnsupportedArgument].
+AnnotationArgs parseAnnotationArgs(Annotation annotation,
     {dynamic Function(Expression argument)? onUnsupportedArgument}) {
-  final matchingAnnotation = getMatchingAnnotation(member, annotationType);
-
-  // If no annotation is found, return null.
-  if (matchingAnnotation == null) {
-    return null;
-  }
-
-  final matchingAnnotationArgs = matchingAnnotation.arguments;
-  if (matchingAnnotationArgs == null) {
-    throw Exception('Annotation not invocation of constructor: `$matchingAnnotation`. '
-        'This is likely due to invalid usage of the annotation class, but could'
-        'also be a name conflict with the specified type `$annotationType`');
-  }
-
-  // Get the parameters from the annotation's AST.
-  Map<Symbol, dynamic> namedParameters = {};
+  Map<String, dynamic> namedParameters = {};
   List positionalParameters = [];
 
-  matchingAnnotationArgs.arguments.forEach((argument) {
+  annotation.arguments?.arguments.forEach((argument) {
     var onUnsupportedExpression =
         onUnsupportedArgument == null ? null : (_) => onUnsupportedArgument(argument);
 
     if (argument is NamedExpression) {
       var name = argument.name.label.name;
       var value = getValue(argument.expression, onUnsupportedExpression: onUnsupportedExpression);
 
-      namedParameters[Symbol(name)] = value;
+      namedParameters[name] = value;
     } else {
       var value = getValue(argument, onUnsupportedExpression: onUnsupportedExpression);
 
       positionalParameters.add(value);
     }
   });
 
-  // Instantiate and return an instance of the annotation using reflection.
-  String constructorName = _getConstructorName(matchingAnnotation) ?? '';
-
-  // Be sure to use `originalDeclaration` so that generic parameters work.
-  final classMirror =
-      mirrors.reflectClass(annotationType).originalDeclaration as mirrors.ClassMirror;
-
-  try {
-    var instanceMirror =
-        classMirror.newInstance(Symbol(constructorName), positionalParameters, namedParameters);
-    return instanceMirror.reflectee;
-  } catch (e, stacktrace) {
-    throw Exception('Unable to instantiate annotation: $matchingAnnotation. This is '
-        'likely due to improper usage, or a naming conflict with '
-        'annotationType $annotationType. Original error: $e. Stacktrace: $stacktrace');
-  }
+  return AnnotationArgs(
+    named: namedParameters,
+    positional: positionalParameters,
+  );
 }
 
 String _copyFieldDeclaration(FieldDeclaration decl, String initializer) {
@@ -221,31 +169,3 @@ String _copyMethodDeclaration(MethodDeclaration decl, String body) {
   result = '$result {\n$body\n  }';
   return result;
 }
-
-/// Returns the name of the class being instantiated for [annotation], or null
-/// if the annotation is not the invocation of a constructor.
-///
-/// Workaround for a Dart analyzer issue where the constructor name is included
-/// in [annotation.name].
-String _getClassName(Annotation annotation) => annotation.name.name.split('.').first;
-
-/// Returns the name of the constructor being instantiated for [annotation], or
-/// null if the annotation is not the invocation of a named constructor.
-///
-/// Workaround for a Dart analyzer issue where the constructor name is included
-/// in [annotation.name].
-String? _getConstructorName(Annotation annotation) {
-  var constructorName = annotation.constructorName?.name;
-  if (constructorName == null) {
-    var periodIndex = annotation.name.name.indexOf('.');
-    if (periodIndex != -1) {
-      constructorName = annotation.name.name.substring(periodIndex + 1);
-    }
-  }
-
-  return constructorName;
-}
-
-/// Get the name of a [type] via reflection.
-String _getReflectedName(Type type) =>
-    mirrors.MirrorSystem.getName(mirrors.reflectType(type).simpleName);