[vm/aot/tfa] Infer int type, devirtualize dynamic calls

This change improves type flow analysis to infer int types, in addition
to concrete classes (int type is abstract and has 2 concrete subclasses,
_Smi and _Mint).

Also, this CL enables devirtualization of dynamic calls (previously, only
calls with known interface target were devirtualized).

DartMicroBench.PrimeNumber:
x64: +221%
armv8: +461%
armv7h: +47.98%

No measurable impact on Flutter gallery build time in release mode.

Issue: flutter/flutter#19677

Change-Id: I34db195f52f2a434218ee11eee7f308d4661738b
Reviewed-on: https://dart-review.googlesource.com/69520
Commit-Queue: Alexander Markov <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>

Author: alexmarkov

pkg/vm/lib/metadata/inferred_type.dart

@@ -9,18 +9,25 @@ import 'package:kernel/ast.dart';
 /// Metadata for annotating nodes with an inferred type information.
 class InferredType {
   final Reference _concreteClassReference;
-  final bool nullable;
+  final int _flags;
 
-  InferredType(Class concreteClass, bool nullable)
-      : this._byReference(getClassReference(concreteClass), nullable);
+  static const int flagNullable = 1 << 0;
+  static const int flagInt = 1 << 1;
 
-  InferredType._byReference(this._concreteClassReference, this.nullable);
+  InferredType(Class concreteClass, bool nullable, bool isInt)
+      : this._byReference(getClassReference(concreteClass),
+            (nullable ? flagNullable : 0) | (isInt ? flagInt : 0));
+
+  InferredType._byReference(this._concreteClassReference, this._flags);
 
   Class get concreteClass => _concreteClassReference?.asClass;
 
+  bool get nullable => (_flags & flagNullable) != 0;
+  bool get isInt => (_flags & flagInt) != 0;
+
   @override
   String toString() =>
-      "${concreteClass != null ? concreteClass : '!'}${nullable ? '?' : ''}";
+      "${concreteClass != null ? concreteClass : (isInt ? 'int' : '!')}${nullable ? '?' : ''}";
 }
 
 /// Repository for [InferredType].
@@ -35,14 +42,14 @@ class InferredTypeMetadataRepository extends MetadataRepository<InferredType> {
   void writeToBinary(InferredType metadata, Node node, BinarySink sink) {
     sink.writeCanonicalNameReference(
         getCanonicalNameOfClass(metadata.concreteClass));
-    sink.writeByte(metadata.nullable ? 1 : 0);
+    sink.writeByte(metadata._flags);
   }
 
   @override
   InferredType readFromBinary(Node node, BinarySource source) {
     final concreteClassReference =
         source.readCanonicalNameReference()?.getReference();
-    final nullable = (source.readByte() != 0);
-    return new InferredType._byReference(concreteClassReference, nullable);
+    final flags = source.readByte();
+    return new InferredType._byReference(concreteClassReference, flags);
   }
 }

pkg/vm/lib/transformations/devirtualization.dart

@@ -72,7 +72,7 @@ abstract class Devirtualization extends RecursiveVisitor<Null> {
       directCall.checkReceiverForNull &&
       _objectMemberNames.contains(directCall.target.name);
 
-  DirectCallMetadata getDirectCall(TreeNode node, Member target,
+  DirectCallMetadata getDirectCall(TreeNode node, Member interfaceTarget,
       {bool setter = false});
 
   makeDirectCall(TreeNode node, Member target, DirectCallMetadata directCall) {
@@ -96,45 +96,50 @@ abstract class Devirtualization extends RecursiveVisitor<Null> {
   visitMethodInvocation(MethodInvocation node) {
     super.visitMethodInvocation(node);
 
-    Member target = node.interfaceTarget;
-    if ((target != null) && isMethod(target)) {
-      DirectCallMetadata directCall = getDirectCall(node, target);
-      // TODO(dartbug.com/30480): Convert _isLegalTargetForMethodInvocation()
-      // check into an assertion once front-end implements override checks.
-      if ((directCall != null) &&
-          isMethod(directCall.target) &&
-          isLegalTargetForMethodInvocation(directCall.target, node.arguments) &&
-          !hasExtraTargetForNull(directCall)) {
-        makeDirectCall(node, target, directCall);
-      }
+    final Member target = node.interfaceTarget;
+    if (target != null && !isMethod(target)) {
+      return;
+    }
+
+    final DirectCallMetadata directCall = getDirectCall(node, target);
+
+    // TODO(alexmarkov): Convert _isLegalTargetForMethodInvocation()
+    // check into an assertion once front-end implements all override checks.
+    if ((directCall != null) &&
+        isMethod(directCall.target) &&
+        isLegalTargetForMethodInvocation(directCall.target, node.arguments) &&
+        !hasExtraTargetForNull(directCall)) {
+      makeDirectCall(node, target, directCall);
     }
   }
 
   @override
   visitPropertyGet(PropertyGet node) {
     super.visitPropertyGet(node);
 
-    Member target = node.interfaceTarget;
-    if ((target != null) && isFieldOrGetter(target)) {
-      DirectCallMetadata directCall = getDirectCall(node, target);
-      if ((directCall != null) &&
-          isFieldOrGetter(directCall.target) &&
-          !hasExtraTargetForNull(directCall)) {
-        makeDirectCall(node, target, directCall);
-      }
+    final Member target = node.interfaceTarget;
+    if (target != null && !isFieldOrGetter(target)) {
+      return;
+    }
+
+    final DirectCallMetadata directCall = getDirectCall(node, target);
+
+    if ((directCall != null) &&
+        isFieldOrGetter(directCall.target) &&
+        !hasExtraTargetForNull(directCall)) {
+      makeDirectCall(node, target, directCall);
     }
   }
 
   @override
   visitPropertySet(PropertySet node) {
     super.visitPropertySet(node);
 
-    Member target = node.interfaceTarget;
-    if (target != null) {
-      DirectCallMetadata directCall = getDirectCall(node, target, setter: true);
-      if (directCall != null) {
-        makeDirectCall(node, target, directCall);
-      }
+    final Member target = node.interfaceTarget;
+    final DirectCallMetadata directCall =
+        getDirectCall(node, target, setter: true);
+    if (directCall != null) {
+      makeDirectCall(node, target, directCall);
     }
   }
 }
@@ -148,10 +153,13 @@ class CHADevirtualization extends Devirtualization {
       : super(coreTypes, component, hierarchy);
 
   @override
-  DirectCallMetadata getDirectCall(TreeNode node, Member target,
+  DirectCallMetadata getDirectCall(TreeNode node, Member interfaceTarget,
       {bool setter = false}) {
+    if (interfaceTarget == null) {
+      return null;
+    }
     Member singleTarget = _hierarchySubtype
-        .getSingleTargetForInterfaceInvocation(target, setter: setter);
+        .getSingleTargetForInterfaceInvocation(interfaceTarget, setter: setter);
     if (singleTarget == null) {
       return null;
     }

pkg/vm/lib/transformations/type_flow/analysis.dart

@@ -450,6 +450,13 @@ class _DispatchableInvocation extends _Invocation {
         }
         _getReceiverTypeBuilder(targets, kNoSuchMethodMarker)
             .addConcreteType(receiver);
+      } else if (selector is DynamicSelector) {
+        if (kPrintTrace) {
+          tracePrint(
+              "Dynamic selector - adding noSuchMethod for receiver $receiver");
+        }
+        _getReceiverTypeBuilder(targets, kNoSuchMethodMarker)
+            .addConcreteType(receiver);
       } else {
         if (kPrintTrace) {
           tracePrint("Target is not found for receiver $receiver");

pkg/vm/lib/transformations/type_flow/summary_collector.dart

@@ -1067,16 +1067,17 @@ class SummaryCollector extends RecursiveVisitor<TypeExpr> {
   }
 
   @override
-  visitSwitchStatement(SwitchStatement node) {
+  TypeExpr visitSwitchStatement(SwitchStatement node) {
     _visit(node.expression);
     for (var switchCase in node.cases) {
       switchCase.expressions.forEach(_visit);
       _visit(switchCase.body);
     }
+    return null;
   }
 
   @override
-  visitTryCatch(TryCatch node) {
+  TypeExpr visitTryCatch(TryCatch node) {
     _visit(node.body);
     for (var catchClause in node.catches) {
       if (catchClause.exception != null) {
@@ -1087,49 +1088,56 @@ class SummaryCollector extends RecursiveVisitor<TypeExpr> {
       }
       _visit(catchClause.body);
     }
+    return null;
   }
 
   @override
-  visitTryFinally(TryFinally node) {
+  TypeExpr visitTryFinally(TryFinally node) {
     _visit(node.body);
     _visit(node.finalizer);
+    return null;
   }
 
   @override
-  visitVariableDeclaration(VariableDeclaration node) {
+  TypeExpr visitVariableDeclaration(VariableDeclaration node) {
     final v = _declareVariable(node, addInitType: true);
     if (node.initializer == null) {
       v.values.add(_nullType);
     }
+    return null;
   }
 
   @override
-  visitWhileStatement(WhileStatement node) {
+  TypeExpr visitWhileStatement(WhileStatement node) {
     _addUse(_visit(node.condition));
     _visit(node.body);
+    return null;
   }
 
   @override
-  visitYieldStatement(YieldStatement node) {
+  TypeExpr visitYieldStatement(YieldStatement node) {
     _visit(node.expression);
+    return null;
   }
 
   @override
-  visitFieldInitializer(FieldInitializer node) {
+  TypeExpr visitFieldInitializer(FieldInitializer node) {
     final value = _visit(node.value);
     final args = new Args<TypeExpr>([_receiver, value]);
     _makeCall(node,
         new DirectSelector(node.field, callKind: CallKind.PropertySet), args);
+    return null;
   }
 
   @override
-  visitRedirectingInitializer(RedirectingInitializer node) {
+  TypeExpr visitRedirectingInitializer(RedirectingInitializer node) {
     final args = _visitArguments(_receiver, node.arguments);
     _makeCall(node, new DirectSelector(node.target), args);
+    return null;
   }
 
   @override
-  visitSuperInitializer(SuperInitializer node) {
+  TypeExpr visitSuperInitializer(SuperInitializer node) {
     final args = _visitArguments(_receiver, node.arguments);
 
     Constructor target = null;
@@ -1146,22 +1154,27 @@ class SummaryCollector extends RecursiveVisitor<TypeExpr> {
     }
     assertx(target != null);
     _makeCall(node, new DirectSelector(target), args);
+    return null;
   }
 
   @override
-  visitLocalInitializer(LocalInitializer node) {
+  TypeExpr visitLocalInitializer(LocalInitializer node) {
     visitVariableDeclaration(node.variable);
+    return null;
   }
 
   @override
-  visitAssertInitializer(AssertInitializer node) {
+  TypeExpr visitAssertInitializer(AssertInitializer node) {
     if (!kRemoveAsserts) {
       _visit(node.statement);
     }
+    return null;
   }
 
   @override
-  visitInvalidInitializer(InvalidInitializer node) {}
+  TypeExpr visitInvalidInitializer(InvalidInitializer node) {
+    return null;
+  }
 
   @override
   TypeExpr visitConstantExpression(ConstantExpression node) {

pkg/vm/lib/transformations/type_flow/transformer.dart

@@ -96,7 +96,7 @@ class TFADevirtualization extends Devirtualization {
             _typeFlowAnalysis.environment.hierarchy);
 
   @override
-  DirectCallMetadata getDirectCall(TreeNode node, Member target,
+  DirectCallMetadata getDirectCall(TreeNode node, Member interfaceTarget,
       {bool setter = false}) {
     final callSite = _typeFlowAnalysis.callSite(node);
     if (callSite != null) {
@@ -115,10 +115,12 @@ class AnnotateKernel extends RecursiveVisitor<Null> {
   final TypeFlowAnalysis _typeFlowAnalysis;
   final InferredTypeMetadataRepository _inferredTypeMetadata;
   final UnreachableNodeMetadataRepository _unreachableNodeMetadata;
+  final DartType _intType;
 
   AnnotateKernel(Component component, this._typeFlowAnalysis)
       : _inferredTypeMetadata = new InferredTypeMetadataRepository(),
-        _unreachableNodeMetadata = new UnreachableNodeMetadataRepository() {
+        _unreachableNodeMetadata = new UnreachableNodeMetadataRepository(),
+        _intType = _typeFlowAnalysis.environment.intType {
     component.addMetadataRepository(_inferredTypeMetadata);
     component.addMetadataRepository(_unreachableNodeMetadata);
   }
@@ -127,23 +129,25 @@ class AnnotateKernel extends RecursiveVisitor<Null> {
     assertx(type != null);
 
     Class concreteClass;
+    bool isInt = false;
 
     final nullable = type is NullableType;
     if (nullable) {
-      final baseType = (type as NullableType).baseType;
+      type = (type as NullableType).baseType;
+    }
 
-      if (baseType == const EmptyType()) {
-        concreteClass = _typeFlowAnalysis.environment.coreTypes.nullClass;
-      } else {
-        concreteClass =
-            baseType.getConcreteClass(_typeFlowAnalysis.hierarchyCache);
-      }
+    if (nullable && type == const EmptyType()) {
+      concreteClass = _typeFlowAnalysis.environment.coreTypes.nullClass;
     } else {
       concreteClass = type.getConcreteClass(_typeFlowAnalysis.hierarchyCache);
+
+      if (concreteClass == null) {
+        isInt = type.isSubtypeOf(_typeFlowAnalysis.hierarchyCache, _intType);
+      }
     }
 
-    if ((concreteClass != null) || !nullable) {
-      return new InferredType(concreteClass, nullable);
+    if ((concreteClass != null) || !nullable || isInt) {
+      return new InferredType(concreteClass, nullable, isInt);
     }
 
     return null;

pkg/vm/lib/transformations/type_flow/types.dart

@@ -95,6 +95,8 @@ abstract class Type extends TypeExpr {
 
   Class getConcreteClass(TypeHierarchy typeHierarchy) => null;
 
+  bool isSubtypeOf(TypeHierarchy typeHierarchy, DartType dartType) => false;
+
   @override
   Type getComputedType(List<Type> types) => this;
 
@@ -167,6 +169,10 @@ class NullableType extends Type {
   @override
   String toString() => "${baseType}?";
 
+  @override
+  bool isSubtypeOf(TypeHierarchy typeHierarchy, DartType dartType) =>
+      baseType.isSubtypeOf(typeHierarchy, dartType);
+
   @override
   int get order => TypeOrder.Nullable.index;
 
@@ -278,6 +284,10 @@ class SetType extends Type {
   @override
   String toString() => "_T ${types}";
 
+  @override
+  bool isSubtypeOf(TypeHierarchy typeHierarchy, DartType dartType) =>
+      types.every((ConcreteType t) => t.isSubtypeOf(typeHierarchy, dartType));
+
   @override
   int get order => TypeOrder.Set.index;
 
@@ -396,6 +406,10 @@ class ConeType extends Type {
       .specializeTypeCone(dartType)
       .getConcreteClass(typeHierarchy);
 
+  @override
+  bool isSubtypeOf(TypeHierarchy typeHierarchy, DartType dartType) =>
+      typeHierarchy.isSubtype(this.dartType, dartType);
+
   @override
   int get hashCode => (dartType.hashCode + 37) & kHashMask;
 
@@ -504,6 +518,10 @@ class ConcreteType extends Type implements Comparable<ConcreteType> {
   Class getConcreteClass(TypeHierarchy typeHierarchy) =>
       (dartType as InterfaceType).classNode;
 
+  @override
+  bool isSubtypeOf(TypeHierarchy typeHierarchy, DartType dartType) =>
+      typeHierarchy.isSubtype(this.dartType, dartType);
+
   @override
   int get hashCode => (classId.hashCode ^ 0x1234) & kHashMask;
 

pkg/vm/testcases/transformations/type_flow/transformer/annotation.dart.expect

@@ -37,7 +37,7 @@ class B extends core::Object {
 }
 static method foo([@vm.inferred-type.metadata=dart.core::Null?] (core::List<core::int>) → void a) → core::int {
   @self::VarAnnotation::•() core::int x = 2;
-  return [@vm.direct-call.metadata=dart.core::_IntegerImplementation::+] x.{core::num::+}(2);
+  return [@vm.direct-call.metadata=dart.core::_IntegerImplementation::+] [@vm.inferred-type.metadata=int?] x.{core::num::+}(2);
 }
 @self::ParametrizedAnnotation::•<core::Null>(null)
 static method main(core::List<core::String> args) → dynamic {