Only generate dynamic calls when class has generic params (#1388)

Currently, a dynamic call is generated when a field is a function
(previously added [back in 2018](#498)). Without the dynamic call, [this test](https://github.com/google/built_value.dart/blob/f20857b873aa6c77395b75aa18a4c03b80f18017/end_to_end_test/test/generics_test.dart#L71-L81)
fails. The error message is:

```
00:00 +9 -1: GenericFunction can be compared [E]                                                   │
  type '(int) => Null' is not a subtype of type '(dynamic) => dynamic'                             │
  package:end_to_end_test/generics.g.dart 1726:58  _$GenericFunction.==                            │
  test/generics_test.dart 77:63                    main.<fn>.<fn>
```

In this commit, only use dynamic calls when the enclosing class has
generic parameters. This should eliminate a significant number of
dynamic call generation in cases that don't need it.

Ideally we would only generate the dynamic call when the *field* is a
function and uses type parameters from the enclosing class, but my
understanding is that is much more complex and requires deeper
integration with the analyzer.

The *.g.dart files were regenerated by locally modifying the pubspec of
end_to_end_test to use dependency_overrides to point to the local repo
(not sure if this is the right approach).

Motivation: Dynamic modules do not support dynamic calls and the
current generation of dynamic calls makes using built_value in dynamic
modules problematic. See b/481568738 for details.

Tested: Running the tests, and also doing an internal global presubmit
with this change.

Author: jiahaog

built_value_generator/lib/src/value_source_class.dart

@@ -1354,7 +1354,10 @@ abstract class ValueSourceClass
     result.writeln('bool operator==(Object other) {');
     result.writeln('  if (identical(other, this)) return true;');
 
-    if (comparedFunctionFields.isNotEmpty) {
+    var needsDynamic =
+        comparedFunctionFields.isNotEmpty && genericParameters.isNotEmpty;
+
+    if (needsDynamic) {
       result.writeln('  final dynamic _\$dynamicOther = other;');
     }
     result.writeln('  return other is $name${forBuilder ? 'Builder' : ''}');
@@ -1364,7 +1367,7 @@ abstract class ValueSourceClass
         comparedFields.map((field) {
           var nameOrThisDotName =
               field.name == 'other' ? 'this.other' : field.name;
-          return field.isFunctionType
+          return needsDynamic && field.isFunctionType
               ? '$nameOrThisDotName == _\$dynamicOther.${field.name}'
               : '$nameOrThisDotName == other.${field.name}';
         }).join('&&'),

built_value_generator/test/built_value_generator_test.dart

@@ -880,6 +880,37 @@ abstract class NestedValue implements Built<NestedValue, NestedValueBuilder> {
               '1. Make builder field nestedValue have `nestedBuilder: false` in order to use `comparableBuilders: true`.'));
     });
 
+    test('uses dynamic for equality check on function fields with generics',
+        () async {
+      expect(
+          await generate('''library value;
+import 'package:built_value/built_value.dart';
+part 'value.g.dart';
+abstract class Value<T> implements Built<Value<T>, ValueBuilder<T>> {
+  Value._();
+  factory Value([void Function(ValueBuilder<T>) updates]) = _\$Value<T>;
+  void Function(T) get callback;
+}
+'''),
+          contains(r'final dynamic _$dynamicOther = other;'));
+    });
+
+    test(
+        'does not use dynamic for equality check on function fields without generics',
+        () async {
+      expect(
+          await generate('''library value;
+import 'package:built_value/built_value.dart';
+part 'value.g.dart';
+abstract class Value implements Built<Value, ValueBuilder> {
+  Value._();
+  factory Value([void Function(ValueBuilder) updates]) = _\$Value;
+  void Function(int) get callback;
+}
+'''),
+          isNot(contains(r'dynamicOther')));
+    });
+
     test('cleans generated class names for private classes', () async {
       expect(
           await generate('''library value;