[torque] move class tests to unittests

This avoids the generation of fake external classes.

Bug: v8:7793
Change-Id: I9744b299d3ec474d72b298b4f6143f95e345d1d9
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1625991Reviewed-by: Simon Zünd <szuend@chromium.org>
Reviewed-by: Sigurd Schneider <sigurds@chromium.org>
Commit-Queue: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61778}

src/torque/implementation-visitor.cc

@@ -155,40 +155,19 @@ void ImplementationVisitor::Visit(NamespaceConstant* decl) {
 
 void ImplementationVisitor::Visit(TypeAlias* alias) {
   if (alias->IsRedeclaration()) return;
-  const ClassType* class_type = ClassType::DynamicCast(alias->type());
-  if (class_type && class_type->IsExtern()) {
-    // Classes that are in the default namespace are defined in the C++
-    // world and all of their fields and methods are declared explicitly.
-    // Internal classes (e.g. ones used for testing that are not in the default
-    // name space) need to be defined by Torque.
-    // TODO(danno): This is a pretty cheesy hack for now. There should be a more
-    // robust mechanism for this, e.g. declaring classes 'extern' or something.
-    if (class_type->nspace()->IsTestNamespace()) {
-      const ClassType* super = class_type->GetSuperClass();
-      std::string class_name{super->GetGeneratedTNodeTypeName()};
-      header_out() << "  class " << class_type->name() << " : public "
-                   << class_name << " {\n";
-      header_out() << "   public:\n";
-      header_out() << "    DEFINE_FIELD_OFFSET_CONSTANTS(" << class_name
-                   << "::";
-      header_out() << (super->IsAbstract() ? "kHeaderSize" : "kSize");
-      header_out() << ", TORQUE_GENERATED_"
-                   << CapifyStringWithUnderscores(class_type->name())
-                   << "_FIELDS)\n";
-      header_out() << "  };\n";
-    } else if (!class_type->nspace()->IsDefaultNamespace()) {
-      ReportError(
-          "extern classes are currently only supported in the default and test "
-          "namespaces");
-    }
-    return;
-  }
-  const StructType* struct_type = StructType::DynamicCast(alias->type());
-  if (!struct_type) return;
+  if (const ClassType* class_type = ClassType::DynamicCast(alias->type())) {
+    if (class_type->IsExtern() && !class_type->nspace()->IsDefaultNamespace()) {
+      Error(
+          "extern classes are currently only supported in the default "
+          "namespace");
+    }
+  } else if (const StructType* struct_type =
+                 StructType::DynamicCast(alias->type())) {
     const std::string& name = struct_type->name();
     header_out() << "  struct " << name << " {\n";
     for (auto& field : struct_type->fields()) {
-    header_out() << "    " << field.name_and_type.type->GetGeneratedTypeName();
+      header_out() << "    "
+                   << field.name_and_type.type->GetGeneratedTypeName();
       header_out() << " " << field.name_and_type.name << ";\n";
     }
     header_out() << "\n    std::tuple<";
@@ -217,6 +196,7 @@ void ImplementationVisitor::Visit(TypeAlias* alias) {
     header_out() << ");\n";
     header_out() << "    }\n";
     header_out() << "  };\n";
+  }
 }
 
 VisitResult ImplementationVisitor::InlineMacro(

test/torque/test-torque.tq

@@ -823,59 +823,6 @@ namespace test {
     assert(a.b.GetX() == 2);
   }
 
-  @noVerifier
-  extern class TestClassWithAllTypes extends JSObject {
-    a: int8;
-    b: uint8;
-    b2: uint8;
-    b3: uint8;
-    c: int16;
-    d: uint16;
-    e: int32;
-    f: uint32;
-    g: RawPtr;
-    h: intptr;
-    i: uintptr;
-  }
-
-  // This class should throw alignment errors if @if decorators aren't
-  // working.
-  @noVerifier
-  extern class PreprocessingTest extends JSObject {
-    @if(FALSE_FOR_TESTING) a: int8;
-    @if(TRUE_FOR_TESTING) a: int16;
-    b: int16;
-    d: int32;
-    @ifnot(TRUE_FOR_TESTING) e: int8;
-    @ifnot(FALSE_FOR_TESTING) f: int16;
-    g: int16;
-    h: int32;
-  }
-
-  @export
-  macro TestClassWithAllTypesLoadsAndStores(
-      t: TestClassWithAllTypes, r: RawPtr, v1: int8, v2: uint8, v3: int16,
-      v4: uint16) {
-    t.a = v1;
-    t.b = v2;
-    t.c = v3;
-    t.d = v4;
-    t.e = 0;
-    t.f = 0;
-    t.g = r;
-    t.h = 0;
-    t.i = 0;
-    t.a = t.a;
-    t.b = t.b;
-    t.c = t.c;
-    t.d = t.d;
-    t.e = t.e;
-    t.f = t.f;
-    t.g = t.g;
-    t.h = t.h;
-    t.i = t.i;
-  }
-
   class InternalClass {
     Flip() labels NotASmi {
       const tmp = Cast<Smi>(this.b) otherwise NotASmi;
@@ -956,24 +903,6 @@ namespace test {
     check(array.b == 9);
   }
 
-  type Baztype = Foo | FooType;
-
-  @abstract
-  @noVerifier
-  extern class Foo extends JSObject {
-    fooField: FooType;
-  }
-
-  @noVerifier
-  extern class Bar extends Foo {
-    barField: Bartype;
-    bazfield: Baztype;
-  }
-
-  type Bartype = FooType;
-
-  type FooType = Smi | Bar;
-
   @export
   macro TestStaticAssert() {
     StaticAssert(1 + 2 == 3);

test/unittests/torque/torque-unittest.cc

@@ -13,17 +13,83 @@ namespace torque {
 
 namespace {
 
-TorqueCompilerResult TestCompileTorque(const std::string& source) {
+// This is a simplified version of the basic Torque type definitions.
+// Some class types are replaced by abstact types to keep it self-contained and
+// small.
+constexpr const char* kTestTorquePrelude = R"(
+type void;
+type never;
+
+type Tagged generates 'TNode<Object>' constexpr 'ObjectPtr';
+type Smi extends Tagged generates 'TNode<Smi>' constexpr 'Smi';
+
+@abstract
+extern class HeapObject extends Tagged {
+  map: Map;
+}
+type Map extends HeapObject generates 'TNode<Map>';
+type Object = Smi | HeapObject;
+type JSReceiver extends HeapObject generates 'TNode<JSReceiver>';
+type JSObject extends JSReceiver generates 'TNode<JSObject>';
+type int32 generates 'TNode<Int32T>' constexpr 'int32_t';
+type uint32 generates 'TNode<Uint32T>' constexpr 'uint32_t';
+type int31 extends int32
+    generates 'TNode<Int32T>' constexpr 'int31_t';
+type uint31 extends uint32
+    generates 'TNode<Uint32T>' constexpr 'uint31_t';
+type int16 extends int31
+    generates 'TNode<Int16T>' constexpr 'int16_t';
+type uint16 extends uint31
+    generates 'TNode<Uint16T>' constexpr 'uint16_t';
+type int8 extends int16 generates 'TNode<Int8T>' constexpr 'int8_t';
+type uint8 extends uint16
+    generates 'TNode<Uint8T>' constexpr 'uint8_t';
+type int64 generates 'TNode<Int64T>' constexpr 'int64_t';
+type intptr generates 'TNode<IntPtrT>' constexpr 'intptr_t';
+type uintptr generates 'TNode<UintPtrT>' constexpr 'uintptr_t';
+type float32 generates 'TNode<Float32T>' constexpr 'float';
+type float64 generates 'TNode<Float64T>' constexpr 'double';
+type bool generates 'TNode<BoolT>' constexpr 'bool';
+type bint generates 'TNode<BInt>' constexpr 'BInt';
+type string constexpr 'const char*';
+type RawPtr generates 'TNode<RawPtrT>' constexpr 'void*';
+type Code extends HeapObject generates 'TNode<Code>';
+type BuiltinPtr extends Smi generates 'TNode<BuiltinPtr>';
+type Context extends HeapObject generates 'TNode<Context>';
+type NativeContext extends Context;
+)";
+
+TorqueCompilerResult TestCompileTorque(std::string source) {
   TorqueCompilerOptions options;
   options.output_directory = "";
   options.collect_language_server_data = false;
   options.force_assert_statements = false;
 
+  source = kTestTorquePrelude + source;
   return CompileTorque(source, options);
 }
 
+void ExpectSuccessfulCompilation(std::string source) {
+  TorqueCompilerResult result = TestCompileTorque(std::move(source));
+  std::vector<std::string> messages;
+  for (const auto& message : result.messages) {
+    messages.push_back(message.message);
+  }
+  EXPECT_EQ(messages, std::vector<std::string>{});
+}
+
+template <class T>
+void ExpectFailingCompilation(
+    std::string source, ::testing::PolymorphicMatcher<T> message_pattern) {
+  TorqueCompilerResult result = TestCompileTorque(std::move(source));
+  ASSERT_FALSE(result.messages.empty());
+  EXPECT_THAT(result.messages[0].message, message_pattern);
+}
+
 }  // namespace
 
+TEST(Torque, Prelude) { ExpectSuccessfulCompilation(""); }
+
 TEST(Torque, StackDeleteRange) {
   Stack<int> stack = {1, 2, 3, 4, 5, 6, 7};
   stack.DeleteRange(StackRange{BottomOffset{2}, BottomOffset{4}});
@@ -33,31 +99,112 @@ TEST(Torque, StackDeleteRange) {
 
 using ::testing::HasSubstr;
 TEST(Torque, TypeNamingConventionLintError) {
-  std::string source = R"(
-    type void;
-    type never;
-
+  ExpectFailingCompilation(R"(
     type foo generates 'TNode<Foo>';
-  )";
+  )",
+                           HasSubstr("\"foo\""));
+}
 
-  const TorqueCompilerResult result = TestCompileTorque(source);
+TEST(Torque, StructNamingConventionLintError) {
+  ExpectFailingCompilation(R"(
+    struct foo {}
+  )",
+                           HasSubstr("\"foo\""));
+}
 
-  ASSERT_EQ(result.messages.size(), static_cast<size_t>(1));
-  EXPECT_THAT(result.messages[0].message, HasSubstr("\"foo\""));
+TEST(Torque, ClassDefinition) {
+  ExpectSuccessfulCompilation(R"(
+    extern class TestClassWithAllTypes extends HeapObject {
+      a: int8;
+      b: uint8;
+      b2: uint8;
+      b3: uint8;
+      c: int16;
+      d: uint16;
+      e: int32;
+      f: uint32;
+      g: RawPtr;
+      h: intptr;
+      i: uintptr;
+    }
+
+    macro TestClassWithAllTypesLoadsAndStores(
+        t: TestClassWithAllTypes, r: RawPtr, v1: int8, v2: uint8, v3: int16,
+        v4: uint16, v5: int32, v6: uint32, v7: intptr, v8: uintptr) {
+      t.a = v1;
+      t.b = v2;
+      t.c = v3;
+      t.d = v4;
+      t.e = v5;
+      t.f = v6;
+      t.g = r;
+      t.h = v7;
+      t.i = v8;
+      t.a = t.a;
+      t.b = t.b;
+      t.c = t.c;
+      t.d = t.d;
+      t.e = t.e;
+      t.f = t.f;
+      t.g = t.g;
+      t.h = t.h;
+      t.i = t.i;
+    }
+  )");
 }
 
-TEST(Torque, StructNamingConventionLintError) {
-  const std::string source = R"(
-    type void;
-    type never;
+TEST(Torque, TypeDeclarationOrder) {
+  ExpectSuccessfulCompilation(R"(
+    type Baztype = Foo | FooType;
 
-    struct foo {}
-  )";
+    @abstract
+    @noVerifier
+    extern class Foo extends HeapObject {
+      fooField: FooType;
+    }
+
+    @noVerifier
+    extern class Bar extends Foo {
+      barField: Bartype;
+      bazfield: Baztype;
+    }
 
-  const TorqueCompilerResult result = TestCompileTorque(source);
+    type Bartype = FooType;
+
+    type FooType = Smi | Bar;
+  )");
+}
 
-  ASSERT_EQ(result.messages.size(), static_cast<size_t>(1));
-  EXPECT_THAT(result.messages[0].message, HasSubstr("\"foo\""));
+TEST(Torque, ConditionalFields) {
+  // This class should throw alignment errors if @if decorators aren't
+  // working.
+  ExpectSuccessfulCompilation(R"(
+  @noVerifier
+  extern class PreprocessingTest extends HeapObject {
+    @if(FALSE_FOR_TESTING) a: int8;
+    @if(TRUE_FOR_TESTING) a: int16;
+    b: int16;
+    d: int32;
+    @ifnot(TRUE_FOR_TESTING) e: int8;
+    @ifnot(FALSE_FOR_TESTING) f: int16;
+    g: int16;
+    h: int32;
+  }
+  )");
+  ExpectFailingCompilation(R"(
+  @noVerifier
+  extern class PreprocessingTest extends HeapObject {
+    @if(TRUE_FOR_TESTING) a: int8;
+    @if(FALSE_FOR_TESTING) a: int16;
+    b: int16;
+    d: int32;
+    @ifnot(FALSE_FOR_TESTING) e: int8;
+    @ifnot(TRUE_FOR_TESTING) f: int16;
+    g: int16;
+    h: int32;
+  }
+  )",
+                           HasSubstr("aligned"));
 }
 
 }  // namespace torque