module js

import v.ast
import arrays

struct Type {
    // typ is the original type
    typ ast.Type        @[required]
    sym &ast.TypeSymbol = unsafe { nil } @[required]
    // unaliased is `typ` once aliased have been resolved
    // it may not contain information such as flags and nr_muls
    unaliased     ast.Type        @[required]
    unaliased_sym &ast.TypeSymbol = unsafe { nil } @[required]
}

fn (a Type) == (b Type) bool {
    return a.unaliased == b.unaliased
}

fn (a Type) < (b Type) bool {
    return a.unaliased_sym.name < b.unaliased_sym.name
}

// unwrap returns the following variants of a type:
// * generics unwrapped
// * alias unwrapped
fn (mut g JsGen) unwrap(typ ast.Type) Type {
    no_generic := g.unwrap_generic(typ)
    no_generic_sym := g.table.sym(no_generic)
    if no_generic_sym.kind != .alias {
        return Type{
            typ:           no_generic
            sym:           no_generic_sym
            unaliased:     no_generic
            unaliased_sym: no_generic_sym
        }
    }
    no_generic_unaliased := g.table.unaliased_type(no_generic)
    return Type{
        typ:           no_generic
        sym:           no_generic_sym
        unaliased:     no_generic_unaliased
        unaliased_sym: g.table.sym(no_generic_unaliased)
    }
}

fn (mut g JsGen) unwrap_sum_type(typ ast.Type) []Type {
    mut types := []Type{}
    sym := g.table.sym(typ)
    if sym.info is ast.SumType {
        for v in sym.info.variants {
            types << g.unwrap_sum_type(v)
        }
    } else {
        types << g.unwrap(typ)
    }
    return arrays.distinct(types)
}