Revert "[torque] move class tests to unittests"

This reverts commit f589d561.

Reason for revert: failing win64 asan
https://ci.chromium.org/p/v8/builders/ci/V8%20Win64%20ASAN/8653

Original change's description:
> [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/+/1625991
> Reviewed-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}

TBR=sigurds@chromium.org,tebbi@chromium.org,szuend@chromium.org

Change-Id: I762f29a0d3212d2eabfafa48c0e46940d0e6f835
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: v8:7793
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1625863Reviewed-by: Francis McCabe <fgm@chromium.org>
Commit-Queue: Francis McCabe <fgm@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61805}

src/torque/implementation-visitor.cc

@@ -155,19 +155,40 @@ void ImplementationVisitor::Visit(NamespaceConstant* decl) {
 
 void ImplementationVisitor::Visit(TypeAlias* alias) {
   if (alias->IsRedeclaration()) 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 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;
   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<";
@@ -196,7 +217,6 @@ void ImplementationVisitor::Visit(TypeAlias* alias) {
   header_out() << ");\n";
   header_out() << "    }\n";
   header_out() << "  };\n";
-  }
 }
 
 VisitResult ImplementationVisitor::InlineMacro(

test/torque/test-torque.tq

@@ -823,6 +823,59 @@ 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;
@@ -903,6 +956,24 @@ 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,83 +13,17 @@ namespace torque {
 
 namespace {
 
-// 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) {
+TorqueCompilerResult TestCompileTorque(const 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}});
@@ -99,112 +33,31 @@ TEST(Torque, StackDeleteRange) {
 
 using ::testing::HasSubstr;
 TEST(Torque, TypeNamingConventionLintError) {
-  ExpectFailingCompilation(R"(
+  std::string source = R"(
+    type void;
+    type never;
+
     type foo generates 'TNode<Foo>';
-  )",
-                           HasSubstr("\"foo\""));
-}
+  )";
 
-TEST(Torque, StructNamingConventionLintError) {
-  ExpectFailingCompilation(R"(
-    struct foo {}
-  )",
-                           HasSubstr("\"foo\""));
-}
+  const TorqueCompilerResult result = TestCompileTorque(source);
 
-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;
-    }
-  )");
+  ASSERT_EQ(result.messages.size(), static_cast<size_t>(1));
+  EXPECT_THAT(result.messages[0].message, HasSubstr("\"foo\""));
 }
 
-TEST(Torque, TypeDeclarationOrder) {
-  ExpectSuccessfulCompilation(R"(
-    type Baztype = Foo | FooType;
-
-    @abstract
-    @noVerifier
-    extern class Foo extends HeapObject {
-      fooField: FooType;
-    }
-
-    @noVerifier
-    extern class Bar extends Foo {
-      barField: Bartype;
-      bazfield: Baztype;
-    }
+TEST(Torque, StructNamingConventionLintError) {
+  const std::string source = R"(
+    type void;
+    type never;
 
-    type Bartype = FooType;
+    struct foo {}
+  )";
 
-    type FooType = Smi | Bar;
-  )");
-}
+  const TorqueCompilerResult result = TestCompileTorque(source);
 
-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"));
+  ASSERT_EQ(result.messages.size(), static_cast<size_t>(1));
+  EXPECT_THAT(result.messages[0].message, HasSubstr("\"foo\""));
 }
 
 }  // namespace torque