[vm/compiler] Infer array element type from static type Iterable<E>

Inferring array element type E from static type Iterable<E> allows
compiler to remove extra checks left from iterator code.
This is valid as List<E> implements Iterable<E>.

This change makes for-in loops over built-in lists with static types
Iterable<E> as efficient as loops over List<E>.

TEST=runtime/tests/vm/dart/regress_56840_il_test.dart
Fixes #56840

Change-Id: Ie52208b9c3e92dcc52079e66c910b023f09a2173
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/392401
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>

Author: alexmarkov

runtime/tests/vm/dart/regress_56840_il_test.dart

@@ -0,0 +1,80 @@
+// Copyright (c) 2024, 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.
+
+// Verify that all checks are optimized out in a for-in loop over built-in
+// list with Iterable<String> static type.
+
+import 'package:vm/testing/il_matchers.dart';
+
+@pragma('vm:never-inline')
+@pragma('vm:testing:print-flow-graph')
+bool foobar(String token, Iterable<String> values) {
+  for (String tokenValue in values) {
+    if (identical(tokenValue, token)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+void matchIL$foobar(FlowGraph graph) {
+  graph.match([
+    match.block('Graph', [
+      'int 0' << match.UnboxedConstant(value: 0),
+      'int 1' << match.UnboxedConstant(value: 1),
+    ]),
+    match.block('Function', [
+      'token' << match.Parameter(index: 0),
+      'values' << match.Parameter(index: 1),
+      'values.length' <<
+          match.LoadField('values', slot: 'GrowableObjectArray.length'),
+      'values.length_unboxed' << match.UnboxInt64('values.length'),
+      'values.data' <<
+          match.LoadField('values', slot: 'GrowableObjectArray.data'),
+      match.Goto('B16'),
+    ]),
+    'B16' <<
+        match.block('Join', [
+          'i' << match.Phi('int 0', 'i+1'),
+          if (is32BitConfiguration)
+            'i_64' << match.IntConverter('i', from: 'int32', to: 'int64'),
+          match.Branch(
+              match.RelationalOp(
+                  is32BitConfiguration ? 'i_64' : 'i', 'values.length_unboxed',
+                  kind: '>='),
+              ifTrue: 'B4',
+              ifFalse: 'B12'),
+        ]),
+    'B4' <<
+        match.block('Target', [
+          match.DartReturn(match.any),
+        ]),
+    'B12' <<
+        match.block('Target', [
+          if (is32BitConfiguration) 'i_boxed' << match.BoxInt32('i'),
+          'tokenValue' <<
+              match.LoadIndexed(
+                  'values.data', is32BitConfiguration ? 'i_boxed' : 'i'),
+          if (is32BitConfiguration)
+            'i+1' << match.BinaryInt32Op('i', 'int 1')
+          else
+            'i+1' << match.BinaryInt64Op('i', 'int 1'),
+          match.Branch(match.StrictCompare('tokenValue', 'token', kind: '==='),
+              ifTrue: 'B5', ifFalse: 'B6'),
+        ]),
+    'B5' <<
+        match.block('Target', [
+          match.DartReturn(match.any),
+        ]),
+    'B6' <<
+        match.block('Target', [
+          match.Goto('B16'),
+        ]),
+  ]);
+}
+
+main() {
+  print(foobar('a', ['a', 'b', 'c']));
+  print(foobar('b', ['b', 'c']));
+}

runtime/vm/compiler/backend/type_propagator.cc

@@ -1822,7 +1822,9 @@ static AbstractTypePtr ExtractElementTypeFromArrayType(
   if (cid == kGrowableObjectArrayCid || cid == kArrayCid ||
       cid == kImmutableArrayCid ||
       array_type.type_class() ==
-          IsolateGroup::Current()->object_store()->list_class()) {
+          IsolateGroup::Current()->object_store()->list_class() ||
+      array_type.type_class() ==
+          IsolateGroup::Current()->object_store()->iterable_class()) {
     const auto& type_args =
         TypeArguments::Handle(Type::Cast(array_type).arguments());
     return type_args.TypeAtNullSafe(Array::kElementTypeTypeArgPos);