diff --git a/lib/src/element_type.dart b/lib/src/element_type.dart
index ba2da3912f..8ac70ff399 100644
--- a/lib/src/element_type.dart
+++ b/lib/src/element_type.dart
@@ -373,6 +373,10 @@ mixin Callable implements ElementType {
     return _returnType;
   }
 
+  @override
+  // TODO(jcollins-g): mustachio should not require this
+  String get linkedName;
+
   @override
   FunctionType get type => _type;
 }
diff --git a/lib/src/generator/templates.runtime_renderers.dart b/lib/src/generator/templates.runtime_renderers.dart
index e024f7adb9..52e2ca09f1 100644
--- a/lib/src/generator/templates.runtime_renderers.dart
+++ b/lib/src/generator/templates.runtime_renderers.dart
@@ -516,6 +516,26 @@ class _Renderer_Callable extends RendererBase<Callable> {
       _propertyMapCache.putIfAbsent(
           CT_,
           () => {
+                'linkedName': Property(
+                  getValue: (CT_ c) => c.linkedName,
+                  renderVariable:
+                      (CT_ c, Property<CT_> self, List<String> remainingNames) {
+                    if (remainingNames.isEmpty) {
+                      return self.getValue(c).toString();
+                    }
+                    var name = remainingNames.first;
+                    var nextProperty =
+                        _Renderer_String.propertyMap().getValue(name);
+                    return nextProperty.renderVariable(self.getValue(c),
+                        nextProperty, [...remainingNames.skip(1)]);
+                  },
+                  isNullValue: (CT_ c) => c.linkedName == null,
+                  renderValue: (CT_ c, RendererBase<CT_> r,
+                      List<MustachioNode> ast, StringSink sink) {
+                    _render_String(c.linkedName, ast, r.template, sink,
+                        parent: r);
+                  },
+                ),
                 'parameters': Property(
                   getValue: (CT_ c) => c.parameters,
                   renderVariable: (CT_ c, Property<CT_> self,
@@ -6094,73 +6114,6 @@ class _Renderer_FunctionTemplateData
   }
 }
 
-void _render_FunctionTypeElementType(FunctionTypeElementType context,
-    List<MustachioNode> ast, Template template, StringSink sink,
-    {RendererBase<Object> parent}) {
-  var renderer =
-      _Renderer_FunctionTypeElementType(context, parent, template, sink);
-  renderer.renderBlock(ast);
-}
-
-class _Renderer_FunctionTypeElementType
-    extends RendererBase<FunctionTypeElementType> {
-  static final Map<Type, Object> _propertyMapCache = {};
-  static Map<String, Property<CT_>> propertyMap<
-          CT_ extends FunctionTypeElementType>() =>
-      _propertyMapCache.putIfAbsent(
-          CT_,
-          () => {
-                ..._Renderer_UndefinedElementType.propertyMap<CT_>(),
-                ..._Renderer_Rendered.propertyMap<CT_>(),
-                ..._Renderer_Callable.propertyMap<CT_>(),
-                'name': Property(
-                  getValue: (CT_ c) => c.name,
-                  renderVariable:
-                      (CT_ c, Property<CT_> self, List<String> remainingNames) {
-                    if (remainingNames.isEmpty) {
-                      return self.getValue(c).toString();
-                    }
-                    var name = remainingNames.first;
-                    var nextProperty =
-                        _Renderer_String.propertyMap().getValue(name);
-                    return nextProperty.renderVariable(self.getValue(c),
-                        nextProperty, [...remainingNames.skip(1)]);
-                  },
-                  isNullValue: (CT_ c) => c.name == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    _render_String(c.name, ast, r.template, sink, parent: r);
-                  },
-                ),
-                'typeFormals': Property(
-                  getValue: (CT_ c) => c.typeFormals,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(
-                          c, remainingNames, 'List<TypeParameter>'),
-                  renderIterable: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    return c.typeFormals.map((e) => _render_TypeParameter(
-                        e, ast, r.template, sink,
-                        parent: r));
-                  },
-                ),
-              });
-
-  _Renderer_FunctionTypeElementType(FunctionTypeElementType context,
-      RendererBase<Object> parent, Template template, StringSink sink)
-      : super(context, parent, template, sink);
-
-  @override
-  Property<FunctionTypeElementType> getProperty(String key) {
-    if (propertyMap<FunctionTypeElementType>().containsKey(key)) {
-      return propertyMap<FunctionTypeElementType>()[key];
-    } else {
-      return null;
-    }
-  }
-}
-
 void _render_FunctionTypedef(FunctionTypedef context, List<MustachioNode> ast,
     Template template, StringSink sink,
     {RendererBase<Object> parent}) {
@@ -6185,16 +6138,14 @@ class _Renderer_FunctionTypedef extends RendererBase<FunctionTypedef> {
                         }
                         var name = remainingNames.first;
                         var nextProperty =
-                            _Renderer_FunctionTypeElementType.propertyMap()
-                                .getValue(name);
+                            _Renderer_Callable.propertyMap().getValue(name);
                         return nextProperty.renderVariable(self.getValue(c),
                             nextProperty, [...remainingNames.skip(1)]);
                       },
                       isNullValue: (CT_ c) => c.modelType == null,
                       renderValue: (CT_ c, RendererBase<CT_> r,
                           List<MustachioNode> ast, StringSink sink) {
-                        _render_FunctionTypeElementType(
-                            c.modelType, ast, r.template, sink,
+                        _render_Callable(c.modelType, ast, r.template, sink,
                             parent: r);
                       },
                     ),
@@ -14501,161 +14452,6 @@ class _Renderer_TypedefTemplateData extends RendererBase<TypedefTemplateData> {
   }
 }
 
-class _Renderer_UndefinedElementType
-    extends RendererBase<UndefinedElementType> {
-  static final Map<Type, Object> _propertyMapCache = {};
-  static Map<String, Property<CT_>> propertyMap<
-          CT_ extends UndefinedElementType>() =>
-      _propertyMapCache.putIfAbsent(
-          CT_,
-          () => {
-                ..._Renderer_ElementType.propertyMap<CT_>(),
-                'element': Property(
-                  getValue: (CT_ c) => c.element,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(c, remainingNames, 'Element'),
-                  isNullValue: (CT_ c) => c.element == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    renderSimple(c.element, ast, r.template, sink,
-                        parent: r, getters: _invisibleGetters['Element']);
-                  },
-                ),
-                'instantiatedType': Property(
-                  getValue: (CT_ c) => c.instantiatedType,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(c, remainingNames, 'DartType'),
-                  isNullValue: (CT_ c) => c.instantiatedType == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    renderSimple(c.instantiatedType, ast, r.template, sink,
-                        parent: r, getters: _invisibleGetters['DartType']);
-                  },
-                ),
-                'isPublic': Property(
-                  getValue: (CT_ c) => c.isPublic,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(c, remainingNames, 'bool'),
-                  getBool: (CT_ c) => c.isPublic == true,
-                ),
-                'linkedName': Property(
-                  getValue: (CT_ c) => c.linkedName,
-                  renderVariable:
-                      (CT_ c, Property<CT_> self, List<String> remainingNames) {
-                    if (remainingNames.isEmpty) {
-                      return self.getValue(c).toString();
-                    }
-                    var name = remainingNames.first;
-                    var nextProperty =
-                        _Renderer_String.propertyMap().getValue(name);
-                    return nextProperty.renderVariable(self.getValue(c),
-                        nextProperty, [...remainingNames.skip(1)]);
-                  },
-                  isNullValue: (CT_ c) => c.linkedName == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    _render_String(c.linkedName, ast, r.template, sink,
-                        parent: r);
-                  },
-                ),
-                'name': Property(
-                  getValue: (CT_ c) => c.name,
-                  renderVariable:
-                      (CT_ c, Property<CT_> self, List<String> remainingNames) {
-                    if (remainingNames.isEmpty) {
-                      return self.getValue(c).toString();
-                    }
-                    var name = remainingNames.first;
-                    var nextProperty =
-                        _Renderer_String.propertyMap().getValue(name);
-                    return nextProperty.renderVariable(self.getValue(c),
-                        nextProperty, [...remainingNames.skip(1)]);
-                  },
-                  isNullValue: (CT_ c) => c.name == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    _render_String(c.name, ast, r.template, sink, parent: r);
-                  },
-                ),
-                'nameWithGenerics': Property(
-                  getValue: (CT_ c) => c.nameWithGenerics,
-                  renderVariable:
-                      (CT_ c, Property<CT_> self, List<String> remainingNames) {
-                    if (remainingNames.isEmpty) {
-                      return self.getValue(c).toString();
-                    }
-                    var name = remainingNames.first;
-                    var nextProperty =
-                        _Renderer_String.propertyMap().getValue(name);
-                    return nextProperty.renderVariable(self.getValue(c),
-                        nextProperty, [...remainingNames.skip(1)]);
-                  },
-                  isNullValue: (CT_ c) => c.nameWithGenerics == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    _render_String(c.nameWithGenerics, ast, r.template, sink,
-                        parent: r);
-                  },
-                ),
-                'referenceChildren': Property(
-                  getValue: (CT_ c) => c.referenceChildren,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(
-                          c, remainingNames, 'Map<String, CommentReferable>'),
-                  isNullValue: (CT_ c) => c.referenceChildren == null,
-                  renderValue: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    renderSimple(c.referenceChildren, ast, r.template, sink,
-                        parent: r, getters: _invisibleGetters['Map']);
-                  },
-                ),
-                'referenceParents': Property(
-                  getValue: (CT_ c) => c.referenceParents,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(
-                          c, remainingNames, 'Iterable<CommentReferable>'),
-                  renderIterable: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    return c.referenceParents.map((e) => renderSimple(
-                        e, ast, r.template, sink,
-                        parent: r,
-                        getters: _invisibleGetters['CommentReferable']));
-                  },
-                ),
-                'typeArguments': Property(
-                  getValue: (CT_ c) => c.typeArguments,
-                  renderVariable: (CT_ c, Property<CT_> self,
-                          List<String> remainingNames) =>
-                      self.renderSimpleVariable(
-                          c, remainingNames, 'Iterable<ElementType>'),
-                  renderIterable: (CT_ c, RendererBase<CT_> r,
-                      List<MustachioNode> ast, StringSink sink) {
-                    return c.typeArguments.map((e) => _render_ElementType(
-                        e, ast, r.template, sink,
-                        parent: r));
-                  },
-                ),
-              });
-
-  _Renderer_UndefinedElementType(UndefinedElementType context,
-      RendererBase<Object> parent, Template template, StringSink sink)
-      : super(context, parent, template, sink);
-
-  @override
-  Property<UndefinedElementType> getProperty(String key) {
-    if (propertyMap<UndefinedElementType>().containsKey(key)) {
-      return propertyMap<UndefinedElementType>()[key];
-    } else {
-      return null;
-    }
-  }
-}
-
 class _Renderer_Warnable extends RendererBase<Warnable> {
   static final Map<Type, Object> _propertyMapCache = {};
   static Map<String, Property<CT_>> propertyMap<CT_ extends Warnable>() =>
diff --git a/lib/src/model/typedef.dart b/lib/src/model/typedef.dart
index ac36412d57..e9212b86d0 100644
--- a/lib/src/model/typedef.dart
+++ b/lib/src/model/typedef.dart
@@ -89,5 +89,5 @@ class FunctionTypedef extends Typedef {
       : super(element, library, packageGraph);
 
   @override
-  FunctionTypeElementType get modelType => super.modelType;
+  Callable get modelType => super.modelType;
 }
diff --git a/test/end2end/dartdoc_integration_test.dart b/test/end2end/dartdoc_integration_test.dart
index fe1d15aa31..c8bddf94ab 100644
--- a/test/end2end/dartdoc_integration_test.dart
+++ b/test/end2end/dartdoc_integration_test.dart
@@ -91,20 +91,15 @@ void main() {
     test('invalid parameters return non-zero and print a fatal-error',
         () async {
       var outputLines = <String>[];
-      var threwException = false;
-      // consider [expectLater] when it works reliably with coverage again.
-      try {
-        await subprocessLauncher.runStreamed(
-            Platform.resolvedExecutable,
-            [
-              dartdocPath,
-              '--nonexisting',
-            ],
-            perLine: outputLines.add);
-      } on ProcessException {
-        threwException = true;
-      }
-      expect(threwException, isTrue);
+      await expectLater(
+          subprocessLauncher.runStreamed(
+              Platform.resolvedExecutable,
+              [
+                dartdocPath,
+                '--nonexisting',
+              ],
+              perLine: outputLines.add),
+          throwsA(const TypeMatcher<ProcessException>()));
       expect(
           outputLines.firstWhere((l) => l.startsWith(' fatal')),
           equals(
@@ -114,21 +109,16 @@ void main() {
     test('missing a required file path prints a fatal-error', () async {
       var outputLines = <String>[];
       var impossiblePath = path.join(dartdocPath, 'impossible');
-      var threwException = false;
-      // consider [expectLater] when it works with coverage again.
-      try {
-        await subprocessLauncher.runStreamed(
-            Platform.resolvedExecutable,
-            [
-              dartdocPath,
-              '--input',
-              impossiblePath,
-            ],
-            perLine: outputLines.add);
-      } on ProcessException {
-        threwException = true;
-      }
-      expect(threwException, isTrue);
+      await expectLater(
+          subprocessLauncher.runStreamed(
+              Platform.resolvedExecutable,
+              [
+                dartdocPath,
+                '--input',
+                impossiblePath,
+              ],
+              perLine: outputLines.add),
+          throwsA(const TypeMatcher<ProcessException>()));
       expect(
           outputLines.firstWhere((l) => l.startsWith(' fatal')),
           startsWith(
@@ -136,19 +126,14 @@ void main() {
     });
 
     test('errors cause non-zero exit when warnings are off', () async {
-      // consider [expectLater] when it works with coverage.
-      var exceptionThrown = false;
-      try {
-        await subprocessLauncher.runStreamed(Platform.resolvedExecutable, [
-          dartdocPath,
-          '--allow-tools',
-          '--input=${testPackageToolError.path}',
-          '--output=${path.join(tempDir.absolute.path, 'test_package_tool_error')}'
-        ]);
-      } on ProcessException {
-        exceptionThrown = true;
-      }
-      expect(exceptionThrown, isTrue);
+      await expectLater(
+          subprocessLauncher.runStreamed(Platform.resolvedExecutable, [
+            dartdocPath,
+            '--allow-tools',
+            '--input=${testPackageToolError.path}',
+            '--output=${path.join(tempDir.absolute.path, 'test_package_tool_error')}'
+          ]),
+          throwsA(const TypeMatcher<ProcessException>()));
     });
 
     test('help prints command line args', () async {
@@ -171,20 +156,16 @@ void main() {
       var dartTool =
           Directory(path.join(_testPackageFlutterPluginPath, '.dart_tool'));
       if (dartTool.existsSync()) dartTool.deleteSync(recursive: true);
-      var exceptionThrown = false;
-      // consider [expectLater] when this works with coverage
-      try {
-        await subprocessLauncher.runStreamed(Platform.resolvedExecutable, args,
-            environment: Map.from(Platform.environment)..remove('FLUTTER_ROOT'),
-            includeParentEnvironment: false,
-            workingDirectory: _testPackageFlutterPluginPath, perLine: (s) {
-          output.writeln(s);
-        });
-      } on ProcessException {
-        exceptionThrown = true;
-      }
+      await expectLater(
+          subprocessLauncher.runStreamed(Platform.resolvedExecutable, args,
+              environment: Map.from(Platform.environment)
+                ..remove('FLUTTER_ROOT'),
+              includeParentEnvironment: false,
+              workingDirectory: _testPackageFlutterPluginPath, perLine: (s) {
+            output.writeln(s);
+          }),
+          throwsA(const TypeMatcher<ProcessException>()));
       // Asynchronous exception, but we still need the output, too.
-      expect(exceptionThrown, isTrue);
       expect(
           output.toString(),
           contains(RegExp(
diff --git a/test/end2end/model_test.dart b/test/end2end/model_test.dart
index 57b2db59a7..07575f0c62 100644
--- a/test/end2end/model_test.dart
+++ b/test/end2end/model_test.dart
@@ -268,15 +268,8 @@ void main() {
       expect(listen.isRequiredPositional, isTrue);
       expect(onDone.isNamed, isTrue);
 
-      expect(
-          m3.linkedParamsLines,
-          equals(
-              '<ol class="parameter-list"><li><span class="parameter" id="m3-param-listen"><span class="type-annotation">void</span> <span class="parameter-name">listen</span>(<ol class="parameter-list"><li><span class="parameter" id="param-t"><span class="type-annotation">int</span> <span class="parameter-name">t</span></span></li>\n'
-              '</ol>\n'
-              ')?, </span></li>\n'
-              '<li><span class="parameter" id="m3-param-onDone">{<span class="type-annotation">void</span> <span class="parameter-name">onDone</span>(<ol class="parameter-list"></ol>\n'
-              ')?}</span></li>\n'
-              '</ol>'));
+      expect(m3.linkedParamsLines, contains('</ol>\n)?, '));
+      expect(m3.linkedParamsLines, contains('</ol>\n)?}</span>'));
     });
 
     test('Late final class member test', () {
@@ -2866,11 +2859,11 @@ String topLevelFunction(int param1, bool param2, Cool coolBeans,
       expect(
           params,
           '<span class="parameter" id="doAComplicatedThing-param-x"><span class="type-annotation">int</span> <span class="parameter-name">x</span>, </span>'
-          '<span class="parameter" id="doAComplicatedThing-param-doSomething">{<span class="type-annotation">void</span> <span class="parameter-name">doSomething</span>(<span class="parameter" id="param-aThingParameter"><span class="type-annotation">int</span> <span class="parameter-name">aThingParameter</span>, </span>'
-          '<span class="parameter" id="param-anotherThing"><span class="type-annotation">String</span> <span class="parameter-name">anotherThing</span></span>), </span>'
-          '<span class="parameter" id="doAComplicatedThing-param-doSomethingElse"><span class="type-annotation">void</span> <span class="parameter-name">doSomethingElse</span>(<span class="parameter" id="param-aThingParameter"><span class="type-annotation">int</span> <span class="parameter-name">aThingParameter</span>, </span>'
-          '<span class="parameter" id="param-somethingElse"><span class="type-annotation">double</span> <span class="parameter-name">somethingElse</span></span>)}</span>');
-    });
+          '<span class="parameter" id="doAComplicatedThing-param-doSomething">{<span class="type-annotation">void</span> <span class="parameter-name">doSomething</span>(<span class="parameter" id="doSomething-param-aThingParameter"><span class="type-annotation">int</span> <span class="parameter-name">aThingParameter</span>, </span>'
+          '<span class="parameter" id="doSomething-param-anotherThing"><span class="type-annotation">String</span> <span class="parameter-name">anotherThing</span></span>), </span>'
+          '<span class="parameter" id="doAComplicatedThing-param-doSomethingElse"><span class="type-annotation">void</span> <span class="parameter-name">doSomethingElse</span>(<span class="parameter" id="doSomethingElse-param-aThingParameter"><span class="type-annotation">int</span> <span class="parameter-name">aThingParameter</span>, </span>'
+          '<span class="parameter" id="doSomethingElse-param-somethingElse"><span class="type-annotation">double</span> <span class="parameter-name">somethingElse</span></span>)}</span>');
+    }, skip: 'reenable with analyzer > 1.7.1');
   });
 
   group('Type expansion', () {
@@ -2888,8 +2881,10 @@ String topLevelFunction(int param1, bool param2, Cool coolBeans,
           .singleWhere((f) => f.name == 'explicitSetter');
       // TODO(jcollins-g): really, these shouldn't be called "parameters" in
       // the span class.
-      expect(explicitSetter.modelType.linkedName,
-          'dynamic Function<span class="signature">(<span class="parameter" id="param-bar"><span class="type-annotation">int</span> <span class="parameter-name">bar</span>, </span><span class="parameter" id="param-baz"><span class="type-annotation"><a href="%%__HTMLBASE_dartdoc_internal__%%fake/Cool-class.html">Cool</a></span> <span class="parameter-name">baz</span>, </span><span class="parameter" id="param-macTruck"><span class="type-annotation">List<span class="signature">&lt;<wbr><span class="type-parameter">int</span>&gt;</span></span> <span class="parameter-name">macTruck</span></span>)</span>');
+      expect(
+          explicitSetter.modelType.linkedName,
+          matches(RegExp(
+              r'dynamic Function<span class="signature">\(<span class="parameter" id="(f-)?param-bar"><span class="type-annotation">int</span> <span class="parameter-name">bar</span>, </span><span class="parameter" id="(f-)?param-baz"><span class="type-annotation"><a href="%%__HTMLBASE_dartdoc_internal__%%fake/Cool-class.html">Cool</a></span> <span class="parameter-name">baz</span>, </span><span class="parameter" id="(f-)?param-macTruck"><span class="type-annotation">List<span class="signature">&lt;<wbr><span class="type-parameter">int</span>&gt;</span></span> <span class="parameter-name">macTruck</span></span>\)</span>')));
     });
 
     test('parameterized type from field is correctly displayed', () {
diff --git a/tool/grind.dart b/tool/grind.dart
index b49477bed8..5892c78305 100644
--- a/tool/grind.dart
+++ b/tool/grind.dart
@@ -49,8 +49,9 @@ final String defaultPubCache = Platform.environment['PUB_CACHE'] ??
     path.context.resolveTildePath('~/.pub-cache');
 
 /// Run no more than the number of processors available in parallel.
-final MultiFutureTracker testFutures =
-    MultiFutureTracker(Platform.numberOfProcessors);
+final MultiFutureTracker testFutures = MultiFutureTracker(
+    int.tryParse(Platform.environment['MAX_TEST_FUTURES'] ?? '') ??
+        Platform.numberOfProcessors);
 
 // Directory.systemTemp is not a constant.  So wrap it.
 Directory createTempSync(String prefix) =>