Add some basic NNBD tests and fix a type parameter rendering bug (#2227)

* nnbd opt out test

* Add new tests and fix minor bugs

* Remove superfluous method

Author: jcollins-g

lib/src/element_type.dart

@@ -235,10 +235,10 @@ class TypeParameterElementType extends DefinedElementType {
   TypeParameterType get type => super.type;
 
   @override
-  String get linkedName => name;
+  String get linkedName => '${name}${nullabilitySuffix}';
 
   @override
-  String get nameWithGenerics => name;
+  String get nameWithGenerics => '${name}${nullabilitySuffix}';
 
   @override
   DartType get _bound => type.bound;

lib/src/model/getter_setter_combo.dart

@@ -185,6 +185,8 @@ mixin GetterSetterCombo on ModelElement {
     if (hasGetter) {
       return getter.linkedReturnType;
     } else {
+      // TODO(jcollins-g): this results in the wrong span class for the return
+      // type.
       return setter.linkedParamsNoMetadataOrNames;
     }
   }

lib/src/render/element_type_renderer.dart

@@ -79,7 +79,6 @@ class ParameterizedElementTypeRendererHtml
           '</span>, <span class="type-parameter">');
       buf.write('</span>&gt;');
     }
-    buf.write(elementType.nullabilitySuffix);
     return wrapNullability(elementType, buf.toString());
   }
 }

test/model_special_cases_test.dart

@@ -42,7 +42,8 @@ void main() {
   group('Experiments', () {
     Library lateFinalWithoutInitializer,
         nnbdClassMemberDeclarations,
-        optOutOfNnbd;
+        optOutOfNnbd,
+        nullableElements;
     Class b;
 
     setUpAll(() async {
@@ -55,6 +56,9 @@ void main() {
       optOutOfNnbd = (await utils.testPackageGraphExperiments)
           .libraries
           .firstWhere((lib) => lib.name == 'opt_out_of_nnbd');
+      nullableElements = (await utils.testPackageGraphExperiments)
+          .libraries
+          .firstWhere((lib) => lib.name == 'nullable_elements');
       b = nnbdClassMemberDeclarations.allClasses
           .firstWhere((c) => c.name == 'B');
     });
@@ -142,6 +146,65 @@ void main() {
       expect(initializeMe.isLate, isTrue);
       expect(initializeMe.features, contains('late'));
     });
+
+    test('Opt out of NNBD', () {
+      var notOptedIn = optOutOfNnbd.publicProperties
+          .firstWhere((v) => v.name == 'notOptedIn');
+      expect(notOptedIn.isNNBD, isFalse);
+      expect(notOptedIn.modelType.nullabilitySuffix, isEmpty);
+    });
+
+    test('complex nullable elements are detected and rendered correctly', () {
+      var complexNullableMembers = nullableElements.allClasses
+          .firstWhere((c) => c.name == 'ComplexNullableMembers');
+      var aComplexType = complexNullableMembers.allFields
+          .firstWhere((f) => f.name == 'aComplexType');
+      var aComplexSetterOnlyType = complexNullableMembers.allFields
+          .firstWhere((f) => f.name == 'aComplexSetterOnlyType');
+      expect(complexNullableMembers.isNNBD, isTrue);
+      expect(
+          complexNullableMembers.nameWithGenerics,
+          equals(
+              'ComplexNullableMembers&lt;<wbr><span class=\"type-parameter\">T extends String?</span>&gt;'));
+      expect(
+          aComplexType.linkedReturnType,
+          equals(
+              'Map<span class="signature">&lt;<wbr><span class="type-parameter">T?</span>, <span class="type-parameter">String?</span>&gt;</span>'));
+      expect(aComplexSetterOnlyType.linkedReturnType, equals(
+          // TODO(jcollins-g): fix wrong span class for setter-only return type (#2226)
+          '<span class="parameter" id="aComplexSetterOnlyType=-param-value"><span class="type-annotation">List<span class="signature">&lt;<wbr><span class="type-parameter">Map<span class="signature">&lt;<wbr><span class="type-parameter">T?</span>, <span class="type-parameter">String?</span>&gt;</span>?</span>&gt;</span></span></span><wbr>'));
+    });
+
+    test('simple nullable elements are detected and rendered correctly', () {
+      var nullableMembers = nullableElements.allClasses
+          .firstWhere((c) => c.name == 'NullableMembers');
+      var initialized =
+          nullableMembers.allFields.firstWhere((f) => f.name == 'initialized');
+      var nullableField = nullableMembers.allFields
+          .firstWhere((f) => f.name == 'nullableField');
+      var methodWithNullables = nullableMembers.publicInstanceMethods
+          .firstWhere((f) => f.name == 'methodWithNullables');
+      var operatorStar = nullableMembers.publicInstanceOperators
+          .firstWhere((f) => f.name == 'operator *');
+      expect(nullableMembers.isNNBD, isTrue);
+      expect(
+          nullableField.linkedReturnType,
+          equals(
+              'Iterable<span class=\"signature\">&lt;<wbr><span class=\"type-parameter\">BigInt</span>&gt;</span>?'));
+      expect(
+          methodWithNullables.linkedParams,
+          equals(
+              '<span class="parameter" id="methodWithNullables-param-foo"><span class="type-annotation">String?</span> <span class="parameter-name">foo</span></span><wbr>'));
+      expect(methodWithNullables.linkedReturnType, equals('int?'));
+      expect(
+          initialized.linkedReturnType,
+          equals(
+              'Map<span class="signature">&lt;<wbr><span class="type-parameter">String</span>, <span class="type-parameter">Map</span>&gt;</span>?'));
+      expect(
+          operatorStar.linkedParams,
+          equals(
+              '<span class="parameter" id="*-param-nullableOther"><span class="type-annotation"><a href="%%__HTMLBASE_dartdoc_internal__%%nullable_elements/NullableMembers-class.html">NullableMembers</a>?</span> <span class="parameter-name">nullableOther</span></span><wbr>'));
+    });
   },
       skip: (!_nnbdExperimentAllowed.allows(_platformVersion) &&
           !_platformVersionString.contains('edge')));

testing/test_package_experiments/lib/nnbd_class_member_declarations.dart

@@ -16,12 +16,14 @@ abstract class B {
 }
 
 /// Test nullable parameters, factories, members
-abstract class C {
-  factory C.factory1(int? param, {Object? param2}) => null;
+class C {
+  C() {}
+
+  factory C.factory1(int? param, {Object? param2}) => C();
 
   int? testField;
 
-  List<int?> get testFieldNullableParameter;
+  List<int?> get testFieldNullableParameter => [];
 
-  List<Map<String, num?>>? method1();
+  List<Map<String, num?>>? method1() => null;
 }

testing/test_package_experiments/lib/nullable_elements.dart

@@ -11,7 +11,7 @@ String? get nullableGetter => null;
 String? _nullableSetter;
 
 void set nullableSetter(String? value) {
-  _nullableSetter = value;
+  _nullableSetter = _nullableSetter ??= value;
 }
 
 void some(int? nullable, String? parameters) {}
@@ -27,4 +27,12 @@ class NullableMembers {
   operator *(NullableMembers? nullableOther) => this;
 
   int? methodWithNullables(String? foo) => foo?.length;
+}
+
+class ComplexNullableMembers<T extends String?> {
+  Map<T?, String?> aComplexType = <T?, String?>{null: null};
+
+  void set aComplexSetterOnlyType(List<Map<T?, String?>?> value) => null;
+
+  X? aMethod<X extends T?>(X? f) => null;
 }