Reland "[VM/runtime] Fix type tests with LHS FutureOr (fixes flutter#38906)."

crelier · commit-bot@chromium.org · commit f7a901751bbb · 2020-02-20T21:01:25.000Z
This is a reland of 3ef5270 Original change's description: > [VM/runtime] Fix type tests with LHS FutureOr (fixes flutter#38906). > > Fixes tests/language_2/subtyping_static/future_or_subtype_test > Also simplifies code making use of TypeAtNullSafe(). > > Change-Id: I045a030b2ece9d6980f7a9ba785948f0c10f697b > Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/135625 > Commit-Queue: Régis Crelier <regis@google.com> > Reviewed-by: Alexander Markov <alexmarkov@google.com> Change-Id: Ie3254f6aca3d47a00aead0ac34f3a6b9f301d8dc Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/136680 Reviewed-by: Alexander Markov <alexmarkov@google.com> Commit-Queue: Régis Crelier <regis@google.com>
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
@@ -419,7 +419,6 @@ void Precompiler::DoCompileAll() {
       Class& null_class = Class::Handle(Z);
       Function& null_function = Function::Handle(Z);
       Field& null_field = Field::Handle(Z);
-      I->object_store()->set_future_class(null_class);
       I->object_store()->set_pragma_class(null_class);
       I->object_store()->set_pragma_name(null_field);
       I->object_store()->set_pragma_options(null_field);
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm.cc
@@ -368,8 +368,7 @@ bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
   // If instance is Smi, check directly.
   const Class& smi_class = Class::Handle(zone(), Smi::Class());
   if (Class::IsSubtypeOf(NNBDMode::kLegacyLib, smi_class,
-                         Object::null_type_arguments(), type_class,
-                         Object::null_type_arguments(), Heap::kOld)) {
+                         Object::null_type_arguments(), type, Heap::kOld)) {
     // Fast case for type = int/num/top-type.
     __ b(is_instance_lbl, EQ);
   } else {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_arm64.cc
@@ -353,8 +353,7 @@ bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
   // If instance is Smi, check directly.
   const Class& smi_class = Class::Handle(zone(), Smi::Class());
   if (Class::IsSubtypeOf(NNBDMode::kLegacyLib, smi_class,
-                         Object::null_type_arguments(), type_class,
-                         Object::null_type_arguments(), Heap::kOld)) {
+                         Object::null_type_arguments(), type, Heap::kOld)) {
     // Fast case for type = int/num/top-type.
     __ BranchIfSmi(kInstanceReg, is_instance_lbl);
   } else {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc b/runtime/vm/compiler/backend/flow_graph_compiler_ia32.cc
@@ -344,8 +344,7 @@ bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
   // If instance is Smi, check directly.
   const Class& smi_class = Class::Handle(zone(), Smi::Class());
   if (Class::IsSubtypeOf(NNBDMode::kLegacyLib, smi_class,
-                         Object::null_type_arguments(), type_class,
-                         Object::null_type_arguments(), Heap::kOld)) {
+                         Object::null_type_arguments(), type, Heap::kOld)) {
     // Fast case for type = int/num/top-type.
     __ j(ZERO, is_instance_lbl);
   } else {
diff --git a/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc b/runtime/vm/compiler/backend/flow_graph_compiler_x64.cc
@@ -369,8 +369,7 @@ bool FlowGraphCompiler::GenerateInstantiatedTypeNoArgumentsTest(
   // If instance is Smi, check directly.
   const Class& smi_class = Class::Handle(zone(), Smi::Class());
   if (Class::IsSubtypeOf(NNBDMode::kLegacyLib, smi_class,
-                         Object::null_type_arguments(), type_class,
-                         Object::null_type_arguments(), Heap::kOld)) {
+                         Object::null_type_arguments(), type, Heap::kOld)) {
     // Fast case for type = int/num/top-type.
     __ j(ZERO, is_instance_lbl);
   } else {
diff --git a/runtime/vm/compiler/call_specializer.cc b/runtime/vm/compiler/call_specializer.cc
@@ -1112,8 +1112,7 @@ RawBool* CallSpecializer::InstanceOfAsBool(
                    (unwrapped_type.IsLegacy() && unwrapped_type.IsNeverType());
     } else {
       is_subtype = Class::IsSubtypeOf(mode, cls, Object::null_type_arguments(),
-                                      type_class, Object::null_type_arguments(),
-                                      Heap::kOld);
+                                      type, Heap::kOld);
     }
     results->Add(cls.id());
     results->Add(static_cast<intptr_t>(is_subtype));
@@ -1460,11 +1459,9 @@ bool CallSpecializer::SpecializeTestCidsForNumericTypes(
   const ClassTable& class_table = *Isolate::Current()->class_table();
   if ((*results)[0] != kSmiCid) {
     const Class& smi_class = Class::Handle(class_table.At(kSmiCid));
-    const Class& type_class = Class::Handle(type.type_class());
-    // When testing '42 is type', the nullability of type is irrelevant.
-    const bool smi_is_subtype = Class::IsSubtypeOf(
-        NNBDMode::kLegacyLib, smi_class, Object::null_type_arguments(),
-        type_class, Object::null_type_arguments(), Heap::kOld);
+    const bool smi_is_subtype =
+        Class::IsSubtypeOf(NNBDMode::kLegacyLib, smi_class,
+                           Object::null_type_arguments(), type, Heap::kOld);
     results->Add((*results)[results->length() - 2]);
     results->Add((*results)[results->length() - 2]);
     for (intptr_t i = results->length() - 3; i > 1; --i) {
diff --git a/runtime/vm/dart_api_impl.cc b/runtime/vm/dart_api_impl.cc
@@ -146,15 +146,22 @@ class CheckFunctionTypesVisitor : public ObjectVisitor {
 
 static RawInstance* GetListInstance(Zone* zone, const Object& obj) {
   if (obj.IsInstance()) {
-    const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
-    const Class& list_class =
-        Class::Handle(zone, core_lib.LookupClass(Symbols::List()));
-    ASSERT(!list_class.IsNull());
+    ObjectStore* object_store = Isolate::Current()->object_store();
+    Type& list_rare_type =
+        Type::Handle(zone, object_store->non_nullable_list_rare_type());
+    if (list_rare_type.IsNull()) {
+      const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
+      const Class& list_class =
+          Class::Handle(zone, core_lib.LookupClass(Symbols::List()));
+      ASSERT(!list_class.IsNull());
+      list_rare_type ^= list_class.RareType();
+      object_store->set_non_nullable_list_rare_type(list_rare_type);
+    }
     const Instance& instance = Instance::Cast(obj);
     const Class& obj_class = Class::Handle(zone, obj.clazz());
     if (Class::IsSubtypeOf(NNBDMode::kLegacyLib, obj_class,
-                           Object::null_type_arguments(), list_class,
-                           Object::null_type_arguments(), Heap::kNew)) {
+                           Object::null_type_arguments(), list_rare_type,
+                           Heap::kNew)) {
       return instance.raw();
     }
   }
@@ -163,15 +170,22 @@ static RawInstance* GetListInstance(Zone* zone, const Object& obj) {
 
 static RawInstance* GetMapInstance(Zone* zone, const Object& obj) {
   if (obj.IsInstance()) {
-    const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
-    const Class& map_class =
-        Class::Handle(core_lib.LookupClass(Symbols::Map()));
-    ASSERT(!map_class.IsNull());
+    ObjectStore* object_store = Isolate::Current()->object_store();
+    Type& map_rare_type =
+        Type::Handle(zone, object_store->non_nullable_map_rare_type());
+    if (map_rare_type.IsNull()) {
+      const Library& core_lib = Library::Handle(zone, Library::CoreLibrary());
+      const Class& map_class =
+          Class::Handle(zone, core_lib.LookupClass(Symbols::Map()));
+      ASSERT(!map_class.IsNull());
+      map_rare_type ^= map_class.RareType();
+      object_store->set_non_nullable_map_rare_type(map_rare_type);
+    }
     const Instance& instance = Instance::Cast(obj);
     const Class& obj_class = Class::Handle(zone, obj.clazz());
     if (Class::IsSubtypeOf(NNBDMode::kLegacyLib, obj_class,
-                           Object::null_type_arguments(), map_class,
-                           Object::null_type_arguments(), Heap::kNew)) {
+                           Object::null_type_arguments(), map_rare_type,
+                           Heap::kNew)) {
       return instance.raw();
     }
   }
@@ -2212,16 +2226,21 @@ DART_EXPORT bool Dart_IsByteBuffer(Dart_Handle handle) {
 DART_EXPORT bool Dart_IsFuture(Dart_Handle handle) {
   DARTSCOPE(Thread::Current());
   API_TIMELINE_DURATION(T);
-  Isolate* I = T->isolate();
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(handle));
   if (obj.IsInstance()) {
-    const Class& future_class =
-        Class::Handle(I->object_store()->future_class());
-    ASSERT(!future_class.IsNull());
+    ObjectStore* object_store = T->isolate()->object_store();
+    Type& future_rare_type =
+        Type::Handle(Z, object_store->non_nullable_future_rare_type());
+    if (future_rare_type.IsNull()) {
+      const Class& future_class = Class::Handle(object_store->future_class());
+      ASSERT(!future_class.IsNull());
+      future_rare_type ^= future_class.RareType();
+      object_store->set_non_nullable_future_rare_type(future_rare_type);
+    }
     const Class& obj_class = Class::Handle(Z, obj.clazz());
-    bool is_future = Class::IsSubtypeOf(
-        NNBDMode::kLegacyLib, obj_class, Object::null_type_arguments(),
-        future_class, Object::null_type_arguments(), Heap::kNew);
+    bool is_future = Class::IsSubtypeOf(NNBDMode::kLegacyLib, obj_class,
+                                        Object::null_type_arguments(),
+                                        future_rare_type, Heap::kNew);
     return is_future;
   }
   return false;
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
@@ -4858,56 +4858,94 @@ bool Class::IsFutureClass() const {
          (library() == Library::AsyncLibrary());
 }
 
-// Checks if type S is a subtype of type T, assuming that S is non-nullable.
-// Type S is specified by class 'cls' parameterized with 'type_arguments', and
-// type T by class 'other' parameterized with 'other_type_arguments'.
+// Checks if type T0 is a subtype of type T1, assuming that T0 is non-nullable.
+// Type T0 is specified by class 'cls' parameterized with 'type_arguments', and
+// type T1 is specified by 'other' and must have a type class.
 // This class and class 'other' do not need to be finalized, however, they must
 // be resolved as well as their interfaces.
 bool Class::IsSubtypeOf(NNBDMode mode,
                         const Class& cls,
                         const TypeArguments& type_arguments,
-                        const Class& other,
-                        const TypeArguments& other_type_arguments,
+                        const AbstractType& other,
                         Heap::Space space) {
-  // This function does not support Null, dynamic, or void as type S.
-  ASSERT(!cls.IsNullClass() && !cls.IsDynamicClass() && !cls.IsVoidClass());
-  // Since we assume that S is non-nullable, the nullability of T is irrelevant.
-  if (other.IsDynamicClass() || other.IsVoidClass() || other.IsObjectClass()) {
+  // This function does not support Null, Never, dynamic, or void as type T0.
+  classid_t this_cid = cls.id();
+  ASSERT(this_cid != kNullCid && this_cid != kNeverCid &&
+         this_cid != kDynamicCid && this_cid != kVoidCid);
+  // Type T1 must have a type class (e.g. not a type parameter).
+  ASSERT(other.HasTypeClass());
+  const classid_t other_cid = other.type_class_id();
+  // Since T0 is assumed non-nullable, the nullability of T1 is irrelevant.
+  if (other_cid == kDynamicCid || other_cid == kVoidCid ||
+      other_cid == kObjectCid) {
     return true;
   }
-  // Use the 'this_class' object as if it was the receiver of this method, but
-  // instead of recursing, reset it to the super class and loop.
   Thread* thread = Thread::Current();
   Zone* zone = thread->zone();
+  const Class& other_class = Class::Handle(zone, other.type_class());
+  const TypeArguments& other_type_arguments =
+      TypeArguments::Handle(zone, other.arguments());
+  // Use the 'this_class' object as if it was the receiver of this method, but
+  // instead of recursing, reset it to the super class and loop.
   Class& this_class = Class::Handle(zone, cls.raw());
   while (true) {
-    // Apply additional subtyping rules if 'other' is 'FutureOr'.
-    if (other.IsFutureOrClass()) {
-      if (other_type_arguments.IsNull()) {
-        return true;
+    // Apply additional subtyping rules if T0 or T1 are 'FutureOr'.
+
+    // Left FutureOr:
+    //   if T0 is FutureOr<S0> then:
+    //     T0 <: T1 iff Future<S0> <: T1 and S0 <: T1
+    if (this_cid == kFutureOrCid) {
+      // Check Future<S0> <: T1.
+      ObjectStore* object_store = Isolate::Current()->object_store();
+      const Class& future_class =
+          Class::Handle(zone, object_store->future_class());
+      ASSERT(!future_class.IsNull() && future_class.NumTypeParameters() == 1 &&
+             this_class.NumTypeParameters() == 1);
+      ASSERT(type_arguments.IsNull() || type_arguments.Length() >= 1);
+      if (Class::IsSubtypeOf(mode, future_class, type_arguments, other,
+                             space)) {
+        // Check S0 <: T1.
+        const AbstractType& type_arg =
+            AbstractType::Handle(zone, type_arguments.TypeAtNullSafe(0));
+        if (type_arg.IsSubtypeOf(mode, other, space)) {
+          return true;
+        }
       }
+    }
+
+    // Right FutureOr:
+    //   if T1 is FutureOr<S1> then:
+    //     T0 <: T1 iff any of the following hold:
+    //     either T0 <: Future<S1>
+    //     or T0 <: S1
+    //     or T0 is X0 and X0 has bound S0 and S0 <: T1  (checked elsewhere)
+    if (other_cid == kFutureOrCid) {
       const AbstractType& other_type_arg =
-          AbstractType::Handle(zone, other_type_arguments.TypeAt(0));
+          AbstractType::Handle(zone, other_type_arguments.TypeAtNullSafe(0));
+      // Check if S1 is a top type.
       if (other_type_arg.IsTopType()) {
         return true;
       }
-      if (!type_arguments.IsNull() && this_class.IsFutureClass()) {
+      // Check T0 <: Future<S1> when T0 is Future<S0>.
+      if (this_class.IsFutureClass()) {
         const AbstractType& type_arg =
-            AbstractType::Handle(zone, type_arguments.TypeAt(0));
+            AbstractType::Handle(zone, type_arguments.TypeAtNullSafe(0));
+        // If T0 is Future<S0>, then T0 <: Future<S1>, iff S0 <: S1.
         if (type_arg.IsSubtypeOf(mode, other_type_arg, space)) {
           return true;
         }
       }
+      // Check T0 <: Future<S1> when T0 is FutureOr<S0> is already done.
+      // Check T0 <: S1.
       if (other_type_arg.HasTypeClass() &&
-          Class::IsSubtypeOf(
-              mode, this_class, type_arguments,
-              Class::Handle(zone, other_type_arg.type_class()),
-              TypeArguments::Handle(zone, other_type_arg.arguments()), space)) {
+          Class::IsSubtypeOf(mode, this_class, type_arguments, other_type_arg,
+                             space)) {
         return true;
       }
     }
+
     // Check for reflexivity.
-    if (this_class.raw() == other.raw()) {
+    if (this_class.raw() == other_class.raw()) {
       const intptr_t num_type_params = this_class.NumTypeParameters();
       if (num_type_params == 0) {
         return true;
@@ -4961,7 +4999,7 @@ bool Class::IsSubtypeOf(NNBDMode mode,
         continue;
       }
       if (Class::IsSubtypeOf(mode, interface_class, interface_args, other,
-                             other_type_arguments, space)) {
+                             space)) {
         return true;
       }
     }
@@ -4970,6 +5008,7 @@ bool Class::IsSubtypeOf(NNBDMode mode,
     if (this_class.IsNull()) {
       return false;
     }
+    this_cid = this_class.id();
   }
   UNREACHABLE();
   return false;
@@ -17569,35 +17608,28 @@ bool Instance::RuntimeTypeIsSubtypeOf(
   }
   // RuntimeType of non-null instance is non-nullable, so there is no need to
   // check nullability of other type.
-  return Class::IsSubtypeOf(
-      mode, cls, type_arguments,
-      Class::Handle(zone, instantiated_other.type_class()),
-      TypeArguments::Handle(zone, instantiated_other.arguments()), Heap::kOld);
+  return Class::IsSubtypeOf(mode, cls, type_arguments, instantiated_other,
+                            Heap::kOld);
 }
 
 bool Instance::IsFutureOrInstanceOf(Zone* zone,
                                     NNBDMode mode,
                                     const AbstractType& other) const {
   if (other.IsType() && other.IsFutureOrType()) {
-    if (other.arguments() == TypeArguments::null()) {
-      return true;
-    }
     const TypeArguments& other_type_arguments =
         TypeArguments::Handle(zone, other.arguments());
     const AbstractType& other_type_arg =
-        AbstractType::Handle(zone, other_type_arguments.TypeAt(0));
+        AbstractType::Handle(zone, other_type_arguments.TypeAtNullSafe(0));
     if (other_type_arg.IsTopType()) {
       return true;
     }
     if (Class::Handle(zone, clazz()).IsFutureClass()) {
       const TypeArguments& type_arguments =
           TypeArguments::Handle(zone, GetTypeArguments());
-      if (!type_arguments.IsNull()) {
-        const AbstractType& type_arg =
-            AbstractType::Handle(zone, type_arguments.TypeAt(0));
-        if (type_arg.IsSubtypeOf(mode, other_type_arg, Heap::kOld)) {
-          return true;
-        }
+      const AbstractType& type_arg =
+          AbstractType::Handle(zone, type_arguments.TypeAtNullSafe(0));
+      if (type_arg.IsSubtypeOf(mode, other_type_arg, Heap::kOld)) {
+        return true;
       }
     }
     // Retry RuntimeTypeIsSubtypeOf after unwrapping type arg of FutureOr.
@@ -18396,26 +18428,22 @@ bool AbstractType::IsSubtypeOf(NNBDMode mode,
     return false;
   }
   return Class::IsSubtypeOf(
-      mode, type_cls, TypeArguments::Handle(zone, arguments()), other_type_cls,
-      TypeArguments::Handle(zone, other.arguments()), space);
+      mode, type_cls, TypeArguments::Handle(zone, arguments()), other, space);
 }
 
 bool AbstractType::IsSubtypeOfFutureOr(Zone* zone,
                                        NNBDMode mode,
                                        const AbstractType& other,
                                        Heap::Space space) const {
   if (other.IsType() && other.IsFutureOrType()) {
-    if (other.arguments() == TypeArguments::null()) {
-      return true;
-    }
     // This function is only called with a receiver that is either a function
     // type or an uninstantiated type parameter, therefore, it cannot be of
     // class Future and we can spare the check.
     ASSERT(IsFunctionType() || IsTypeParameter());
     const TypeArguments& other_type_arguments =
         TypeArguments::Handle(zone, other.arguments());
     const AbstractType& other_type_arg =
-        AbstractType::Handle(zone, other_type_arguments.TypeAt(0));
+        AbstractType::Handle(zone, other_type_arguments.TypeAtNullSafe(0));
     if (other_type_arg.IsTopType()) {
       return true;
     }
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
@@ -1226,13 +1226,12 @@ class Class : public Object {
         cls->ptr()->library_->ptr()->flags_);
   }
 
-  // Returns true if the type specified by cls and type_arguments is a
-  // subtype of the type specified by other class and other_type_arguments.
+  // Returns true if the type specified by cls and type_arguments is a subtype
+  // of the other type.
   static bool IsSubtypeOf(NNBDMode mode,
                           const Class& cls,
                           const TypeArguments& type_arguments,
-                          const Class& other,
-                          const TypeArguments& other_type_arguments,
+                          const AbstractType& other,
                           Heap::Space space);
 
   // Check if this is the top level class.
diff --git a/runtime/vm/object_store.h b/runtime/vm/object_store.h
@@ -73,6 +73,9 @@ class ObjectPointerVisitor;
   RW(Type, string_type)                                                        \
   RW(Type, legacy_string_type)                                                 \
   RW(Type, non_nullable_string_type)                                           \
+  RW(Type, non_nullable_list_rare_type)   /* maybe be null, lazily built */    \
+  RW(Type, non_nullable_map_rare_type)    /* maybe be null, lazily built */    \
+  RW(Type, non_nullable_future_rare_type) /* maybe be null, lazily built */    \
   RW(TypeArguments, type_argument_int)                                         \
   RW(TypeArguments, type_argument_legacy_int)                                  \
   RW(TypeArguments, type_argument_non_nullable_int)                            \
