[VM/nnbd] Introduce type Never in VM and bytecode.

crelier · commit-bot@chromium.org · commit df678dbec0db · 2019-11-01T00:43:59.000Z
Introduce enum NNBDMode for subtype test checking mode. Change-Id: Id9c39ee8c975c664ac58e313b7dd05e6e219dfc1 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/123557 Reviewed-by: Ryan Macnak <rmacnak@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com> Commit-Queue: Régis Crelier <regis@google.com>
diff --git a/pkg/front_end/testcases/strong.status b/pkg/front_end/testcases/strong.status
@@ -112,7 +112,6 @@ inference_new/invalid_assignment_during_toplevel_inference: TypeCheckError
 instantiate_to_bound/non_simple_class_parametrized_typedef_cycle: RuntimeError # Expected
 instantiate_to_bound/non_simple_generic_function_in_bound_regress: RuntimeError # Expected
 nnbd/nullable_param: RuntimeError
-nnbd/simple_never: RuntimeError
 rasta/abstract_constructor: RuntimeError
 rasta/bad_constructor_redirection: RuntimeError
 rasta/bad_continue: RuntimeError
diff --git a/pkg/vm/lib/bytecode/dbc.dart b/pkg/vm/lib/bytecode/dbc.dart
@@ -10,7 +10,7 @@ library vm.bytecode.dbc;
 /// Before bumping current bytecode version format, make sure that
 /// all users have switched to a VM which is able to consume new
 /// version of bytecode.
-const int currentBytecodeFormatVersion = 24;
+const int currentBytecodeFormatVersion = 25;
 
 enum Opcode {
   kUnusedOpcode000,
diff --git a/pkg/vm/lib/bytecode/object_table.dart b/pkg/vm/lib/bytecode/object_table.dart
@@ -201,6 +201,11 @@ type VoidType extends Type {
   typeTag (flags) = 2
 }
 
+type NeverType extends Type {
+  kind = 15
+  typeTag (flags) = 9
+}
+
 // SimpleType can be used only for types without instantiator type arguments.
 type SimpleType extends Type {
   kind = 15
@@ -321,6 +326,7 @@ enum TypeTag {
   kRecursiveGenericType,
   kRecursiveTypeRef,
   kFunctionType,
+  kNever,
 }
 
 /// Name of artificial class containing top-level members of a library.
@@ -419,6 +425,8 @@ abstract class ObjectHandle extends BytecodeObject {
             return new _DynamicTypeHandle();
           case TypeTag.kVoid:
             return new _VoidTypeHandle();
+          case TypeTag.kNever:
+            return new _NeverTypeHandle();
           case TypeTag.kSimpleType:
             return new _SimpleTypeHandle._empty(nullability);
           case TypeTag.kTypeParameter:
@@ -737,6 +745,25 @@ class _VoidTypeHandle extends _TypeHandle {
   String toString() => 'void';
 }
 
+class _NeverTypeHandle extends _TypeHandle {
+  _NeverTypeHandle() : super(TypeTag.kNever, Nullability.nonNullable);
+
+  @override
+  void writeContents(BufferedWriter writer) {}
+
+  @override
+  void readContents(BufferedReader reader) {}
+
+  @override
+  int get hashCode => 2049;
+
+  @override
+  bool operator ==(other) => other is _NeverTypeHandle;
+
+  @override
+  String toString() => 'Never';
+}
+
 class _SimpleTypeHandle extends _TypeHandle {
   _ClassHandle class_;
 
@@ -1717,12 +1744,14 @@ class ObjectTable implements ObjectWriter, ObjectReader {
   List<ObjectHandle> _indexTable;
   _TypeHandle _dynamicType;
   _TypeHandle _voidType;
+  _TypeHandle _neverType;
   CoreTypes coreTypes;
   _NodeVisitor _nodeVisitor;
 
   ObjectTable() {
     _dynamicType = getOrAddObject(new _DynamicTypeHandle());
     _voidType = getOrAddObject(new _VoidTypeHandle());
+    _neverType = getOrAddObject(new _NeverTypeHandle());
     _nodeVisitor = new _NodeVisitor(this);
   }
 
@@ -2098,6 +2127,9 @@ class _NodeVisitor extends Visitor<ObjectHandle> {
   @override
   ObjectHandle visitVoidType(VoidType node) => objectTable._voidType;
 
+  @override
+  ObjectHandle visitNeverType(NeverType node) => objectTable._neverType;
+
   @override
   ObjectHandle visitBottomType(BottomType node) =>
       objectTable.getHandle(objectTable.coreTypes.nullType);
diff --git a/runtime/lib/mirrors.cc b/runtime/lib/mirrors.cc
@@ -625,6 +625,10 @@ static RawInstance* CreateTypeMirror(const AbstractType& type) {
       Array& args = Array::Handle(Array::New(1));
       args.SetAt(0, Symbols::Dynamic());
       return CreateMirror(Symbols::_SpecialTypeMirror(), args);
+    } else if (cls.IsNeverClass()) {
+      Array& args = Array::Handle(Array::New(1));
+      args.SetAt(0, Symbols::Never());
+      return CreateMirror(Symbols::_SpecialTypeMirror(), args);
     }
     // TODO(regis): Until mirrors reflect nullability, force kLegacy, except for
     // Null type, which should remain nullable.
diff --git a/runtime/vm/class_id.h b/runtime/vm/class_id.h
@@ -208,10 +208,11 @@ enum ClassId {
   // clang-format on
 
   // The following entries do not describe a predefined class, but instead
-  // are class indexes for pre-allocated instances (Null, dynamic and Void).
+  // are class indexes for pre-allocated instances (Null, dynamic, void, Never).
   kNullCid,
   kDynamicCid,
   kVoidCid,
+  kNeverCid,
 
   kNumPredefinedCids,
 };
diff --git a/runtime/vm/class_table.cc b/runtime/vm/class_table.cc
@@ -44,6 +44,7 @@ SharedClassTable::SharedClassTable()
         vm_shared_class_table->SizeAt(kForwardingCorpse);
     table_[kDynamicCid] = vm_shared_class_table->SizeAt(kDynamicCid);
     table_[kVoidCid] = vm_shared_class_table->SizeAt(kVoidCid);
+    table_[kNeverCid] = vm_shared_class_table->SizeAt(kNeverCid);
   }
 #ifndef PRODUCT
   class_heap_stats_table_ = static_cast<ClassHeapStats*>(
@@ -90,6 +91,7 @@ ClassTable::ClassTable(SharedClassTable* shared_class_table)
     table_[kForwardingCorpse] = vm_class_table->At(kForwardingCorpse);
     table_[kDynamicCid] = vm_class_table->At(kDynamicCid);
     table_[kVoidCid] = vm_class_table->At(kVoidCid);
+    table_[kNeverCid] = vm_class_table->At(kNeverCid);
   }
 }
 
diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
@@ -4902,6 +4902,7 @@ void Serializer::AddVMIsolateBaseObjects() {
   }
   AddBaseObject(table->At(kDynamicCid), "Class");
   AddBaseObject(table->At(kVoidCid), "Class");
+  AddBaseObject(table->At(kNeverCid), "Class");
 
   if (!Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
@@ -5360,6 +5361,7 @@ void Deserializer::AddVMIsolateBaseObjects() {
   }
   AddBaseObject(table->At(kDynamicCid));
   AddBaseObject(table->At(kVoidCid));
+  AddBaseObject(table->At(kNeverCid));
 
   if (!Snapshot::IncludesCode(kind_)) {
     for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
@@ -1573,8 +1573,9 @@ void Precompiler::AttachOptimizedTypeTestingStub() {
     const AbstractType& type = types.At(i);
 
     if (type.InVMIsolateHeap()) {
-      // The only important types in the vm isolate are "dynamic"/"void", which
-      // will get their optimized top-type testing stub installed at creation.
+      // The only important types in the vm isolate are
+      // "dynamic"/"void"/"Never", which will get their optimized
+      // testing stub installed at creation.
       continue;
     }
 
diff --git a/runtime/vm/compiler/backend/il.cc b/runtime/vm/compiler/backend/il.cc
@@ -204,6 +204,7 @@ void HierarchyInfo::BuildRangesFor(ClassTable* table,
     if (cid == kTypeArgumentsCid) continue;
     if (cid == kVoidCid) continue;
     if (cid == kDynamicCid) continue;
+    if (cid == kNeverCid) continue;
     if (cid == kNullCid && !exclude_null) continue;
     cls = table->At(cid);
     if (!include_abstract && cls.is_abstract()) continue;
diff --git a/runtime/vm/compiler/frontend/bytecode_reader.cc b/runtime/vm/compiler/frontend/bytecode_reader.cc
@@ -1689,6 +1689,7 @@ RawObject* BytecodeReaderHelper::ReadType(intptr_t tag,
     kRecursiveGenericType,
     kRecursiveTypeRef,
     kFunctionType,
+    kNever,
   };
 
   // FunctionType flags, must be in sync with _FunctionTypeHandle constants in
@@ -1705,6 +1706,8 @@ RawObject* BytecodeReaderHelper::ReadType(intptr_t tag,
       return AbstractType::dynamic_type().raw();
     case kVoid:
       return AbstractType::void_type().raw();
+    case kNever:
+      return AbstractType::never_type().raw();
     case kSimpleType: {
       const Class& cls = Class::CheckedHandle(Z, ReadObject());
       if (!cls.is_declaration_loaded()) {
diff --git a/runtime/vm/compiler/frontend/kernel_fingerprints.cc b/runtime/vm/compiler/frontend/kernel_fingerprints.cc
@@ -232,7 +232,6 @@ void KernelFingerprintHelper::CalculateDartTypeFingerprint() {
     case kNeverType:
       // those contain nothing.
       break;
-      UNIMPLEMENTED();
     case kInterfaceType:
       CalculateInterfaceTypeFingerprint(false);
       break;
diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.cc b/runtime/vm/compiler/frontend/kernel_translation_helper.cc
@@ -2789,7 +2789,7 @@ void TypeTranslator::BuildTypeInternal() {
       ASSERT(result_.IsNullable());
       break;
     case kNeverType:
-      UNREACHABLE();
+      result_ = Object::never_type().raw();
       break;
     case kInterfaceType:
       BuildInterfaceType(false);
diff --git a/runtime/vm/constants_kbc.h b/runtime/vm/constants_kbc.h
@@ -749,7 +749,7 @@ class KernelBytecode {
   // Maximum bytecode format version supported by VM.
   // The range of supported versions should include version produced by bytecode
   // generator (currentBytecodeFormatVersion in pkg/vm/lib/bytecode/dbc.dart).
-  static const intptr_t kMaxSupportedBytecodeFormatVersion = 24;
+  static const intptr_t kMaxSupportedBytecodeFormatVersion = 25;
 
   enum Opcode {
 #define DECLARE_BYTECODE(name, encoding, kind, op1, op2, op3) k##name,
diff --git a/runtime/vm/exceptions.cc b/runtime/vm/exceptions.cc
@@ -861,7 +861,8 @@ void Exceptions::CreateAndThrowTypeError(TokenPosition location,
     if (!src_type.IsNull()) {
       src_type.EnumerateURIs(&uris);
     }
-    if (!dst_type.IsDynamicType() && !dst_type.IsVoidType()) {
+    if (!dst_type.IsDynamicType() && !dst_type.IsVoidType() &&
+        !dst_type.IsNeverType()) {
       dst_type.EnumerateURIs(&uris);
     }
     const String& formatted_uris =
diff --git a/runtime/vm/interpreter.cc b/runtime/vm/interpreter.cc
@@ -3125,6 +3125,7 @@ RawObject* Interpreter::Call(RawFunction* function,
     // Perform type test of value if field type is not one of dynamic, object,
     // or void, and if the value is not null.
     RawObject* null_value = Object::null();
+    // TODO(regis): Revisit when type checking mode is not kUnaware anymore.
     if (cid != kDynamicCid && cid != kInstanceCid && cid != kVoidCid &&
         value != null_value) {
       RawSubtypeTestCache* cache = field->ptr()->type_test_cache_;
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
@@ -133,6 +133,7 @@ RawObject* Object::null_ = reinterpret_cast<RawObject*>(RAW_NULL);
 RawClass* Object::class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+RawClass* Object::never_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
 RawClass* Object::function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ -930,6 +931,13 @@ void Object::Init(Isolate* isolate) {
   cls.set_is_type_finalized();
   void_class_ = cls.raw();
 
+  cls = Class::New<Instance>(kNeverCid, isolate);
+  cls.set_num_type_arguments(0);
+  cls.set_is_finalized();
+  cls.set_is_declaration_loaded();
+  cls.set_is_type_finalized();
+  never_class_ = cls.raw();
+
   cls = Class::New<Type>(isolate);
   cls.set_is_finalized();
   cls.set_is_declaration_loaded();
@@ -941,6 +949,9 @@ void Object::Init(Isolate* isolate) {
   cls = void_class_;
   *void_type_ = Type::NewNonParameterizedType(cls);
 
+  cls = never_class_;
+  *never_type_ = Type::NewNonParameterizedType(cls);
+
   // Since TypeArguments objects are passed as function arguments, make them
   // behave as Dart instances, although they are just VM objects.
   // Note that we cannot set the super type to ObjectType, which does not live
@@ -1084,7 +1095,7 @@ void Object::Init(Isolate* isolate) {
 
 void Object::FinishInit(Isolate* isolate) {
   // The type testing stubs we initialize in AbstractType objects for the
-  // canonical type of kDynamicCid/kVoidCid need to be set in this
+  // canonical type of kDynamicCid/kVoidCid/kNeverCid need to be set in this
   // method, which is called after StubCode::InitOnce().
   Code& code = Code::Handle();
 
@@ -1093,13 +1104,17 @@ void Object::FinishInit(Isolate* isolate) {
 
   code = TypeTestingStubGenerator::DefaultCodeForType(*void_type_);
   void_type_->SetTypeTestingStub(code);
+
+  code = TypeTestingStubGenerator::DefaultCodeForType(*never_type_);
+  never_type_->SetTypeTestingStub(code);
 }
 
 void Object::Cleanup() {
   null_ = reinterpret_cast<RawObject*>(RAW_NULL);
   class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   dynamic_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   void_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
+  never_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   type_arguments_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   patch_class_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
   function_class_ = reinterpret_cast<RawClass*>(RAW_NULL);
@@ -1200,6 +1215,7 @@ void Object::FinalizeVMIsolate(Isolate* isolate) {
   SET_CLASS_NAME(class, Class);
   SET_CLASS_NAME(dynamic, Dynamic);
   SET_CLASS_NAME(void, Void);
+  SET_CLASS_NAME(never, Never);
   SET_CLASS_NAME(type_arguments, TypeArguments);
   SET_CLASS_NAME(patch_class, PatchClass);
   SET_CLASS_NAME(function, Function);
@@ -4057,6 +4073,8 @@ RawString* Class::GenerateUserVisibleName() const {
       return Symbols::Dynamic().raw();
     case kVoidCid:
       return Symbols::Void().raw();
+    case kNeverCid:
+      return Symbols::Never().raw();
     case kClassCid:
       return Symbols::Class().raw();
     case kTypeArgumentsCid:
@@ -17317,30 +17335,28 @@ bool AbstractType::IsNullTypeRef() const {
 }
 
 bool AbstractType::IsDynamicType() const {
-  if (IsCanonical()) {
-    return raw() == Object::dynamic_type().raw();
-  }
   return type_class_id() == kDynamicCid;
 }
 
 bool AbstractType::IsVoidType() const {
-  // The void type is always canonical, because void is a keyword.
-  return raw() == Object::void_type().raw();
+  return type_class_id() == kVoidCid;
+}
+
+bool AbstractType::IsNeverType() const {
+  return type_class_id() == kNeverCid;
 }
 
 bool AbstractType::IsObjectType() const {
   return type_class_id() == kInstanceCid;
 }
 
-bool AbstractType::IsTopType() const {
-  if (IsVoidType()) {
-    return true;
-  }
+bool AbstractType::IsTopType(NNBDMode mode) const {
   const classid_t cid = type_class_id();
   if (cid == kIllegalCid) {
     return false;
   }
-  if ((cid == kDynamicCid) || (cid == kInstanceCid)) {
+  if (cid == kDynamicCid || cid == kVoidCid ||
+      (cid == kInstanceCid && (mode != kStrong || IsNullable()))) {
     return true;
   }
   // FutureOr<T> where T is a top type behaves as a top type.
@@ -17354,7 +17370,7 @@ bool AbstractType::IsTopType() const {
         TypeArguments::Handle(zone, arguments());
     const AbstractType& type_arg =
         AbstractType::Handle(zone, type_arguments.TypeAt(0));
-    if (type_arg.IsTopType()) {
+    if (type_arg.IsTopType(mode)) {
       return true;
     }
   }
@@ -17581,7 +17597,8 @@ void AbstractType::SetTypeTestingStub(const Code& stub) const {
   if (stub.IsNull()) {
     // This only happens during bootstrapping when creating Type objects before
     // we have the instructions.
-    ASSERT(type_class_id() == kDynamicCid || type_class_id() == kVoidCid);
+    ASSERT(type_class_id() == kDynamicCid || type_class_id() == kVoidCid ||
+           type_class_id() == kNeverCid);
     StoreNonPointer(&raw_ptr()->type_test_stub_entry_point_, 0);
   } else {
     StoreNonPointer(&raw_ptr()->type_test_stub_entry_point_, stub.EntryPoint());
@@ -17601,6 +17618,10 @@ RawType* Type::VoidType() {
   return Object::void_type().raw();
 }
 
+RawType* Type::NeverType() {
+  return Object::never_type().raw();
+}
+
 RawType* Type::ObjectType() {
   return Isolate::Current()->object_store()->object_type();
 }
@@ -18018,6 +18039,11 @@ RawAbstractType* Type::Canonicalize(TrailPtr trail) const {
     return Object::dynamic_type().raw();
   }
 
+  if ((type_class_id() == kNeverCid) && (isolate != Dart::vm_isolate())) {
+    ASSERT(Object::never_type().IsCanonical());
+    return Object::never_type().raw();
+  }
+
   const Class& cls = Class::Handle(zone, type_class());
 
   // Fast canonical lookup/registry for simple types.
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
diff --git a/runtime/vm/snapshot.cc b/runtime/vm/snapshot.cc
diff --git a/runtime/vm/snapshot_ids.h b/runtime/vm/snapshot_ids.h
diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h
diff --git a/runtime/vm/type_testing_stubs.cc b/runtime/vm/type_testing_stubs.cc
diff --git a/tools/VERSION b/tools/VERSION

Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,7 @@ SharedClassTable::SharedClassTable()`
`44`	`44`	`vm_shared_class_table->SizeAt(kForwardingCorpse);`
`45`	`45`	`table_[kDynamicCid] = vm_shared_class_table->SizeAt(kDynamicCid);`
`46`	`46`	`table_[kVoidCid] = vm_shared_class_table->SizeAt(kVoidCid);`
	`47`	`+ table_[kNeverCid] = vm_shared_class_table->SizeAt(kNeverCid);`
`47`	`48`	`}`
`48`	`49`	`#ifndef PRODUCT`
`49`	`50`	`class_heap_stats_table_ = static_cast<ClassHeapStats*>(`
`@@ -90,6 +91,7 @@ ClassTable::ClassTable(SharedClassTable* shared_class_table)`
`90`	`91`	`table_[kForwardingCorpse] = vm_class_table->At(kForwardingCorpse);`
`91`	`92`	`table_[kDynamicCid] = vm_class_table->At(kDynamicCid);`
`92`	`93`	`table_[kVoidCid] = vm_class_table->At(kVoidCid);`
	`94`	`+ table_[kNeverCid] = vm_class_table->At(kNeverCid);`
`93`	`95`	`}`
`94`	`96`	`}`
`95`	`97`
Original file line number	Diff line number	Diff line change
`@@ -4902,6 +4902,7 @@ void Serializer::AddVMIsolateBaseObjects() {`
`4902`	`4902`	`}`
`4903`	`4903`	`AddBaseObject(table->At(kDynamicCid), "Class");`
`4904`	`4904`	`AddBaseObject(table->At(kVoidCid), "Class");`
	`4905`	`+ AddBaseObject(table->At(kNeverCid), "Class");`
`4905`	`4906`
`4906`	`4907`	`if (!Snapshot::IncludesCode(kind_)) {`
`4907`	`4908`	`for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {`
`@@ -5360,6 +5361,7 @@ void Deserializer::AddVMIsolateBaseObjects() {`
`5360`	`5361`	`}`
`5361`	`5362`	`AddBaseObject(table->At(kDynamicCid));`
`5362`	`5363`	`AddBaseObject(table->At(kVoidCid));`
	`5364`	`+ AddBaseObject(table->At(kNeverCid));`
`5363`	`5365`
`5364`	`5366`	`if (!Snapshot::IncludesCode(kind_)) {`
`5365`	`5367`	`for (intptr_t i = 0; i < StubCode::NumEntries(); i++) {`