[vm/compiler] Use unchecked entry point when static receiver type is non-generic.

This guarantees that type checks are skipped in the code like this:

class X<T> {
  void method(X<T> other) {
  }
}

class Y extends X<String> {
}

void foo(Y y, Y z) {
  y.method(z);  // No need to check on the callee side. No variance.
}

Additionally ammend IL printing to print user visible type names instead
of internal type names for brevity.

Bug: #31798
Change-Id: I4fe16d5dc7de01bb0a8ba834569d90ee5ce7ac74
Reviewed-on: https://dart-review.googlesource.com/72001
Reviewed-by: Samir Jindel <[email protected]>
Commit-Queue: Vyacheslav Egorov <[email protected]>

Author: mraleph

runtime/vm/compiler/backend/il_printer.cc

@@ -149,14 +149,18 @@ void FlowGraphPrinter::PrintTypeCheck(const ParsedFunction& parsed_function,
       String::Handle(dst_type.Name()).ToCString(), dst_name.ToCString());
 }
 
+static const char* TypeToUserVisibleName(const AbstractType& type) {
+  return String::Handle(type.UserVisibleName()).ToCString();
+}
+
 void CompileType::PrintTo(BufferFormatter* f) const {
   const char* type_name = "?";
   if ((cid_ != kIllegalCid) && (cid_ != kDynamicCid)) {
     const Class& cls =
         Class::Handle(Isolate::Current()->class_table()->At(cid_));
     type_name = String::Handle(cls.ScrubbedName()).ToCString();
   } else if (type_ != NULL && !type_->IsDynamicType()) {
-    type_name = type_->ToCString();
+    type_name = TypeToUserVisibleName(*type_);
   } else if (!is_nullable()) {
     type_name = "!null";
   }
@@ -471,7 +475,8 @@ void DropTempsInstr::PrintOperandsTo(BufferFormatter* f) const {
 
 void AssertAssignableInstr::PrintOperandsTo(BufferFormatter* f) const {
   value()->PrintTo(f);
-  f->Print(", %s, '%s',", dst_type().ToCString(), dst_name().ToCString());
+  f->Print(", %s, '%s',", TypeToUserVisibleName(dst_type()),
+           dst_name().ToCString());
   f->Print(" instantiator_type_args(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print("), function_type_args(");
@@ -480,8 +485,8 @@ void AssertAssignableInstr::PrintOperandsTo(BufferFormatter* f) const {
 }
 
 void AssertSubtypeInstr::PrintOperandsTo(BufferFormatter* f) const {
-  f->Print("%s, %s, '%s',", sub_type().ToCString(), super_type().ToCString(),
-           dst_name().ToCString());
+  f->Print("%s, %s, '%s',", TypeToUserVisibleName(sub_type()),
+           TypeToUserVisibleName(super_type()), dst_name().ToCString());
   f->Print(" instantiator_type_args(");
   instantiator_type_arguments()->PrintTo(f);
   f->Print("), function_type_args(");

runtime/vm/compiler/frontend/kernel_binary_flowgraph.cc

@@ -3516,12 +3516,19 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p) {
   }
 
   bool is_unchecked_closure_call = false;
+  bool is_unchecked_call = false;
 #ifndef TARGET_ARCH_DBC
-  if (call_site_attributes.receiver_type != nullptr &&
-      call_site_attributes.receiver_type->IsFunctionType()) {
-    AlternativeReadingScope alt(&reader_);
-    SkipExpression();  // skip receiver
-    is_unchecked_closure_call = ReadNameAsMethodName().Equals(Symbols::Call());
+  if (call_site_attributes.receiver_type != nullptr) {
+    if (call_site_attributes.receiver_type->IsFunctionType()) {
+      AlternativeReadingScope alt(&reader_);
+      SkipExpression();  // skip receiver
+      is_unchecked_closure_call =
+          ReadNameAsMethodName().Equals(Symbols::Call());
+    } else if (call_site_attributes.receiver_type->HasResolvedTypeClass() &&
+               !Class::Handle(call_site_attributes.receiver_type->type_class())
+                    .IsGeneric()) {
+      is_unchecked_call = true;
+    }
   }
 #endif
 
@@ -3554,7 +3561,9 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p) {
 
   // Take note of whether the invocation is against the receiver of the current
   // function: in this case, we may skip some type checks in the callee.
-  const bool is_this_invocation = PeekTag() == kThisExpression;
+  if (PeekTag() == kThisExpression) {
+    is_unchecked_call = true;
+  }
   instructions += BuildExpression();  // read receiver.
 
   const String& name = ReadNameAsMethodName();  // read name.
@@ -3644,7 +3653,7 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p) {
         B->ClosureCall(position, type_args_len, argument_count, argument_names,
                        /*use_unchecked_entry=*/true);
   } else if (!direct_call.target_.IsNull()) {
-    // TODO(#34162): Pass 'is_this_invocation' down if/when we feature multiple
+    // TODO(#34162): Pass 'is_unchecked_call' down if/when we feature multiple
     // entry-points in AOT.
     ASSERT(FLAG_precompiled_mode);
     instructions += StaticCall(position, direct_call.target_, argument_count,
@@ -3665,12 +3674,12 @@ Fragment StreamingFlowGraphBuilder::BuildMethodInvocation(TokenPosition* p) {
           Z, Function::CreateDynamicInvocationForwarderName(name));
     }
 
-    // TODO(#34162): Pass 'is_this_invocation' down if/when we feature multiple
+    // TODO(#34162): Pass 'is_unchecked_call' down if/when we feature multiple
     // entry-points in AOT.
     instructions += InstanceCall(
         position, *mangled_name, token_kind, type_args_len, argument_count,
         argument_names, checked_argument_count, *interface_target, &result_type,
-        /*use_unchecked_entry=*/!FLAG_precompiled_mode && is_this_invocation,
+        /*use_unchecked_entry=*/!FLAG_precompiled_mode && is_unchecked_call,
         &call_site_attributes);
   }