[vm/kernel] In async transformation check if strongMode is on.

It seems we are still using non-strong mode targets in few
places (e.g. when training front-end server we by accident
train it in legacy mode).

A separate bug is filed to clean that up #34468

For now to unbreak the build we simply check if we are in the
legacy mode and then avoid using getStaticType in async
transformation.

This is followup to eec96f9.

Bug: #34463
Change-Id: Ib693fddfb9abbf89599ae646cb408d4a9c93f1b6
Reviewed-on: https://dart-review.googlesource.com/75061
Commit-Queue: Vyacheslav Egorov <vegorov@google.com>
Reviewed-by: Alexander Markov <alexmarkov@google.com>

Author: mraleph

pkg/front_end/testcases/async_function.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library;
 import self as self;
 import "dart:async" as asy;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 static field core::List<core::String> stringList = <dynamic>["bar"];
 static method asyncString() → asy::Future<core::String> /* originally async */ {
@@ -119,7 +118,7 @@ static method asyncStarString() → asy::Stream<core::String> /* originally asyn
           else
             [yield] null;
           [yield] let dynamic #t1 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error, :async_op) in null;
-          if(:controller.{asy::_AsyncStarStreamController::add}(_in::unsafeCast<core::String>(:result)))
+          if(:controller.{asy::_AsyncStarStreamController::add}(:result))
             return null;
           else
             [yield] null;
@@ -188,7 +187,7 @@ static method main() → dynamic /* originally async */ {
       #L5:
       {
         [yield] let dynamic #t2 = asy::_awaitHelper(self::asyncString(), :async_op_then, :async_op_error, :async_op) in null;
-        core::String str = _in::unsafeCast<core::String>(:result);
+        core::String str = :result;
       }
       asy::_completeOnAsyncReturn(:async_completer, :return_value);
       return;

pkg/front_end/testcases/async_nested.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
-import "dart:_internal" as _in;
 
 class Node extends core::Object {
   final field core::List<self::Node> nested;
@@ -44,7 +43,7 @@ static method main() → void /* originally async */ {
         [yield] let dynamic #t9 = asy::_awaitHelper(asy::Future::value<dynamic>(new self::Node::•("3", <dynamic>[:result])), :async_op_then, :async_op_error, :async_op) in null;
         :async_temporary_0 = :result;
         [yield] let dynamic #t10 = asy::_awaitHelper(asy::Future::value<dynamic>(new self::Node::•("10", <dynamic>[])), :async_op_then, :async_op_error, :async_op) in null;
-        self::Node node = new self::Node::•("1", <dynamic>[_in::unsafeCast<self::Node>(:async_temporary_2), :async_temporary_0, :result]);
+        self::Node node = new self::Node::•("1", <dynamic>[:async_temporary_2, :async_temporary_0, :result]);
         core::String actual = node.toSimpleString();
         core::print(actual);
         if(!actual.==(expected)) {

pkg/front_end/testcases/await.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library;
 import self as self;
 import "dart:async" as asy;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 static method main() → dynamic /* originally async */ {
   final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
@@ -18,7 +17,7 @@ static method main() → dynamic /* originally async */ {
       #L1:
       {
         [yield] let dynamic #t1 = asy::_awaitHelper("Hello, World!", :async_op_then, :async_op_error, :async_op) in null;
-        core::print(_in::unsafeCast<core::String>(:result));
+        core::print(:result);
       }
       asy::_completeOnAsyncReturn(:async_completer, :return_value);
       return;

pkg/front_end/testcases/bug33206.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
-import "dart:_internal" as _in;
 
 class X extends core::Object {
   final field dynamic x;
@@ -90,10 +89,10 @@ static method foo() → asy::Future<self::X> /* originally async */ {
       {
         final dynamic #t1 = new self::Y::•();
         [yield] let dynamic #t2 = asy::_awaitHelper(self::f1(), :async_op_then, :async_op_error, :async_op) in null;
-        final dynamic #t3 = #t1.f(_in::unsafeCast<core::List<core::Object>>(:result));
+        final dynamic #t3 = #t1.f(:result);
         final dynamic #t4 = #t1.f(self::f2());
         [yield] let dynamic #t5 = asy::_awaitHelper(self::f3(), :async_op_then, :async_op_error, :async_op) in null;
-        :return_value = new self::X::•(#t1, _in::unsafeCast<core::Object>(:result));
+        :return_value = new self::X::•(#t1, :result);
         break #L3;
       }
       asy::_completeOnAsyncReturn(:async_completer, :return_value);
@@ -122,7 +121,7 @@ static method main() → asy::Future<void> /* originally async */ {
       #L4:
       {
         [yield] let dynamic #t6 = asy::_awaitHelper(self::foo(), :async_op_then, :async_op_error, :async_op) in null;
-        core::print(_in::unsafeCast<self::X>(:result));
+        core::print(:result);
       }
       asy::_completeOnAsyncReturn(:async_completer, :return_value);
       return;

pkg/front_end/testcases/inference/async_await.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library test;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
-import "dart:_internal" as _in;
 
 abstract class MyFuture extends core::Object implements asy::Future<core::int> {
   synthetic constructor •() → void
@@ -303,25 +302,25 @@ static method test() → void /* originally async */ {
           return :async_completer.{asy::Completer::future};
         }
         [yield] let dynamic #t1 = asy::_awaitHelper(x0, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y0 = _in::unsafeCast<core::int>(:result);
+        dynamic y0 = :result;
         [yield] let dynamic #t2 = asy::_awaitHelper(x1, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y1 = _in::unsafeCast<core::int>(:result);
+        dynamic y1 = :result;
         [yield] let dynamic #t3 = asy::_awaitHelper(x2, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y2 = _in::unsafeCast<asy::Future<core::int>>(:result);
+        dynamic y2 = :result;
         [yield] let dynamic #t4 = asy::_awaitHelper(x3, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y3 = _in::unsafeCast<asy::FutureOr<core::int>>(:result);
+        dynamic y3 = :result;
         [yield] let dynamic #t5 = asy::_awaitHelper(x4, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y4 = _in::unsafeCast<self::MyFuture>(:result);
+        dynamic y4 = :result;
         [yield] let dynamic #t6 = asy::_awaitHelper(x5, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y5 = _in::unsafeCast<core::int>(:result);
+        dynamic y5 = :result;
         [yield] let dynamic #t7 = asy::_awaitHelper(x6, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y6 = _in::unsafeCast<asy::Future<core::int>>(:result);
+        dynamic y6 = :result;
         [yield] let dynamic #t8 = asy::_awaitHelper(x7, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y7 = _in::unsafeCast<asy::FutureOr<core::int>>(:result);
+        dynamic y7 = :result;
         [yield] let dynamic #t9 = asy::_awaitHelper(x8, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y8 = _in::unsafeCast<self::MyFuture>(:result);
+        dynamic y8 = :result;
         [yield] let dynamic #t10 = asy::_awaitHelper(x9, :async_op_then, :async_op_error, :async_op) in null;
-        dynamic y9 = _in::unsafeCast<core::int>(:result);
+        dynamic y9 = :result;
       }
       asy::_completeOnAsyncReturn(:async_completer, :return_value);
       return;

pkg/front_end/testcases/inference/downwards_inference_async_await.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library test;
 import self as self;
 import "dart:async" as asy;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 static method main() → asy::Future<dynamic> /* originally async */ {
   final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
@@ -19,7 +18,7 @@ static method main() → asy::Future<dynamic> /* originally async */ {
       {
         dynamic d;
         [yield] let dynamic #t1 = asy::_awaitHelper(<dynamic>[d], :async_op_then, :async_op_error, :async_op) in null;
-        core::List<core::int> l0 = _in::unsafeCast<core::List<dynamic>>(:result);
+        core::List<core::int> l0 = :result;
         [yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<dynamic>(<dynamic>[d]), :async_op_then, :async_op_error, :async_op) in null;
         core::List<core::int> l1 = :result;
       }

pkg/front_end/testcases/inference/downwards_inference_for_each.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library test;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
-import "dart:_internal" as _in;
 
 abstract class MyStream<T extends core::Object = dynamic> extends asy::Stream<self::MyStream::T> {
   static factory •<T extends core::Object = dynamic>() → self::MyStream<self::MyStream::•::T>
@@ -50,7 +49,7 @@ static method f() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t3 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t4 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 dynamic x = :for-iterator.{asy::_StreamIterator::current};
                 {}
               }
@@ -73,7 +72,7 @@ static method f() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t6 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t7 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 dynamic x = :for-iterator.{asy::_StreamIterator::current};
                 {}
               }
@@ -96,7 +95,7 @@ static method f() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t9 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t10 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 core::Object x = :for-iterator.{asy::_StreamIterator::current};
                 {}
               }
@@ -119,7 +118,7 @@ static method f() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t12 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t13 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 final dynamic #t14 = :for-iterator.{asy::_StreamIterator::current};
                 {
                   d = #t14;
@@ -144,7 +143,7 @@ static method f() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t16 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t17 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 final dynamic #t18 = :for-iterator.{asy::_StreamIterator::current};
                 {
                   o = #t18;
@@ -204,7 +203,7 @@ static method main() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t20 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t21 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 core::int x = :for-iterator.{asy::_StreamIterator::current};
                 {}
               }
@@ -227,7 +226,7 @@ static method main() → asy::Future<dynamic> /* originally async */ {
             while (true) {
               dynamic #t23 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t24 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 dynamic x = :for-iterator.{asy::_StreamIterator::current};
                 {}
               }

pkg/front_end/testcases/inference/for_each_downcast_iterable.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library test;
 import self as self;
 import "dart:async" as asy;
 import "dart:core" as core;
-import "dart:_internal" as _in;
 
 static method test() → dynamic /* originally async */ {
   final asy::Completer<dynamic> :async_completer = asy::Completer::sync<dynamic>();
@@ -33,7 +32,7 @@ static method test() → dynamic /* originally async */ {
             while (true) {
               dynamic #t1 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t2 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 dynamic x = :for-iterator.{asy::_StreamIterator::current};
                 {}
               }
@@ -60,7 +59,7 @@ static method test() → dynamic /* originally async */ {
             while (true) {
               dynamic #t5 = :product-mode ?{dynamic} null : asy::_asyncStarMoveNextHelper(:stream);
               [yield] let dynamic #t6 = asy::_awaitHelper(:for-iterator.{asy::_StreamIterator::moveNext}(), :async_op_then, :async_op_error, :async_op) in null;
-              if(_in::unsafeCast<core::bool>(:result)) {
+              if(:result) {
                 final dynamic #t7 = :for-iterator.{asy::_StreamIterator::current};
                 {
                   y = #t7;

pkg/front_end/testcases/inference/future_then.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library test;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
-import "dart:_internal" as _in;
 
 class MyFuture<T extends core::Object = dynamic> extends core::Object implements asy::Future<self::MyFuture::T> {
   constructor •() → void
@@ -38,7 +37,7 @@ static method test() → void {
         #L1:
         {
           [yield] let dynamic #t1 = asy::_awaitHelper(asy::Future::value<core::int>(3), :async_op_then, :async_op_error, :async_op) in null;
-          :return_value = _in::unsafeCast<core::int>(:result);
+          :return_value = :result;
           break #L1;
         }
         asy::_completeOnAsyncReturn(:async_completer, :return_value);
@@ -67,7 +66,7 @@ static method test() → void {
         #L2:
         {
           [yield] let dynamic #t2 = asy::_awaitHelper(asy::Future::value<core::int>(3), :async_op_then, :async_op_error, :async_op) in null;
-          :return_value = _in::unsafeCast<core::int>(:result);
+          :return_value = :result;
           break #L2;
         }
         asy::_completeOnAsyncReturn(:async_completer, :return_value);

pkg/front_end/testcases/inference/future_then_2.dart.direct.transformed.expect

@@ -2,7 +2,6 @@ library test;
 import self as self;
 import "dart:core" as core;
 import "dart:async" as asy;
-import "dart:_internal" as _in;
 
 class MyFuture<T extends core::Object = dynamic> extends core::Object implements asy::Future<self::MyFuture::T> {
   constructor •() → void
@@ -38,7 +37,7 @@ static method test() → void {
         #L1:
         {
           [yield] let dynamic #t1 = asy::_awaitHelper(new self::MyFuture::value<core::int>(3), :async_op_then, :async_op_error, :async_op) in null;
-          :return_value = _in::unsafeCast<core::int>(:result);
+          :return_value = :result;
           break #L1;
         }
         asy::_completeOnAsyncReturn(:async_completer, :return_value);
@@ -67,7 +66,7 @@ static method test() → void {
         #L2:
         {
           [yield] let dynamic #t2 = asy::_awaitHelper(new self::MyFuture::value<core::int>(3), :async_op_then, :async_op_error, :async_op) in null;
-          :return_value = _in::unsafeCast<core::int>(:result);
+          :return_value = :result;
           break #L2;
         }
         asy::_completeOnAsyncReturn(:async_completer, :return_value);