Implement .getCallType

pkg/compiler/lib/src/kernel/element_map_impl.dart

 // Copyright (c) 2017, 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.
 
 library dart2js.kernel.element_map;
 
 import 'package:kernel/ast.dart' as ir;
 
 import '../closure.dart' show BoxLocal;
 import '../common.dart';
@@ skipping 445 matching lines @@
   ConstantValue computeConstantValue(ConstantExpression constant,
       {bool requireConstant: true}) {
     return _constantEnvironment.getConstantValue(constant);
   }
 
   DartType _substByContext(DartType type, InterfaceType context) {
     return type.subst(
         context.typeArguments, _getThisType(context.element).typeArguments);
   }
 
+  void _ensureCallType(IndexedClass cls, ClassData data) {
+    if (!data.isCallTypeComputed) {
+      data.isCallTypeComputed = true;
+      MemberEntity callMethod = lookupClassMember(cls, Identifiers.call);
+      if (callMethod != null) {
+        if (callMethod.isFunction) {
+          data.callType = _getFunctionType(callMethod);
+        } else {
+          data.callType = const DynamicType();
+        }
+        return;
+      }
+
+      Set<FunctionType> inheritedCallTypes = new Set<FunctionType>();
+      bool inheritsInvalidCallMember = false;
+
+      void addCallType(InterfaceType supertype) {
+        if (supertype == null) return;
+        DartType type = _getCallType(supertype);
+        if (type == null) return;
+        if (type.isFunctionType) {
+          inheritedCallTypes.add(type);
+        } else {
+          inheritsInvalidCallMember = true;
+        }
+      }
+
+      addCallType(_getSuperType(cls));
+      _getInterfaces(cls).forEach(addCallType);
+
+      if (inheritsInvalidCallMember) {
+        data.callType = const DynamicType();
+      } else if (inheritedCallTypes.isEmpty) {
+        return;
+      } else if (inheritedCallTypes.length == 1) {
+        data.callType = inheritedCallTypes.single;
+      } else {
+        List<FunctionType> subtypesOfAllInherited = <FunctionType>[];

[Siggi Cherem (dart-lang), 2017/08/11 16:14:59]

I am not sure it is worth it to replicate this logic. In strong-mode we don't
allow these invalid overrides and we just need to lookup the target of `call`
and use that (the type system will verify that all overrides are valid).

Since this is only needed for erroneous cases, I'm inclined to just keep it
simple and go straight to the new semantics (yes a couple tests might not work,
but as the migration of tests to language_2 progresses, I'm guessing there will
be no test covering this behavior either).

[Johnni Winther, 2017/08/15 14:17:37]

It's there. It works. And at some point Issue 30438 will cover it for us.

+        outer:
+        for (FunctionType a in inheritedCallTypes) {
+          for (FunctionType b in inheritedCallTypes) {
+            if (identical(a, b)) continue;
+            if (!types.isSubtype(a, b)) continue outer;

[Siggi Cherem (dart-lang), 2017/08/11 16:14:59]

Assuming we still want to keep this logic, this part was a bit hard to follow
for me. Is this loop basically trying to find a GLB and if one is not directly
in the set, we synthesize one? If so, how about:

// Find whether there is a type that is a valid
// override for all inherited call types.
for (var candidate in inheritedCallTypes) {
  if (inheritedCallTypes.every((c) => isSubtype(candidate, c))) {
    data.callType = candidate;
    return;
  }
}

// Create a synthesized greatestLowerBound type
...

[Johnni Winther, 2017/08/15 14:17:37]

For (int)->void and (num)->void both subtype the other (due to bivariance on
function subtyping) so we can't return the first found!

[Siggi Cherem (dart-lang), 2017/08/15 18:10:27]

but bivariance is not allowed in strong mode :)

Fine to keep because it now that it is implemented, but I'd consider using
TODO-redemption also for things that will become obsolete with strong mode and
later review whether we should add as needed.

+          }
+          subtypesOfAllInherited.add(a);
+        }
+        if (subtypesOfAllInherited.length == 1) {
+          data.callType = subtypesOfAllInherited.single;
+          return;
+        }
+
+        // Multiple signatures with different types => create the synthesized
+        // version.

[Siggi Cherem (dart-lang), 2017/08/11 16:14:59]

Here too - even if we keep the lookup for a glb and not do 2.0 yet, I'm inclined
to get rid of this synthesized type and keep things simple.

[Johnni Winther, 2017/08/15 14:17:37]

It is actually following the spec directly. Added comments.

+        int minRequiredParameters;
+        int maxPositionalParameters;
+        Set<String> names = new Set<String>();
+        for (FunctionType type in inheritedCallTypes) {
+          type.namedParameters.forEach((String name) => names.add(name));
+          int requiredParameters = type.parameterTypes.length;
+          int optionalParameters = type.optionalParameterTypes.length;
+          int positionalParameters = requiredParameters + optionalParameters;
+          if (minRequiredParameters == null ||
+              minRequiredParameters > requiredParameters) {
+            minRequiredParameters = requiredParameters;
+          }
+          if (maxPositionalParameters == null ||
+              maxPositionalParameters < positionalParameters) {
+            maxPositionalParameters = positionalParameters;
+          }
+        }
+        int optionalParameters =
+            maxPositionalParameters - minRequiredParameters;
+        // TODO(johnniwinther): Support function types with both optional
+        // and named parameters?
+        if (optionalParameters == 0 || names.isEmpty) {
+          DartType dynamic = const DynamicType();
+          List<DartType> requiredParameterTypes =
+              new List.filled(minRequiredParameters, dynamic);
+          List<DartType> optionalParameterTypes =
+              new List.filled(optionalParameters, dynamic);
+          List<String> namedParameters = names.toList()
+            ..sort((a, b) => a.compareTo(b));
+          List<DartType> namedParameterTypes =
+              new List.filled(namedParameters.length, dynamic);
+          data.callType = new FunctionType(dynamic, requiredParameterTypes,
+              optionalParameterTypes, namedParameters, namedParameterTypes);
+        } else {
+          // The function type is not valid.
+          data.callType = const DynamicType();
+        }
+      }
+    }
+  }
+
+  /// Returns the type of the `call` method on 'type'.
+  ///
+  /// If [type] doesn't have a `call` member `null` is returned. If [type] has
+  /// an invalid `call` member (non-method or a synthesized method with both
+  /// optional and named parameters) a [DynamicType] is returned.
+  DartType _getCallType(InterfaceType type) {
+    IndexedClass cls = type.element;
+    assert(checkFamily(cls));
+    ClassData data = _classData[cls.classIndex];
+    _ensureCallType(cls, data);
+    if (data.callType != null) {
+      return _substByContext(data.callType, type);
+    }
+    return null;
+  }
+
   InterfaceType _getThisType(IndexedClass cls) {
     assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
     _ensureThisAndRawType(cls, data);
     return data.thisType;
   }
 
   InterfaceType _getRawType(IndexedClass cls) {
     assert(checkFamily(cls));
     ClassData data = _classData[cls.classIndex];
@@ skipping 628 matching lines @@
       if (node is ir.FunctionDeclaration) {
         name = node.variable.name;
         functionType = getFunctionType(node.function);
       } else if (node is ir.FunctionExpression) {
         functionType = getFunctionType(node.function);
       }
       return new KLocalFunction(
           name, memberContext, executableContext, functionType);
     });
   }
+
+  bool _implementsFunction(IndexedClass cls) {
+    assert(checkFamily(cls));
+    ClassData data = _classData[cls.classIndex];
+    OrderedTypeSet orderedTypeSet = data.orderedTypeSet;
+    InterfaceType supertype = orderedTypeSet.asInstanceOf(
+        commonElements.functionClass,
+        _getHierarchyDepth(commonElements.functionClass));
+    if (supertype != null) {
+      return true;
+    }
+    _ensureCallType(cls, data);
+    return data.callType is FunctionType;
+  }
 }
 
 class KernelElementEnvironment implements ElementEnvironment {
   final KernelToElementMapBase elementMap;
 
   KernelElementEnvironment(this.elementMap);
 
   @override
   DartType get dynamicType => const DynamicType();
 
@@ skipping 410 matching lines @@
     return elementMap._getOrderedTypeSet(cls).supertypes;
   }
 
   @override
   ClassEntity getSuperClass(ClassEntity cls) {
     return elementMap._getSuperType(cls)?.element;
   }
 
   @override
   bool implementsFunction(ClassEntity cls) {
-    // TODO(redemption): Implement this.
-    return false;
+    return elementMap._implementsFunction(cls);
   }
 
   @override
   int getHierarchyDepth(ClassEntity cls) {
     return elementMap._getHierarchyDepth(cls);
   }
 
   @override
   ClassEntity getAppliedMixin(ClassEntity cls) {
     return elementMap._getAppliedMixin(cls);
@@ skipping 601 matching lines @@
   ///
   /// These names are not used in generated code, just as element name.
   String _getClosureVariableName(String name, int id) {
     return "_captured_${name}_$id";
   }
 
   String getDeferredUri(ir.LibraryDependency node) {
     throw new UnimplementedError('JsKernelToElementMap.getDeferredUri');
   }
 }