std/src/reflect_test.nv - main - nv-lang/nova

std/src/reflect_test.nv
106 строк4 KB
Evgeniy Golovin
registry(#592): array-ext static own-generic blanket methods mono per element
11 авг 2026, 21:06
11 авг 2026, 21:06909e352
// std/reflect_test.nv — Plan 222.8 Ф.1 (D438) peer-tests: blanket
// `Reflect`-реализации на примитивах/контейнерах + ручная (не компиляторная)
// реализация протокола, возвращающая `Opaque` (owner-decided addition —
// компилятор `Opaque` НИКОГДА сам не синтезирует, только hand-written impl).
module std.reflect_test
import std.reflect.{TypeShape, SumRepr, Reflect}

test "int.reflect() -> Int" {
    match int.reflect() { Int => assert(true), _ => assert(false) }
}

test "i8/i16/i32/i64/uint/u8/u16/u32/u64.reflect() -> Int (uniform, no wire-width split)" {
    match i8.reflect()   { Int => assert(true), _ => assert(false) }
    match i16.reflect()  { Int => assert(true), _ => assert(false) }
    match i32.reflect()  { Int => assert(true), _ => assert(false) }
    match i64.reflect()  { Int => assert(true), _ => assert(false) }
    match uint.reflect() { Int => assert(true), _ => assert(false) }
    match u8.reflect()   { Int => assert(true), _ => assert(false) }
    match u16.reflect()  { Int => assert(true), _ => assert(false) }
    match u32.reflect()  { Int => assert(true), _ => assert(false) }
    match u64.reflect()  { Int => assert(true), _ => assert(false) }
}

test "f32/f64.reflect() -> Float" {
    match f32.reflect() { Float => assert(true), _ => assert(false) }
    match f64.reflect() { Float => assert(true), _ => assert(false) }
}

test "bool.reflect() -> Bool" {
    match bool.reflect() { Bool => assert(true), _ => assert(false) }
}

test "str.reflect() -> Str" {
    match str.reflect() { Str => assert(true), _ => assert(false) }
}

// Реестр 221.1 №592 (было [M-array-ext-static-erased-body-no-generic-
// dispatch]): a STATIC array-ext own-generic blanket (`fn[T] []T.reflect()`)
// used to be emitted ONCE, erased, under a name that happened to look like
// `[]int` (the C-ident catch-all defaults an unbound `T` to `nova_int`) but
// served every element — `[]int.reflect()` "passed" by coincidence,
// `[]str.reflect()` read back `int`'s answer. Three element kinds below
// (primitive int, primitive str, record) each get their OWN monomorphized
// body now — a single shared int-shaped body can no longer hide behind any
// of them.
test "[]int.reflect() -> Arr(Int)" {
    match []int.reflect() {
        Arr(items) => match items { Int => assert(true), _ => assert(false) }
        _ => assert(false)
    }
}

test "[]str.reflect() -> Arr(Str)" {
    match []str.reflect() {
        Arr(items) => match items { Str => assert(true), _ => assert(false) }
        _ => assert(false)
    }
}

#impl(Reflect)
type ReflPoint { x int, y int }

test "[]<record>.reflect() -> Arr(Record(...))" {
    match []ReflPoint.reflect() {
        Arr(items) => match items {
            Record(name, fields) => {
                assert(name == "ReflPoint")
                assert(fields.len() == 2)
            }
            _ => assert(false)
        }
        _ => assert(false)
    }
}

test "Option[int].reflect() -> Opt(Int)" {
    match Option[int].reflect() {
        Opt(inner) => match inner { Int => assert(true), _ => assert(false) }
        _ => assert(false)
    }
}

test "Option[str].reflect() -> Opt(Str)" {
    match Option[str].reflect() {
        Opt(inner) => match inner { Str => assert(true), _ => assert(false) }
        _ => assert(false)
    }
}

// ── Opaque: ТОЛЬКО ручная реализация (owner-decided addition). Компилятор
// сам `Opaque` не синтезирует — здесь ручной `#impl(Reflect)` на локальном
// типе, имитирующем "сырой", не подлежащий схеме тип (напр. ServerRequest
// в бандл-extractor'е 222.8 §1.3, вне Ф.1-объёма).
// `Reflect` — структурный протокол (D42): предоставить `.reflect()` с нужной
// сигнатурой достаточно для соответствия, `#impl(Reflect)` НЕ нужен (это
// атрибут для ЗАПРОСА компиляторного СИНТЕЗА, RawHandle его не просит).
type RawHandle { fd int }

fn RawHandle.reflect() -> TypeShape => Opaque("RawHandle")

test "manual #impl(Reflect) returning Opaque — compiler never synthesizes this itself" {
    match RawHandle.reflect() {
        Opaque(name) => assert(name == "RawHandle")
        _ => assert(false)
    }
}