Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-js

Source of release 0.6.0

0.6.0 / src / engine / module_parse.lucb

#==============================================================================================
#
#   module_parse - The module syntax of the parser, and creating and freeing FunctionDefs
#
#   DESCRIPTION:
#       Port of quickjs.c add_export_entry (lines 29828-29834) and lines 31594-32221: the
#       `with` clause of imports, the `from` clause, export and import declarations,
#       js_parse_source_element, js_new_function_def and js_free_function_def.
#
#==============================================================================================

# mark: Import attributes and the from clause ===================================================

func add_export_entry(s: ParseState*, m: ModuleDef*, local_name: Atom, export_name: Atom,
                      export_type: ExportType) -> ExportEntry*!:
    return try add_export_entry2(s.ctx, s, m, local_name, export_name, export_type)

# Parse `with { key: "value", ... }` into the attributes of `rme`.
func js_parse_with_clause(s: ParseState*, rme: ReqModuleEntry*) -> !:
    let ctx = s.ctx

    try next_token(s)
    try js_parse_expect(s, TokenType.lbrace)
    while s.token.val != TokenType.rbrace:
        let key_token_ptr = s.token.ptr
        var key = no_atom
        if s.token.val == TokenType.string:
            key = try js_value_to_atom(ctx, s.token.u.str_.str)
        else:
            if not token_is_ident(s.token.val):
                try js_parse_error(s, "identifier expected")
            key = js_dup_atom(ctx, s.token.u.ident.atom)
        try next_token(s)
        js_parse_expect(s, TokenType.colon) catch failure:
            js_free_atom(ctx, key)
            error(failure.code, failure.message)
        if s.token.val != TokenType.string:
            try js_parse_error_pos(s, key_token_ptr, "string expected")
        if js_is_undefined(rme.attributes):
            let attributes = js_new_object_proto(ctx, js_null()) catch failure:
                js_free_atom(ctx, key)
                error(failure.code, failure.message)
            rme.attributes = attributes
        let has_key = js_has_property(ctx, rme.attributes, key) catch failure:
            js_free_atom(ctx, key)
            error(failure.code, failure.message)
        if has_key:
            js_free_atom(ctx, key)
            try js_parse_error(s, "duplicate with key")
        let defined = js_define_property_value(ctx, rme.attributes, key,
                                               js_dup_value(ctx, s.token.u.str_.str), prop_c_w_e) catch failure:
            js_free_atom(ctx, key)
            error(failure.code, failure.message)
        _ = defined
        js_free_atom(ctx, key)
        try next_token(s)
        if s.token.val != TokenType.comma:
            break
        try next_token(s)
    if not js_is_undefined(rme.attributes):
        let rt = ctx.rt
        if let check = rt.module_check_attrs:
            try check(ctx, rt.module_loader_opaque, rme.attributes)
    try js_parse_expect(s, TokenType.rbrace)

# return the module index in m.req_module_entries[]
func js_parse_from_clause(s: ParseState*, m: ModuleDef*) -> i32!:
    if not token_is_pseudo_keyword(s, atom_from):
        try js_parse_error(s, "from clause expected")
    try next_token(s)
    if s.token.val != TokenType.string:
        try js_parse_error(s, "string expected")
    let module_name = try js_value_to_atom(s.ctx, s.token.u.str_.str)
    next_token(s) catch failure:
        js_free_atom(s.ctx, module_name)
        error(failure.code, failure.message)

    let idx = add_req_module_entry(s.ctx, m, module_name) catch failure:
        js_free_atom(s.ctx, module_name)
        error(failure.code, failure.message)
    js_free_atom(s.ctx, module_name)
    if s.token.val == TokenType.with_:
        try js_parse_with_clause(s, module_req_entry(m, idx))
    return idx

# mark: Export declarations =====================================================================

# After the local name of `export { local as name }`: the exported name, `local_name`
# itself when there is no `as`.
func js_parse_export_as(s: ParseState*, local_name: Atom) -> Atom!:
    let ctx = s.ctx
    try next_token(s)
    if token_is_pseudo_keyword(s, atom_as):
        try next_token(s)
        var export_name = no_atom
        if s.token.val == TokenType.string:
            if js_string_find_invalid_codepoint(js_value_get_string(s.token.u.str_.str)) >= 0:
                try js_parse_error(s, "contains unpaired surrogate")
            export_name = try js_value_to_atom(s.ctx, s.token.u.str_.str)
        else:
            if not token_is_ident(s.token.val):
                try js_parse_error(s, "identifier expected")
            export_name = js_dup_atom(ctx, s.token.u.ident.atom)
        next_token(s) catch failure:
            js_free_atom(ctx, export_name)
            error(failure.code, failure.message)
        return export_name
    return js_dup_atom(ctx, local_name)

# One `local [as name]` of `export { ... }`.
func js_parse_export_specifier(s: ParseState*, m: ModuleDef*) -> !:
    let ctx = s.ctx
    if not token_is_ident(s.token.val):
        try js_parse_error(s, "identifier expected")
    let local_name = js_dup_atom(ctx, s.token.u.ident.atom)
    defer js_free_atom(ctx, local_name)
    let export_name = try js_parse_export_as(s, local_name)
    defer js_free_atom(ctx, export_name)
    _ = try add_export_entry(s, m, local_name, export_name, ExportType.local_)

# `export * as name from "module"`: the token after `as`.
func js_parse_export_ns_from(s: ParseState*, m: ModuleDef*) -> !:
    let ctx = s.ctx
    if not token_is_ident(s.token.val):
        try js_parse_error(s, "identifier expected")
    let export_name = js_dup_atom(ctx, s.token.u.ident.atom)
    defer js_free_atom(ctx, export_name)
    try next_token(s)
    let idx = try js_parse_from_clause(s, m)
    let me = try add_export_entry(s, m, atom__star_, export_name, ExportType.indirect)
    me.u.req_module_idx = idx

func js_parse_export(s: ParseState*) -> !:
    let ctx = s.ctx
    let m = s.fd().module else trap("js_parse_export: not a module")

    try next_token(s)

    let tok = s.token.val
    if tok == TokenType.class_:
        try js_parse_class(s, false, ParseExportKind.named)
        return
    elif (tok == TokenType.function or (token_is_pseudo_keyword(s, atom_async) and peek_token(s, true) == TokenType.function)):
        try js_parse_function_decl2(s, ParseFunctionKind.statement, js_func_normal, no_atom,
                                    s.token.ptr, ParseExportKind.named, none)
        return

    try next_token(s)

    match tok:
        .lbrace:
            let first_export = m.export_entries_count
            while s.token.val != TokenType.rbrace:
                try js_parse_export_specifier(s, m)
                if s.token.val != TokenType.comma:
                    break
                try next_token(s)
            try js_parse_expect(s, TokenType.rbrace)
            if token_is_pseudo_keyword(s, atom_from):
                let idx = try js_parse_from_clause(s, m)
                for i in first_export..<m.export_entries_count:
                    let me = module_export_entry(m, i)
                    me.export_type = ExportType.indirect
                    me.u.req_module_idx = idx
        .star:
            if token_is_pseudo_keyword(s, atom_as):
                # export ns from
                try next_token(s)
                try js_parse_export_ns_from(s, m)
            else:
                let idx = try js_parse_from_clause(s, m)
                try add_star_export_entry(ctx, m, idx)
        .default:
            if s.token.val == TokenType.class_:
                try js_parse_class(s, false, ParseExportKind.default)
                return
            elif (s.token.val == TokenType.function or (token_is_pseudo_keyword(s, atom_async) and peek_token(s, true) == TokenType.function)):
                try js_parse_function_decl2(s, ParseFunctionKind.statement, js_func_normal, no_atom,
                                            s.token.ptr, ParseExportKind.default, none)
                return
            else:
                try js_parse_assign_expr(s)
            # set the name of anonymous functions
            set_object_name(s, atom_default)

            # store the value in the _default_ global variable and export it
            let local_name = atom__default_
            _ = try define_var(s, s.fd(), local_name, VarDefKind.let_)
            emit_op(s, (u8)TempOp.scope_put_var_init)
            emit_atom(s, local_name)
            emit_u16(s, 0)

            _ = try add_export_entry(s, m, local_name, atom_default, ExportType.local_)
        .var_, .let_, .const_:
            # parse_flags TRUE: PF_IN_ACCEPTED
            try js_parse_var(s, 1, tok, true)
            return
        _:
            try js_parse_error(s, "invalid export syntax")
    try js_parse_expect_semi(s)

# mark: Import declarations =====================================================================

func add_import(s: ParseState*, m: ModuleDef*, local_name: Atom, import_name: Atom, is_star: bool) -> !:
    let ctx = s.ctx
    let fd = s.fd()

    if local_name == atom_arguments or local_name == atom_eval:
        try js_parse_error(s, "invalid import binding")

    if local_name != atom_default:
        for i in 0..<fd.closure_var_count:
            let closure_var = fd.closure_var else trap("add_import: no closure variables")
            if closure_var[(usize)i].var_name == local_name:
                try js_parse_error(s, "duplicate import binding")

    let closure_type = ClosureType.module_decl if is_star else ClosureType.module_import
    let var_idx = try add_closure_var(ctx, fd, closure_type, m.import_entries_count, local_name,
                                      true, true, VarKind.normal)
    try js_resize_array(ctx, (void*?*)&m.import_entries, (i32)memory.size_of(ImportEntry),
                        &m.import_entries_size, m.import_entries_count + 1)
    let mi = module_import_entry(m, m.import_entries_count)
    m.import_entries_count += 1
    mi.import_name = js_dup_atom(ctx, import_name)
    mi.var_idx = var_idx
    mi.is_star = is_star

# The binding after a default or namespace import: add the import of `local_name`, which is
# released.
func js_parse_import_binding(s: ParseState*, m: ModuleDef*, local_name: Atom, import_name: Atom,
                             is_star: bool) -> !:
    defer js_free_atom(s.ctx, local_name)
    try next_token(s)
    try add_import(s, m, local_name, import_name, is_star)

# After the imported name of `import { name as local }`: the local name, `import_name`
# itself when there is no `as`.
func js_parse_import_local_name(s: ParseState*, import_name: Atom, is_string: bool) -> Atom!:
    try next_token(s)
    if token_is_pseudo_keyword(s, atom_as):
        try next_token(s)
        if not token_is_ident(s.token.val):
            try js_parse_error(s, "identifier expected")
        let local_name = js_dup_atom(s.ctx, s.token.u.ident.atom)
        next_token(s) catch failure:
            js_free_atom(s.ctx, local_name)
            error(failure.code, failure.message)
        return local_name
    if is_string:
        try js_parse_error(s, "expecting 'as'")
    return js_dup_atom(s.ctx, import_name)

# One `name [as local]` of `import { ... }`.
func js_parse_import_specifier(s: ParseState*, m: ModuleDef*) -> !:
    let ctx = s.ctx
    var is_string = false
    var import_name = no_atom
    if s.token.val == TokenType.string:
        is_string = true
        if js_string_find_invalid_codepoint(js_value_get_string(s.token.u.str_.str)) >= 0:
            try js_parse_error(s, "contains unpaired surrogate")
        import_name = try js_value_to_atom(s.ctx, s.token.u.str_.str)
    else:
        if not token_is_ident(s.token.val):
            try js_parse_error(s, "identifier expected")
        import_name = js_dup_atom(ctx, s.token.u.ident.atom)
    defer js_free_atom(ctx, import_name)
    let local_name = try js_parse_import_local_name(s, import_name, is_string)
    defer js_free_atom(ctx, local_name)
    try add_import(s, m, local_name, import_name, false)

# The import clause and the from clause of `import ... from "module"`; answers the module
# index.
func js_parse_import_clause(s: ParseState*, m: ModuleDef*) -> i32!:
    let ctx = s.ctx
    var end_import_clause = false
    if s.token.val == TokenType.ident:
        if s.token.u.ident.is_reserved:
            try js_parse_error_reserved_identifier(s)
        # "default" import
        let local_name = js_dup_atom(ctx, s.token.u.ident.atom)
        try js_parse_import_binding(s, m, local_name, atom_default, false)

        if s.token.val != TokenType.comma:
            end_import_clause = true
        else:
            try next_token(s)

    if not end_import_clause:
        if s.token.val == TokenType.star:
            # name space import
            try next_token(s)
            if not token_is_pseudo_keyword(s, atom_as):
                try js_parse_error(s, "expecting 'as'")
            try next_token(s)
            if not token_is_ident(s.token.val):
                try js_parse_error(s, "identifier expected")
            let local_name = js_dup_atom(ctx, s.token.u.ident.atom)
            try js_parse_import_binding(s, m, local_name, atom__star_, true)
        elif s.token.val == TokenType.lbrace:
            try next_token(s)

            while s.token.val != TokenType.rbrace:
                try js_parse_import_specifier(s, m)
                if s.token.val != TokenType.comma:
                    break
                try next_token(s)
            try js_parse_expect(s, TokenType.rbrace)
    return try js_parse_from_clause(s, m)

func js_parse_import(s: ParseState*) -> !:
    let ctx = s.ctx
    let m = s.fd().module else trap("js_parse_import: not a module")

    try next_token(s)

    let first_import = m.import_entries_count
    var idx: i32 = 0
    if s.token.val == TokenType.string:
        let module_name = try js_value_to_atom(ctx, s.token.u.str_.str)
        next_token(s) catch failure:
            js_free_atom(ctx, module_name)
            error(failure.code, failure.message)
        idx = add_req_module_entry(ctx, m, module_name) catch failure:
            js_free_atom(ctx, module_name)
            error(failure.code, failure.message)
        js_free_atom(ctx, module_name)
        if s.token.val == TokenType.with_:
            try js_parse_with_clause(s, module_req_entry(m, idx))
    else:
        idx = try js_parse_import_clause(s, m)
    for i in first_import..<m.import_entries_count:
        module_import_entry(m, i).req_module_idx = idx

    try js_parse_expect_semi(s)

func js_parse_source_element(s: ParseState*) -> !:
    let fd = s.fd()

    if (s.token.val == TokenType.function or (token_is_pseudo_keyword(s, atom_async) and peek_token(s, true) == TokenType.function)):
        try js_parse_function_decl(s, ParseFunctionKind.statement, js_func_normal, no_atom, s.token.ptr)
    elif s.token.val == TokenType.export_ and fd.module != none:
        try js_parse_export(s)
    else:
        var is_import = false
        if s.token.val == TokenType.import_ and fd.module != none:
            # the peek_token is needed to avoid confusion with ImportCall (dynamic import) or
            # import.meta
            let tok = peek_token(s, false)
            is_import = tok != TokenType.lparen and tok != TokenType.dot
        if is_import:
            try js_parse_import(s)
        else:
            try js_parse_statement_or_decl(s, decl_mask_all)

# mark: Function definitions ====================================================================

func js_new_function_def(ctx: Context*, parent: FunctionDef*?, is_eval: bool, is_func_expr: bool,
                         filename: const u8*, source_ptr: const u8*,
                         get_line_col_cache: GetLineColCache*) -> FunctionDef*!:
    let fd = (FunctionDef*)(try js_mallocz(ctx, memory.size_of(FunctionDef)))

    fd.ctx = ctx
    cutils.init_list_head(&fd.child_list)

    # insert in parent list
    fd.parent = parent
    fd.parent_cpool_idx = -1
    if let p = parent:
        cutils.list_add_tail(&fd.link, &p.child_list)
        fd.js_mode = p.js_mode
        fd.parent_scope_level = p.scope_level
    let strip_flags = (i32)ctx.rt.strip_flags
    fd.strip_debug = (strip_flags & strip_debug) != 0
    fd.strip_source = (strip_flags & (strip_debug | strip_source)) != 0

    fd.is_eval = is_eval
    fd.is_func_expr = is_func_expr
    js_dbuf_bytecode_init(ctx, &fd.byte_code)
    fd.last_opcode_pos = -1
    fd.func_name = no_atom
    fd.var_object_idx = -1
    fd.arg_var_object_idx = -1
    fd.arguments_var_idx = -1
    fd.arguments_arg_idx = -1
    fd.func_var_idx = -1
    fd.eval_ret_idx = -1
    fd.this_var_idx = -1
    fd.new_target_var_idx = -1
    fd.this_active_func_var_idx = -1
    fd.home_object_var_idx = -1

    # XXX: should distinguish arg, var and var object and body scopes
    fd.scopes = &fd.def_scope_array[0]
    fd.scope_size = (i32)fd.def_scope_array.length
    fd.scope_count = 1
    fd.scopes[0].first = -1
    fd.scopes[0].parent = -1
    # 0: var/arg scope
    fd.scope_level = 0
    fd.scope_first = -1
    fd.body_scope = -1

    # QuickJS ignores a failure here (the name is JS_ATOM_NULL then)
    fd.filename = js_new_atom_len(ctx, filename, cutils.strlen(filename)) catch failure: recover no_atom
    fd.source_pos = (u32)(source_ptr - get_line_col_cache.buf_start)
    fd.get_line_col_cache = get_line_col_cache

    js_dbuf_init(ctx, &fd.pc2line)
    fd.last_opcode_source_ptr = source_ptr
    return fd

func js_free_function_def(ctx: Context*, fd: FunctionDef*):
    # free the child functions
    let head = &fd.child_list
    var el = head.next else trap("js_free_function_def: unlinked child list")
    while el != head:
        let next = el.next else trap("js_free_function_def: unlinked child list")
        let fd1 = (FunctionDef*)((u8*)el - memory.offset_of(FunctionDef, link))
        js_free_function_def(ctx, fd1)
        el = next

    if let bc_buf = fd.byte_code.buf:
        free_bytecode_atoms(ctx.rt, bc_buf, (i32)fd.byte_code.size, fd.use_short_opcodes)
    cutils.dbuf_free(&fd.byte_code)
    if let p = fd.jump_slots:
        js_free(ctx, p)
    if let p = fd.label_slots:
        js_free(ctx, p)
    if let p = fd.line_number_slots:
        js_free(ctx, p)

    if let cpool = fd.cpool:
        for i in 0..<fd.cpool_count:
            js_free_value(ctx, cpool[(usize)i])
        js_free(ctx, cpool)

    js_free_atom(ctx, fd.func_name)

    if let vars = fd.vars:
        for i in 0..<fd.var_count:
            js_free_atom(ctx, vars[(usize)i].var_name)
        js_free(ctx, vars)
    if let args = fd.args:
        for i in 0..<fd.arg_count:
            js_free_atom(ctx, args[(usize)i].var_name)
        js_free(ctx, args)

    if let global_vars = fd.global_vars:
        for i in 0..<fd.global_var_count:
            js_free_atom(ctx, global_vars[(usize)i].var_name)
        js_free(ctx, global_vars)

    if let closure_var = fd.closure_var:
        for i in 0..<fd.closure_var_count:
            js_free_atom(ctx, closure_var[(usize)i].var_name)
        js_free(ctx, closure_var)

    if fd.scopes != &fd.def_scope_array[0]:
        js_free(ctx, fd.scopes)

    js_free_atom(ctx, fd.filename)
    cutils.dbuf_free(&fd.pc2line)

    if let source = fd.source:
        js_free(ctx, source)

    if fd.parent != none:
        # remove in parent list
        cutils.list_del(&fd.link)
    js_free(ctx, fd)