Allow FunctionTypes to work in place of InterfaceType in applicability check

lib/src/element_type.dart

@@ -205,10 +205,11 @@ class TypeParameterElementType extends DefinedElementType {
   String get nameWithGenerics => name;
 
   @override
-  ClassElement get _boundClassElement => interfaceType.element;
+  ClassElement get _boundClassElement => type.element;
 
   @override
-  InterfaceType get interfaceType => (type as TypeParameterType).bound;
+  // TODO(jcollins-g): This is wrong; bound is not always an InterfaceType.
+  InterfaceType get _interfaceType => (type as TypeParameterType).bound;
 }
 
 /// An [ElementType] associated with an [Element].
@@ -271,18 +272,19 @@ abstract class DefinedElementType extends ElementType {
   ClassElement get _boundClassElement => (element.element as ClassElement);
   Class get boundClass =>
       ModelElement.fromElement(_boundClassElement, packageGraph);
-  InterfaceType get interfaceType => type;
+
+  InterfaceType get _interfaceType => type;
 
   InterfaceType _instantiatedType;
 
   /// Return this type, instantiated to bounds if it isn't already.
   DartType get instantiatedType {
     if (_instantiatedType == null) {
-      if (!interfaceType.typeArguments.every((t) => t is InterfaceType)) {
+      if (!_interfaceType.typeArguments.every((t) => t is InterfaceType)) {
         var typeSystem = library.element.typeSystem as TypeSystemImpl;
-        _instantiatedType = typeSystem.instantiateToBounds(interfaceType);
+        _instantiatedType = typeSystem.instantiateToBounds(_interfaceType);
       } else {
-        _instantiatedType = interfaceType;
+        _instantiatedType = _interfaceType;
       }
     }
     return _instantiatedType;
@@ -413,4 +415,7 @@ class CallableGenericTypeAliasElementType extends ParameterizedElementType
     }
     return _returnType;
   }
+
+  @override
+  DartType get instantiatedType => type;
 }

lib/src/model/class.dart

@@ -5,12 +5,13 @@
 import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:dartdoc/src/element_type.dart';
+import 'package:dartdoc/src/model/extension_target.dart';
 import 'package:dartdoc/src/model/model.dart';
 import 'package:dartdoc/src/model_utils.dart' as model_utils;
 import 'package:quiver/iterables.dart' as quiver;
 
 class Class extends Container
-    with TypeParameters, Categorization
+    with TypeParameters, Categorization, ExtensionTarget
     implements EnclosedElement {
   List<DefinedElementType> mixins;
   DefinedElementType supertype;
@@ -51,22 +52,6 @@ class Class extends Container
     return _defaultConstructor;
   }
 
-  bool get hasPotentiallyApplicableExtensions =>
-      potentiallyApplicableExtensions.isNotEmpty;
-
-  List<Extension> _potentiallyApplicableExtensions;
-
-  Iterable<Extension> get potentiallyApplicableExtensions {
-    if (_potentiallyApplicableExtensions == null) {
-      _potentiallyApplicableExtensions = model_utils
-          .filterNonDocumented(packageGraph.extensions)
-          .where((e) => e.couldApplyTo(this))
-          .toList(growable: false)
-            ..sort(byName);
-    }
-    return _potentiallyApplicableExtensions;
-  }
-
   Iterable<Method> get allInstanceMethods =>
       quiver.concat([instanceMethods, inheritedMethods]);
 
@@ -223,6 +208,7 @@ class Class extends Container
 
   bool get hasPublicMixins => publicMixins.isNotEmpty;
 
+  @override
   bool get hasModifiers =>
       hasPublicMixins ||
       hasAnnotations ||

lib/src/model/extension.dart

@@ -8,6 +8,7 @@ import 'package:analyzer/dart/element/element.dart';
 import 'package:analyzer/dart/element/type.dart';
 import 'package:analyzer/src/dart/element/element.dart';
 import 'package:dartdoc/src/element_type.dart';
+import 'package:dartdoc/src/model/extension_target.dart';
 import 'package:dartdoc/src/model/model.dart';
 import 'package:quiver/iterables.dart' as quiver;
 
@@ -24,7 +25,8 @@ class Extension extends Container
         ElementType.from(_extension.extendedType, library, packageGraph);
   }
 
-  bool couldApplyTo(Class c) => _couldApplyTo(c.modelType);
+  bool couldApplyTo<T extends ExtensionTarget>(T c) =>
+      _couldApplyTo(c.modelType);
 
   /// Return true if this extension could apply to [t].
   bool _couldApplyTo(DefinedElementType t) {
@@ -40,13 +42,14 @@ class Extension extends Container
       .isSubtypeOf(extendedType.instantiatedType, t.instantiatedType);
 
   bool isBoundSupertypeTo(DefinedElementType t) =>
-      _isBoundSupertypeTo(t.type, HashSet());
+      _isBoundSupertypeTo(t.instantiatedType, HashSet());
 
   /// Returns true if at least one supertype (including via mixins and
   /// interfaces) is equivalent to or a subtype of [extendedType] when
   /// instantiated to bounds.
-  bool _isBoundSupertypeTo(
-      InterfaceType superType, HashSet<InterfaceType> visited) {
+  bool _isBoundSupertypeTo(DartType superType, HashSet<DartType> visited) {
+    // Only InterfaceTypes can have superTypes.
+    if (superType is! InterfaceType) return false;
     ClassElement superClass = superType?.element;
     if (visited.contains(superType)) return false;
     visited.add(superType);

lib/src/model/extension_target.dart

@@ -0,0 +1,26 @@
+// Copyright (c) 2020, the Dart project authors. Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+import 'package:dartdoc/src/model/model.dart';
+
+// TODO(jcollins-g): Mix-in ExtensionTarget on Method, ModelFunction, Typedef,
+// and other possible documented symbols that could be extended (#2701).
+mixin ExtensionTarget on ModelElement {
+  bool get hasModifiers;
+
+  bool get hasPotentiallyApplicableExtensions =>
+      potentiallyApplicableExtensions.isNotEmpty;
+
+  List<Extension> _potentiallyApplicableExtensions;
+
+  Iterable<Extension> get potentiallyApplicableExtensions {
+    if (_potentiallyApplicableExtensions == null) {
+      _potentiallyApplicableExtensions = packageGraph.documentedExtensions
+          .where((e) => e.couldApplyTo(this))
+          .toList(growable: false)
+            ..sort(byName);
+    }
+    return _potentiallyApplicableExtensions;
+  }
+}

lib/src/model/package_graph.dart

@@ -152,13 +152,21 @@ class PackageGraph {
     return _implementors;
   }
 
+  List<Extension> _documentedExtensions;
+  Iterable<Extension> get documentedExtensions {
+    if (_documentedExtensions == null) {
+      _documentedExtensions =
+          utils.filterNonDocumented(extensions).toList(growable: false);
+    }
+    return _documentedExtensions;
+  }
+
   Iterable<Extension> get extensions {
     assert(allExtensionsAdded);
     return _extensions;
   }
 
   Map<String, Set<ModelElement>> _findRefElementCache;
-
   Map<String, Set<ModelElement>> get findRefElementCache {
     if (_findRefElementCache == null) {
       assert(packageGraph.allLibrariesAdded);

testing/test_package/lib/fake.dart

@@ -1117,3 +1117,18 @@ abstract class CanonicalPrivateInheritedToolUser
     print('hello, tool world');
   }
 }
+
+/*
+ * Complex extension methods case.
+ *
+ * TODO(jcollins-g): add unit tests around behavior when #2701 is implemented.
+ * Until #2701 is fixed we mostly are testing that we don't crash because
+ * DoSomething2X is declared.
+ */
+
+typedef R Function1<A, R>(A a);
+typedef R Function2<A, B, R>(A a, B b);
+
+extension DoSomething2X<A, B, R> on Function1<A, Function1<B, R>> {
+  Function2<A, B, R> something() => (A first, B second) => this(first)(second);
+}