[vm/tfa] Implementation of type arguments tracking in TFA.

Change-Id: I9398186e27ae7a040e249df010ae16fb6ab6da89
Cq-Include-Trybots: luci.dart.try:vm-kernel-win-release-x64-try, vm-kernel-optcounter-threshold-linux-release-x64-try, vm-kernel-precomp-linux-debug-x64-try, vm-kernel-precomp-linux-release-simarm-try, vm-kernel-precomp-linux-release-simarm64-try, vm-kernel-precomp-linux-release-x64-try, vm-kernel-precomp-win-release-x64-try
Reviewed-on: https://dart-review.googlesource.com/c/74962
Commit-Queue: Samir Jindel <sjindel@google.com>
Reviewed-by: Alexander Markov <alexmarkov@google.com>
Reviewed-by: Dmitry Stefantsov <dmitryas@google.com>

Author: sjindel-google

pkg/kernel/lib/class_hierarchy.dart

@@ -42,6 +42,11 @@ abstract class ClassHierarchy {
   /// True if the component contains another class that is a subtype of given one.
   bool hasProperSubtypes(Class class_);
 
+  // Returns the instantition of each generic supertype implemented by this
+  // class (e.g. getClassAsInstanceOf applied to all superclasses and
+  // interfaces).
+  List<Supertype> genericSupertypesOf(Class class_);
+
   /// Returns the least upper bound of two interface types, as defined by Dart
   /// 1.0.
   ///
@@ -699,6 +704,15 @@ class ClosedWorldClassHierarchy implements ClassHierarchy {
         info.directMixers.isNotEmpty;
   }
 
+  @override
+  List<Supertype> genericSupertypesOf(Class class_) {
+    final supertypes = _infoFor[class_].genericSuperTypes;
+    if (supertypes == null) return const <Supertype>[];
+    // Multiple supertypes can arise from ambiguous supertypes. The first
+    // supertype is the real one; the others are purely informational.
+    return supertypes.values.map((v) => v.first).toList();
+  }
+
   @override
   ClassHierarchy applyTreeChanges(Iterable<Library> removedLibraries,
       Iterable<Library> ensureKnownLibraries,
@@ -1339,7 +1353,7 @@ class _ClassInfo {
   /// Maps generic supertype classes to the instantiation implemented by this
   /// class.
   ///
-  /// E.g. `List` maps to `List<String>` for a class that directly of indirectly
+  /// E.g. `List` maps to `List<String>` for a class that directly or indirectly
   /// implements `List<String>`.
   Map<Class, List<Supertype>> genericSuperTypes;
 

pkg/vm/lib/metadata/inferred_type.dart

@@ -14,20 +14,54 @@ class InferredType {
   static const int flagNullable = 1 << 0;
   static const int flagInt = 1 << 1;
 
-  InferredType(Class concreteClass, bool nullable, bool isInt)
-      : this._byReference(getClassReference(concreteClass),
-            (nullable ? flagNullable : 0) | (isInt ? flagInt : 0));
+  // For Parameters and Fields, whether a type-check is required at assignment
+  // (invocation/setter). Not meaningful on other kernel nodes.
+  static const int flagSkipCheck = 1 << 2;
 
-  InferredType._byReference(this._concreteClassReference, this._flags);
+  // Entire list may be null if no type arguments were inferred.
+  // Will always be null if `concreteClass` is null.
+  //
+  // Each component may be null if that particular type argument was not
+  // inferred.
+  //
+  // Otherwise, a non-null type argument indicates that that particular type
+  // argument (in the runtime type) is always exactly a particular `DartType`.
+  final List<DartType> exactTypeArguments;
+
+  InferredType(Class concreteClass, bool nullable, bool isInt,
+      {List<DartType> exactTypeArguments, bool skipCheck: false})
+      : this._byReference(
+            getClassReference(concreteClass),
+            (nullable ? flagNullable : 0) |
+                (isInt ? flagInt : 0) |
+                (skipCheck ? flagSkipCheck : 0),
+            exactTypeArguments);
+
+  InferredType._byReference(
+      this._concreteClassReference, this._flags, this.exactTypeArguments) {
+    assert(exactTypeArguments == null || _concreteClassReference != null);
+  }
 
   Class get concreteClass => _concreteClassReference?.asClass;
 
   bool get nullable => (_flags & flagNullable) != 0;
   bool get isInt => (_flags & flagInt) != 0;
+  bool get skipCheck => (_flags & flagSkipCheck) != 0;
 
   @override
-  String toString() =>
-      "${concreteClass != null ? concreteClass : (isInt ? 'int' : '!')}${nullable ? '?' : ''}";
+  String toString() {
+    final base =
+        "${concreteClass != null ? concreteClass : (isInt ? 'int' : '!')}";
+    final suffix = "${nullable ? '?' : ''}";
+    String typeArgs = "";
+    if (exactTypeArguments != null) {
+      typeArgs =
+          exactTypeArguments.map((t) => t != null ? "$t" : "?").join(", ");
+      typeArgs = "<" + typeArgs + ">";
+    }
+    final skip = skipCheck ? " (skip check)" : "";
+    return base + suffix + typeArgs + skip;
+  }
 }
 
 /// Repository for [InferredType].
@@ -40,16 +74,20 @@ class InferredTypeMetadataRepository extends MetadataRepository<InferredType> {
 
   @override
   void writeToBinary(InferredType metadata, Node node, BinarySink sink) {
+    // TODO(sjindel/tfa): Implement serialization of type arguments when can use
+    // them for optimizations.
     sink.writeCanonicalNameReference(
         getCanonicalNameOfClass(metadata.concreteClass));
     sink.writeByte(metadata._flags);
   }
 
   @override
   InferredType readFromBinary(Node node, BinarySource source) {
+    // TODO(sjindel/tfa): Implement serialization of type arguments when can use
+    // them for optimizations.
     final concreteClassReference =
         source.readCanonicalNameReference()?.getReference();
     final flags = source.readByte();
-    return new InferredType._byReference(concreteClassReference, flags);
+    return new InferredType._byReference(concreteClassReference, flags, null);
   }
 }