From 5b8dd6468037069b00cb93b3c1e7e3eb9f358161 Mon Sep 17 00:00:00 2001 From: fubark Date: Mon, 2 Sep 2024 11:23:24 -0400 Subject: [PATCH] Add `typeInfo`, and `allTypes`. --- src/builtins/builtins.zig | 256 ++++++++++++++++++++++++++++++++++++ src/builtins/builtins_vm.cy | 99 ++++++++++++++ src/capi.zig | 8 ++ src/lib.zig | 8 ++ src/sema.zig | 15 +-- src/std/test.zig | 2 +- src/sym.zig | 22 ++-- test/meta/type.cy | 88 +++++++++++++ test/modules/core.cy | 2 + 9 files changed, 481 insertions(+), 19 deletions(-) diff --git a/src/builtins/builtins.zig b/src/builtins/builtins.zig index 8ca941c27..91a5abf01 100644 --- a/src/builtins/builtins.zig +++ b/src/builtins/builtins.zig @@ -30,6 +30,7 @@ pub const CoreData = struct { const func = cy.hostFuncEntry; const funcs = [_]C.HostFuncEntry{ // Utils. + func("allTypes", zErrFunc(allTypes)), func("bitcast_", zErrFunc(bitcast)), func("copy_", zErrFunc(copy)), func("choicetag_", zErrFunc(choicetag)), @@ -50,6 +51,7 @@ const funcs = [_]C.HostFuncEntry{ func("queueTask", zErrFunc(queueTask)), func("runestr", zErrFunc(runestr)), func("sizeof_", sizeof), + func("typeInfo", zErrFunc(typeInfo)), // Compile-time funcs. @@ -796,6 +798,260 @@ pub fn sizeof(vm: *cy.VM) Value { } } +pub fn allTypes(ivm: *cy.VM) !Value { + const vm: *C.ZVM = @ptrCast(ivm); + + const list_tmpl = ivm.sema.list_tmpl.head.toC(); + const type_v = vm.newType(bt.Type); + defer vm.release(type_v); + var list_t: cy.TypeId = undefined; + _ = vm.expandTemplateType(list_tmpl, &.{type_v}, &list_t); + + const list_v = vm.newList(list_t, &.{}); + for (1..ivm.sema.types.items.len) |id| { + const type_e = ivm.sema.types.items[id]; + if (type_e.kind == .bare or type_e.kind == .ct_ref) { + continue; + } + const elem = vm.newType(@intCast(id)); + vm.listAppend(list_v, elem); + vm.release(elem); + } + return @bitCast(list_v); +} + +pub fn typeInfo(ivm: *cy.VM) !Value { + const type_id = ivm.getObject(*cy.heap.Type, 0).type; + + const vm: *C.ZVM = @ptrCast(ivm); + const info_t = vm.findType("TypeInfo"); + switch (type_id) { + bt.Void => { + return @bitCast(vm.newChoice(info_t, "void_t", C.Void)); + }, + bt.Type => { + return @bitCast(vm.newChoice(info_t, "type_t", C.Void)); + }, + bt.Error => { + return @bitCast(vm.newChoice(info_t, "error_t", C.Void)); + }, + else => { + const type_e = ivm.sema.getType(type_id); + switch (type_e.kind) { + .float => { + const bits = type_e.data.float.bits; + const float_info_t = vm.findType("FloatInfo"); + const float_info = vm.newInstance(float_info_t, &.{ + C.toFieldInit("bits", bits), + }); + return @bitCast(vm.newChoice(info_t, "float_t", float_info)); + }, + .int => { + if (type_e.sym.getVariant()) |variant| { + if (variant.data.sym.template == ivm.sema.pointer_tmpl) { + const ptr_info_t = vm.findType("PointerInfo"); + const elem_t = type_e.sym.getVariant().?.args[0]; + vm.retain(@bitCast(elem_t)); + const ptr_info = vm.newInstance(ptr_info_t, &.{ + C.toFieldInit("elem", @bitCast(elem_t)), + }); + return @bitCast(vm.newChoice(info_t, "ptr_t", ptr_info)); + } + } + const bits = type_e.data.int.bits; + const int_info_t = vm.findType("IntInfo"); + const int_info = vm.newInstance(int_info_t, &.{ + C.toFieldInit("sign", C.bool_(type_id != bt.Byte)), + C.toFieldInit("bits", bits), + }); + return @bitCast(vm.newChoice(info_t, "int_t", int_info)); + }, + .bool => { + return @bitCast(vm.newChoice(info_t, "bool_t", C.Void)); + }, + .trait => { + const name = type_e.sym.name(); + const trait_info_t = vm.findType("TraitInfo"); + const trait_info = vm.newInstance(trait_info_t, &.{ + C.toFieldInit("name", vm.newString(name)), + }); + return @bitCast(vm.newChoice(info_t, "trait_t", trait_info)); + }, + .array => { + const n = type_e.data.array.n; + const elem_t = type_e.data.array.elem_t; + const array_info_t = vm.findType("ArrayInfo"); + const array_info = vm.newInstance(array_info_t, &.{ + C.toFieldInit("len", C.int(@intCast(n))), + C.toFieldInit("elem", vm.newType(elem_t)), + }); + return @bitCast(vm.newChoice(info_t, "array_t", array_info)); + }, + .option => { + const opt_info_t = vm.findType("OptionInfo"); + const elem_t = type_e.sym.getVariant().?.args[0]; + vm.retain(@bitCast(elem_t)); + const opt_info = vm.newInstance(opt_info_t, &.{ + C.toFieldInit("elem", @bitCast(elem_t)), + }); + return @bitCast(vm.newChoice(info_t, "opt_t", opt_info)); + }, + .choice => { + const choice_info_t = vm.findType("ChoiceInfo"); + const list_tmpl = ivm.sema.list_tmpl.head.toC(); + const choice_case_t = vm.findType("ChoiceCase"); + const choice_case_tv = vm.newType(choice_case_t); + defer vm.release(choice_case_tv); + var list_t: cy.TypeId = undefined; + _ = vm.expandTemplateType(list_tmpl, &.{choice_case_tv}, &list_t); + const list_v = vm.newList(list_t, &.{}); + for (type_e.sym.cast(.enum_t).members()) |member| { + const case = vm.newInstance(choice_case_t, &.{ + C.toFieldInit("name", vm.newString(member.head.name())), + C.toFieldInit("type", vm.newType(member.payloadType)), + }); + vm.listAppend(list_v, case); + vm.release(case); + } + const name = type_e.sym.name(); + const namev = try StringSome(ivm, @bitCast(vm.newString(name))); + const choice_info = vm.newInstance(choice_info_t, &.{ + C.toFieldInit("name", @bitCast(namev)), + C.toFieldInit("cases", list_v), + }); + return @bitCast(vm.newChoice(info_t, "choice_t", choice_info)); + }, + .enum_t => { + const enum_info_t = vm.findType("EnumInfo"); + const list_tmpl = ivm.sema.list_tmpl.head.toC(); + const enum_case_t = vm.findType("EnumCase"); + const enum_case_tv = vm.newType(enum_case_t); + defer vm.release(enum_case_tv); + var list_t: cy.TypeId = undefined; + _ = vm.expandTemplateType(list_tmpl, &.{enum_case_tv}, &list_t); + const list_v = vm.newList(list_t, &.{}); + for (type_e.sym.cast(.enum_t).members()) |member| { + const case = vm.newInstance(enum_case_t, &.{ + C.toFieldInit("name", vm.newString(member.head.name())), + }); + vm.listAppend(list_v, case); + vm.release(case); + } + const name = type_e.sym.name(); + const namev = try StringSome(ivm, @bitCast(vm.newString(name))); + const enum_info = vm.newInstance(enum_info_t, &.{ + C.toFieldInit("name", @bitCast(namev)), + C.toFieldInit("cases", list_v), + }); + return @bitCast(vm.newChoice(info_t, "enum_t", enum_info)); + }, + .host_object => { + const hostobj_info_t = vm.findType("HostObjectInfo"); + const name = type_e.sym.name(); + const hostobj_info = vm.newInstance(hostobj_info_t, &.{ + C.toFieldInit("name", vm.newString(name)), + }); + return @bitCast(vm.newChoice(info_t, "hostobj_t", hostobj_info)); + }, + .object => { + const object_info_t = vm.findType("ObjectInfo"); + const list_tmpl = ivm.sema.list_tmpl.head.toC(); + const field_t = vm.findType("ObjectField"); + const field_tv = vm.newType(field_t); + defer vm.release(field_tv); + var list_t: cy.TypeId = undefined; + _ = vm.expandTemplateType(list_tmpl, &.{field_tv}, &list_t); + const list_v = vm.newList(list_t, &.{}); + for (type_e.sym.cast(.object_t).getFields()) |field| { + const f = vm.newInstance(field_t, &.{ + C.toFieldInit("name", vm.newString(field.sym.head.name())), + C.toFieldInit("type", vm.newType(field.type)), + }); + vm.listAppend(list_v, f); + vm.release(f); + } + const name = type_e.sym.name(); + const namev = try StringSome(ivm, @bitCast(vm.newString(name))); + const object_info = vm.newInstance(object_info_t, &.{ + C.toFieldInit("name", @bitCast(namev)), + C.toFieldInit("fields", list_v), + }); + return @bitCast(vm.newChoice(info_t, "object_t", object_info)); + }, + .struct_t => { + const struct_info_t = vm.findType("StructInfo"); + const list_tmpl = ivm.sema.list_tmpl.head.toC(); + const field_t = vm.findType("StructField"); + const field_tv = vm.newType(field_t); + defer vm.release(field_tv); + var list_t: cy.TypeId = undefined; + _ = vm.expandTemplateType(list_tmpl, &.{field_tv}, &list_t); + const list_v = vm.newList(list_t, &.{}); + for (type_e.sym.cast(.struct_t).getFields()) |field| { + const f = vm.newInstance(field_t, &.{ + C.toFieldInit("name", vm.newString(field.sym.head.name())), + C.toFieldInit("type", vm.newType(field.type)), + C.toFieldInit("offset", C.int(@intCast(field.offset))), + }); + vm.listAppend(list_v, f); + vm.release(f); + } + const name = type_e.sym.name(); + const namev = try StringSome(ivm, @bitCast(vm.newString(name))); + const struct_info = vm.newInstance(struct_info_t, &.{ + C.toFieldInit("name", @bitCast(namev)), + C.toFieldInit("fields", list_v), + }); + return @bitCast(vm.newChoice(info_t, "struct_t", struct_info)); + }, + .func_ptr => { + const func_info = newFuncInfo(ivm, 0, type_e); + return @bitCast(vm.newChoice(info_t, "func_t", func_info)); + }, + .func_union => { + const func_info = newFuncInfo(ivm, 1, type_e); + return @bitCast(vm.newChoice(info_t, "func_t", func_info)); + }, + .func_sym => { + const func_info = newFuncInfo(ivm, 2, type_e); + return @bitCast(vm.newChoice(info_t, "func_t", func_info)); + }, + else => { + std.debug.panic("Unsupported: {}", .{type_e.kind}); + } + } + }, + } +} + +fn newFuncInfo(ivm: *cy.VM, kind: u8, type_e: cy.types.Type) C.Value { + const vm: *C.ZVM = @ptrCast(ivm); + const func_info_t = vm.findType("FuncInfo"); + const list_tmpl = ivm.sema.list_tmpl.head.toC(); + const param_t = vm.findType("FuncParam"); + const param_tv = vm.newType(param_t); + defer vm.release(param_tv); + var list_t: cy.TypeId = undefined; + _ = vm.expandTemplateType(list_tmpl, &.{param_tv}, &list_t); + const list_v = vm.newList(list_t, &.{}); + const sig = ivm.sema.getFuncSig(type_e.data.func_ptr.sig); + for (sig.params()) |param| { + const p = vm.newInstance(param_t, &.{ + C.toFieldInit("type", vm.newType(param.type)), + }); + vm.listAppend(list_v, p); + vm.release(p); + } + + const func_kind_t = vm.findType("FuncKind"); + const kind_v = cy.Value.initEnum(@intCast(func_kind_t), kind); + return vm.newInstance(func_info_t, &.{ + C.toFieldInit("kind", @bitCast(kind_v)), + C.toFieldInit("ret", vm.newType(sig.ret)), + C.toFieldInit("params", list_v), + }); +} + pub fn type_call(vm: *cy.VM) !Value { const val = vm.getValue(0); const typeId = val.getTypeId(); diff --git a/src/builtins/builtins_vm.cy b/src/builtins/builtins_vm.cy index 6d01e6012..a23680466 100644 --- a/src/builtins/builtins_vm.cy +++ b/src/builtins/builtins_vm.cy @@ -2,6 +2,9 @@ --| Functions. --| +--| Returns all the current registered types when this function is invoked. +@host func allTypes() List[type] + func bitcast[D, S](D type, val S) D: return bitcast_(D, typeid[D], val, typeid[S]) @@ -79,6 +82,9 @@ func sizeof[T](T type) int: func typeOf(t ExprType) type: return t.getType() +--| Returns info about a type. +@host func typeInfo(T type) TypeInfo + --| --| Value templates. --| @@ -207,8 +213,100 @@ type float #float64_t: @host type any _ @host type type _: + --| Returns a unique ID for this type. @host func id(self) int +type TypeInfo enum: + case int_t IntInfo + case array_t ArrayInfo + case bool_t void + case choice_t ChoiceInfo + case enum_t EnumInfo + case error_t void + case float_t FloatInfo + case func_t FuncInfo + case object_t ObjectInfo + case hostobj_t HostObjectInfo + case opt_t OptionInfo + case ptr_t PointerInfo + case struct_t StructInfo + case trait_t TraitInfo + case type_t void + case void_t void + +type IntInfo struct: + sign bool + bits int + +type FloatInfo struct: + bits int + +type HostObjectInfo struct: + name String + -- getchildren + -- finalizer + +type ObjectInfo struct: + name ?String + fields List[ObjectField] + -- funcs List[funcsym_t] + +type ObjectField struct: + name String + type type + +type EnumInfo struct: + name ?String + cases List[EnumCase] + +type EnumCase struct: + name String + +type ChoiceInfo struct: + name ?String + cases List[ChoiceCase] + +type ChoiceCase struct: + name String + type type + +type FuncKind enum: + case ptr + case union + case sym + +type FuncInfo struct: + kind FuncKind + params List[FuncParam] + ret type + +type FuncParam struct: + type type + +type ArrayInfo struct: + len int + elem type + +type StructInfo struct: + name ?String + fields List[StructField] + -- funcs List[funcsym_t] + +type StructField struct: + name String + type type + offset int + +type TraitInfo struct: + name String + -- funcs List[funcsym_t] + +type PointerInfo struct: + elem type + +type OptionInfo struct: + elem type + --| Return the type of a value. --| See `typeof` to obtain the type of an expression at compile-time. @host func type.$call(val any) type @@ -730,6 +828,7 @@ func Memory.alloc[T](self, T type, n int) [*]T: func Memory.free[T](self, ptr *T): self.iface.free(ptrcast(byte, ptr)[0..sizeof(T)]) +-- TODO: Should be merged with Memory.free. func Memory.free_[T](self, slice [*]T): var bytes = ptrcast(byte, slice.ptr)[0..sizeof(T)*slice.len()] self.iface.free(bytes) diff --git a/src/capi.zig b/src/capi.zig index a463c0243..b1b26c4d8 100644 --- a/src/capi.zig +++ b/src/capi.zig @@ -366,6 +366,14 @@ pub const ZVM = struct { return c.clNewChoice(@ptrCast(self), choice_t, toStr(name), val); } + pub fn newList(self: *ZVM, list_t: Type, vals: []const Value) Value { + return c.clNewList(@ptrCast(self), list_t, vals.ptr, vals.len); + } + + pub fn listAppend(self: *ZVM, list: Value, val: Value) void { + c.clListAppend(@ptrCast(self), list, val); + } + pub fn findType(self: *ZVM, path: []const u8) Type { return c.clFindType(@ptrCast(self), toStr(path)); } diff --git a/src/lib.zig b/src/lib.zig index 4be0a1014..bcfe0d478 100644 --- a/src/lib.zig +++ b/src/lib.zig @@ -620,6 +620,14 @@ export fn clNewListDyn(vm: *cy.VM, ptr: [*]const Value, len: usize) Value { return cy.heap.allocListDyn(vm, elems) catch fatal(); } +export fn clNewList(vm: *cy.VM, list_t: cy.TypeId, ptr: [*]const Value, len: usize) Value { + const elems = ptr[0..len]; + for (elems) |elem| { + cy.arc.retain(vm, elem); + } + return cy.heap.allocList(vm, list_t, elems) catch fatal(); +} + export fn clNewEmptyMap(vm: *cy.VM) Value { return cy.heap.allocEmptyMap(vm) catch fatal(); } diff --git a/src/sema.zig b/src/sema.zig index 62ad179a3..7d6b62188 100644 --- a/src/sema.zig +++ b/src/sema.zig @@ -1685,15 +1685,15 @@ pub fn declareEnumMembers(c: *cy.Chunk, sym: *cy.sym.EnumType, decl: *ast.EnumDe const members = try c.alloc.alloc(*cy.sym.EnumMember, decl.members.len); for (decl.members, 0..) |member, i| { const mName = c.ast.nodeString(member.name); - var payloadType: cy.TypeId = cy.NullId; + var payloadType: cy.TypeId = bt.Void; if (sym.isChoiceType and member.typeSpec != null) { payloadType = try resolveTypeSpecNode(c, member.typeSpec); } const modSymId = try c.declareEnumMember(@ptrCast(sym), mName, sym.type, sym.isChoiceType, @intCast(i), payloadType, member); members[i] = modSymId; } - sym.members = members.ptr; - sym.numMembers = @intCast(members.len); + sym.member_ptr = members.ptr; + sym.member_len = @intCast(members.len); } /// Only allows binding a predefined host type id (BIND_TYPE_DECL). @@ -3286,6 +3286,7 @@ pub fn symbol(c: *cy.Chunk, sym: *Sym, expr: Expr, prefer_ct_sym: bool) !ExprRes }, .type, .enum_t, + .trait_t, .hostobj_t, .object_t, .struct_t => { @@ -3302,12 +3303,8 @@ pub fn symbol(c: *cy.Chunk, sym: *Sym, expr: Expr, prefer_ct_sym: bool) !ExprRes if (member.is_choice_type) { return semaInitChoiceNoPayload(c, member, node); } else { - var typeId = member.payloadType; - if (typeId == cy.NullId) { - typeId = member.type; - } - const ctype = CompactType.init(typeId); - const irIdx = try c.ir.pushExpr(.enumMemberSym, c.alloc, typeId, node, .{ + const ctype = CompactType.init(member.type); + const irIdx = try c.ir.pushExpr(.enumMemberSym, c.alloc, member.type, node, .{ .type = member.type, .val = @as(u8, @intCast(member.val)), }); diff --git a/src/std/test.zig b/src/std/test.zig index 70d9042f4..04a39cd19 100644 --- a/src/std/test.zig +++ b/src/std/test.zig @@ -198,7 +198,7 @@ fn eq2(c: cy.Context, type_id: cy.TypeId, act: rt.Any, exp: rt.Any) bool { bt.Type => { const actv = act.asHeapObject().type; const expv = exp.asHeapObject().type; - if (std.meta.eql(actv, expv)) { + if (actv.type == expv.type) { return true; } else { const act_name = c.sema.allocTypeName(actv.type) catch @panic(""); diff --git a/src/sym.zig b/src/sym.zig index 918261923..58fb2be66 100644 --- a/src/sym.zig +++ b/src/sym.zig @@ -144,7 +144,7 @@ pub const Sym = extern struct { .enum_t => { const enumType = self.cast(.enum_t); enumType.deinit(alloc); - alloc.free(enumType.members[0..enumType.numMembers]); + alloc.free(enumType.members()); alloc.destroy(enumType); }, .func_template => { @@ -1019,8 +1019,8 @@ pub const EnumType = extern struct { head: Sym, decl: *ast.EnumDecl, type: cy.TypeId, - members: [*]*EnumMember, - numMembers: u32, + member_ptr: [*]*EnumMember, + member_len: u32, mod: vmc.Module, variant: ?*Variant, @@ -1029,17 +1029,17 @@ pub const EnumType = extern struct { pub fn deinit(self: *EnumType, alloc: std.mem.Allocator) void { self.getMod().deinit(alloc); - for (self.members[0..self.numMembers]) |m| { + for (self.members()) |m| { alloc.destroy(m); } } pub fn isResolved(self: *EnumType) bool { - return self.numMembers != 0; + return self.member_len != 0; } pub fn getValueSym(self: *EnumType, val: u16) *EnumMember { - return self.members[val]; + return self.member_ptr[val]; } pub fn getMod(self: *EnumType) *cy.Module { @@ -1047,7 +1047,11 @@ pub const EnumType = extern struct { } pub fn getMemberByIdx(self: *EnumType, idx: u32) *EnumMember { - return self.members[idx]; + return self.member_ptr[idx]; + } + + pub fn members(self: *EnumType) []*EnumMember { + return self.member_ptr[0..self.member_len]; } pub fn getMember(self: *EnumType, name: []const u8) ?*EnumMember { @@ -1718,8 +1722,8 @@ pub const ChunkExt = struct { .head = Sym.init(.enum_t, parent, name), .type = typeId, .decl = decl, - .members = undefined, - .numMembers = 0, + .member_ptr = undefined, + .member_len = 0, .isChoiceType = isChoiceType, .variant = null, .mod = undefined, diff --git a/test/meta/type.cy b/test/meta/type.cy index 3c43b0573..fdc2629ca 100644 --- a/test/meta/type.cy +++ b/test/meta/type.cy @@ -18,6 +18,94 @@ t.eq((error).id(), 3) t.eq((Fiber).id(), 23) t.eq((type).id(), 11) +-- typeInfo() +t.assert(typeInfo(int).!int_t == IntInfo{ + sign = true, + bits = 64, +}) +t.assert(typeInfo(byte).!int_t == IntInfo{ + sign = false, + bits = 8, +}) +t.assert(typeInfo(float).!float_t == FloatInfo{ + bits = 64, +}) +t.eq(typeInfo(bool).!bool_t, _) +t.eq(typeInfo(void).!void_t, _) +t.eq(typeInfo(type).!type_t, _) +t.eq(typeInfo(error).!error_t, _) +type Area trait: + func area(self) float +t.assert(typeInfo(Area).!trait_t == TraitInfo{ + name = 'Area', +}) +t.assert(typeInfo([10]int).!array_t == ArrayInfo{ + len = 10, + elem = int, +}) +t.assert(typeInfo(?int).!opt_t == OptionInfo{ + elem = int +}) +t.assert(typeInfo(*int).!ptr_t == PointerInfo{ + elem = int +}) +type Shape enum: + case rectangle Rectangle + case line float + case point +type Rectangle: + width float + height float +var choice_t = typeInfo(Shape).!choice_t +t.eq(choice_t.name.?, 'Shape') +t.eq(choice_t.cases.len(), 3) +t.eq(choice_t.cases[0].name, 'rectangle') +t.eq(choice_t.cases[0].type, Rectangle) +t.eq(choice_t.cases[1].name, 'line') +t.eq(choice_t.cases[1].type, float) +t.eq(choice_t.cases[2].name, 'point') +t.eq(choice_t.cases[2].type, void) +var enum_t = typeInfo(Shape.Tag).!enum_t +t.eq(enum_t.name.?, 'Tag') +t.eq(enum_t.cases.len(), 3) +t.eq(enum_t.cases[0].name, 'rectangle') +t.eq(enum_t.cases[1].name, 'line') +t.eq(enum_t.cases[2].name, 'point') +type O: + a int + b float +var object_t = typeInfo(O).!object_t +t.eq(object_t.name.?, 'O') +t.eq(object_t.fields.len(), 2) +t.eq(object_t.fields[0].name, 'a') +t.eq(object_t.fields[0].type, int) +t.eq(object_t.fields[1].name, 'b') +t.eq(object_t.fields[1].type, float) +type S struct: + a int + b float +var struct_t = typeInfo(S).!struct_t +t.eq(struct_t.name.?, 'S') +t.eq(struct_t.fields.len(), 2) +t.eq(struct_t.fields[0].name, 'a') +t.eq(struct_t.fields[0].type, int) +t.eq(struct_t.fields[1].name, 'b') +t.eq(struct_t.fields[1].type, float) +type FnPtr -> func(int, float) String +var func_t = typeInfo(FnPtr).!func_t +t.eq(func_t.kind, .ptr) +t.eq(func_t.ret, String) +t.eq(func_t.params.len(), 2) +t.eq(func_t.params[0].type, int) +t.eq(func_t.params[1].type, float) +type FnUnion -> Func(int, float) String +func_t = typeInfo(FnUnion).!func_t +t.eq(func_t.kind, .union) +t.eq(func_t.ret, String) +t.eq(func_t.params.len(), 2) +t.eq(func_t.params[0].type, int) +t.eq(func_t.params[1].type, float) + -- Referencing type name path. use os t.eq(type(os.CArray), type) diff --git a/test/modules/core.cy b/test/modules/core.cy index fc5cb7321..4a439875e 100644 --- a/test/modules/core.cy +++ b/test/modules/core.cy @@ -138,4 +138,6 @@ type Foo: var foo = Foo{a=123} t.eq(typeOf(foo), Foo) +-- typeInfo(), see type.cy + --cytest: pass \ No newline at end of file