Adding class hierarchy to typechecker in c++

[bkerec]

I would like to imitate the class hierarchy in lua so I started experimenting on how to do that with metatables. I saw that Luau have a ClassType, but that's not gonna work in my case since properties can also be added to class instance in script. To demonstrate my issues and questions I have the following test code:

std::map<Name, Property> superClassProps;
superClassProps["Member1"] = makeProperty(globals.builtinTypes->anyType, "@luau/globals/TestSuperClass.Member1"); 
TableType superClassTable(superClassProps, std::nullopt, TypeLevel{}, TableState::Sealed);
superClassTable.name = "TestSuperClass";
superClassTable.syntheticName = "TestSuperClass";
TypeId superClassTableType = arena.addType(std::move(superClassTable));
addGlobalBinding(globals, "TestSuperClass", superClassTableType, "@luau");

std::map<Name, Property> classProps;
classProps["Member2"] = makeProperty(globals.builtinTypes->anyType, "@luau/globals/TestClass.Member2");
TableType classTable(classProps, std::nullopt, TypeLevel{}, TableState::Sealed);
classTable.name = "TestClass";
classTable.syntheticName = "TestClass";
TypeId classTableType = arena.addType(std::move(classTable));

TypeId metaTableType = arena.addType(MetatableType{classTableType, superClassTableType, "TestClass"});
addGlobalBinding(globals, "TestClass", metaTableType, "@luau");

TableType* classType = getMutable<TableType>(classTableType);
classType->props["new"] = makeProperty(makeFunction(arena, std::nullopt, {}, {metaTableType}), "@luau/globals/TestClass.new");

First issue is that superclass members are not recognized: TestClass.Member1. Second issue is that creating an instance of a class by calling local instance = TestClass.new() returns any type. I am not sure what I'm doing wrong. Can you please pinpoint the mistakes I made?

[AmaranthineCodices]

You're not going to be able to mimic a traditional class hierarchy in Luau without using ClassType. Table types in Luau are structural, meaning any class you build with them can be replaced with a table type that has the same shape, but potentially very different behavior. ClassType, on the other hand, implements nominal subtyping.

In the code above, you're not using the metatable correctly; you need to specify an __index metamethod like you would in Luau code. I'd suggest reading up on how metatables function. As for the constructor returning any: you may want to check if you're using strict mode. In non-strict mode, most local variables are typed as any regardless of what they're assigned to at the moment.

[bkerec]

Thanks for the tip, it helped a lot. I have one more question. This is my new test code now:

TableType superClassTable({}, std::nullopt, TypeLevel{}, TableState::Sealed);
superClassTable.name = "SuperClass";
superClassTable.syntheticName = "SuperClass";
TypeId superClassTableType = arena.addType(std::move(superClassTable));

TableType testClassTable({}, std::nullopt, TypeLevel{}, TableState::Sealed);
testClassTable.name = "TestClass";
testClassTable.syntheticName = "TestClass";
TypeId testClassTableType = arena.addType(std::move(testClassTable));

TypeId indexTable = arena.addType(TableType{{{{"__index", superClassTableType}}}, std::nullopt, TypeLevel{}, TableState::Sealed});
TypeId testClassMetaTableType = arena.addType(MetatableType{testClassTableType, indexTable, "TestClass"});

getMutable<TableType>(superClassTableType)->props["func1"] = makeFunction(arena, superClassTableType, {}, {});
getMutable<TableType>(testClassTableType)->props["func2"] = makeFunction(arena, testClassMetaTableType, {}, {});

addGlobalBinding(globals, "SuperClass", superClassTableType, "@luau");
addGlobalBinding(globals, "TestClass", testClassMetaTableType, "@luau");

I have an issue that TestClass:func1() produce this error: "Type 'TestClass' could not be converted into 'SuperClass'". What is the best way to solve this? I can replace
getMutable<TableType>(superClassTableType)->props["func1"] = makeFunction(arena, superClassTableType, {}, {});
with
getMutable<TableType>(superClassTableType)->props["func1"] = makeFunction(arena, arena.addType(UnionType{{superClassTableType, testClassMetaTableType}}), {}, {});
but that's just a hack in my opinion.