Improve notifier error handling

packages/riverpod_generator/CHANGELOG.md

@@ -1,3 +1,10 @@
+## Unreleased patch
+
+- Improved error handling if:
+  - a Notifier has no default constructor
+  - a Notifier has has a default constructor but with required parameters
+  - a Notifier is abstract
+
 ## 2.3.9 - 2023-11-27
 
 - `riverpod_annotation` upgraded to `2.3.3`

packages/riverpod_generator/lib/src/templates/class_based_provider.dart

@@ -1,6 +1,7 @@
 import 'package:riverpod_analyzer_utils/riverpod_analyzer_utils.dart';
 import '../models.dart';
 import '../riverpod_generator.dart';
+import '../validation.dart';
 import 'template.dart';
 
 String providerNameFor(
@@ -81,7 +82,10 @@ class ClassBasedProviderTemplate extends Template {
         'Expected a class-based provider with no parameter',
       );
     }
+
+    validateClassBasedProvider(provider);
   }
+
   final ClassBasedProviderDeclaration provider;
   final String notifierTypedefName;
   final String hashFn;

packages/riverpod_generator/lib/src/templates/family.dart

@@ -4,6 +4,7 @@ import 'package:riverpod_analyzer_utils/riverpod_analyzer_utils.dart';
 
 import '../models.dart';
 import '../riverpod_generator.dart';
+import '../validation.dart';
 import 'class_based_provider.dart';
 import 'parameters.dart';
 import 'template.dart';
@@ -121,6 +122,8 @@ ${parameters.map((e) => '        ${e.name}: ${e.name},\n').join()}
     required String hashFn,
     required BuildYamlOptions options,
   }) {
+    validateClassBasedProvider(provider);
+
     var leading = '';
     if (!provider.annotation.element.keepAlive) {
       leading = 'AutoDispose';

packages/riverpod_generator/lib/src/validation.dart

@@ -0,0 +1,31 @@
+import 'package:collection/collection.dart';
+import 'package:riverpod_analyzer_utils/riverpod_analyzer_utils.dart';
+import 'package:source_gen/source_gen.dart';
+
+void validateClassBasedProvider(ClassBasedProviderDeclaration provider) {
+  // Assert that the class is not abstract
+  if (provider.node.abstractKeyword != null) {
+    throw InvalidGenerationSourceError(
+      '`@riverpod` can only be used on concrete classes.',
+      element: provider.node.declaredElement,
+    );
+  }
+
+  // Assert that the provider has a default constructor
+  final constructor = provider.node.declaredElement!.constructors
+      .firstWhereOrNull((e) => e.isDefaultConstructor);
+  if (constructor == null) {
+    throw InvalidGenerationSourceError(
+      'The class ${provider.node.name} must have a default constructor.',
+      element: provider.node.declaredElement,
+    );
+  }
+
+  // Assert that the default constructor can be called with no parameter
+  if (constructor.parameters.any((e) => e.isRequired)) {
+    throw InvalidGenerationSourceError(
+      'The default constructor of ${provider.node.name} must have not have required parameters.',
+      element: constructor,
+    );
+  }
+}

packages/riverpod_generator/test/error_test.dart

@@ -0,0 +1,147 @@
+import 'dart:convert';
+import 'dart:io';
+
+import 'package:analyzer/dart/analysis/results.dart';
+import 'package:analyzer/dart/analysis/utilities.dart';
+import 'package:path/path.dart' as path;
+import 'package:riverpod_generator/src/riverpod_generator.dart';
+import 'package:source_gen/source_gen.dart';
+import 'package:test/test.dart';
+
+void main() {
+  group('Notifiers', () {
+    group('with arguments', () {
+      test('should throw if the class is abstract', () async {
+        const source = r'''
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+@riverpod
+abstract class MyNotifier extends _$MyNotifier {
+  @override
+  int build(int a) => 0;
+}
+''';
+
+        await expectLater(
+          () => compile(source),
+          throwsA(isA<InvalidGenerationSourceError>()),
+        );
+      });
+
+      test('should throw if there is no default constructor', () async {
+        const source = r'''
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+@riverpod
+class MyNotifier extends _$MyNotifier {
+  MyNotifier._();
+
+  @override
+  int build(int a) => 0;
+}
+''';
+
+        await expectLater(
+          () => compile(source),
+          throwsA(isA<InvalidGenerationSourceError>()),
+        );
+      });
+
+      test('should throw if the default constructor has required parameters',
+          () async {
+        const source = r'''
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+@riverpod
+class MyNotifier extends _$MyNotifier {
+  MyNotifier(int a);
+
+  @override
+  int build(int a) => 0;
+}
+''';
+
+        await expectLater(
+          () => compile(source),
+          throwsA(isA<InvalidGenerationSourceError>()),
+        );
+      });
+    });
+
+    group('without arguments', () {
+      test('should throw if the class is abstract', () async {
+        const source = r'''
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+@riverpod
+abstract class MyNotifier extends _$MyNotifier {
+  @override
+  int build() => 0;
+}
+''';
+
+        await expectLater(
+          () => compile(source),
+          throwsA(isA<InvalidGenerationSourceError>()),
+        );
+      });
+    });
+  });
+}
+
+void tearDownTmp() {
+  addTearDown(() {
+    final tmp = Directory('.dart_tool/test');
+    if (tmp.existsSync()) {
+      tmp.deleteSync(recursive: true);
+    }
+  });
+}
+
+File createTmpFile(String filePath) {
+  tearDownTmp();
+
+  final file = File(path.join('.dart_tool', 'test', filePath));
+  file.createSync(recursive: true);
+
+  return file;
+}
+
+Future<String> compile(String source) async {
+  final generator = RiverpodGenerator(const {});
+
+  final main = createTmpFile('lib/main.dart')..writeAsStringSync(source);
+  final pubspec = createTmpFile('pubspec.yaml')..writeAsStringSync('''
+name: test_app
+
+environment:
+  sdk: ">=3.0.0 <4.0.0"
+
+dependencies:
+  riverpod_annotation: ^2.3.3
+''');
+
+  await runPubGet(pubspec.parent);
+
+  final result = await resolveFile2(path: main.absolute.path);
+
+  result as ResolvedUnitResult;
+
+  return generator.generateForUnit([result.unit]);
+}
+
+Future<void> runPubGet(Directory parent) async {
+  final process = await Process.start(
+    'dart',
+    ['pub', 'get'],
+    workingDirectory: parent.path,
+  );
+
+  final exitCode = await process.exitCode;
+  if (exitCode != 0) {
+    throw Exception(
+      'flutter pub get failed with exit code $exitCode\n'
+      '${await process.stdout.transform(utf8.decoder).join()}',
+    );
+  }
+}