[vm/compiler] Infer more accurate generic type of list factory constructors

For recognized list factories, which take constant type arguments,
compiler can infer full generic type in addition to cid.
This helps remove AssertAssignable when creating List<List<...>> with
List.generate constructor.

Havlak +3.7-10% in JIT mode with null safety.

Change-Id: I0a050c9a0d3604ffcfd1a0afa0f123a07e9ac03a
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/159185
Commit-Queue: Alexander Markov <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>
Reviewed-by: Régis Crelier <[email protected]>

Author: alexmarkov

runtime/vm/compiler/backend/type_propagator.cc

@@ -1340,10 +1340,36 @@ CompileType PolymorphicInstanceCallInstr::ComputeType() const {
   return is_nullable ? type : type.CopyNonNullable();
 }
 
+static CompileType ComputeListFactoryType(CompileType* inferred_type,
+                                          Value* type_args_value) {
+  ASSERT(inferred_type != nullptr);
+  const intptr_t cid = inferred_type->ToNullableCid();
+  ASSERT(cid != kDynamicCid);
+  if ((cid == kGrowableObjectArrayCid || cid == kArrayCid ||
+       cid == kImmutableArrayCid) &&
+      type_args_value->BindsToConstant()) {
+    const auto& type_args =
+        type_args_value->BoundConstant().IsNull()
+            ? TypeArguments::null_type_arguments()
+            : TypeArguments::Cast(type_args_value->BoundConstant());
+    const Class& cls =
+        Class::Handle(Isolate::Current()->class_table()->At(cid));
+    Type& type = Type::ZoneHandle(Type::New(
+        cls, type_args, TokenPosition::kNoSource, Nullability::kNonNullable));
+    ASSERT(type.IsInstantiated());
+    type.SetIsFinalized();
+    return CompileType(CompileType::kNonNullable, cid, &type);
+  }
+  return *inferred_type;
+}
+
 CompileType StaticCallInstr::ComputeType() const {
   // TODO(alexmarkov): calculate type of StaticCallInstr eagerly
   // (in optimized mode) and avoid keeping separate result_type.
-  CompileType* inferred_type = result_type();
+  CompileType* const inferred_type = result_type();
+  if (is_known_list_constructor()) {
+    return ComputeListFactoryType(inferred_type, ArgumentValueAt(0));
+  }
   if ((inferred_type != NULL) &&
       (inferred_type->ToNullableCid() != kDynamicCid)) {
     return *inferred_type;