@fink/loxia/ir/assignment/init.js

A fink to JavaScript compiler.

import { _in_ } from "@fink/js-interop/runtime.js";
import { reverse as reverse_0 } from "@fink/std-lib/iter.js";
import { add as add_0 } from "../context.js";
import { any as any_0 } from "../context.js";
import { unique_or_id as unique_or_id_0 } from "../context.js";
import { ir_fn as ir_fn_0 } from "../context.js";
import { transform as transform_0 } from "../transform.js";
import { members_as_rec as members_as_rec_0 } from "../literals/record.js";
import { str as str_5 } from "../literals/string.js";
import { bind as bind_0 } from "../identifier/init.js";
import { bind_x as bind_x_0 } from "../identifier/init.js";

const lst_h_0 = (lst_id_0, name_or_id_0, drec_0, ctx_0) => {
  const result_0 = ir_fn_0(`lst_h`, [lst_id_0], name_or_id_0, {
    loc: drec_0.loc
  }, ctx_0);
  return result_0;
};

const lst_r_0 = (lst_id_1, name_or_id_1, drec_1, ctx_1) => {
  const result_1 = ir_fn_0(`lst_r`, [lst_id_1], name_or_id_1, {
    loc: drec_1.loc
  }, ctx_1);
  return result_1;
};

const lst_t_0 = (lst_id_2, drec_2, ctx_2) => {
  const result_2 = ir_fn_0(`lst_t`, [lst_id_2], `tail`, {
    loc: drec_2.loc
  }, ctx_2);
  return result_2;
};

const if_v_0 = (val_id_0, true_val_id_0, false_val_id_0, name_or_id_2, drec_3, ctx_3) => {
  const result_3 = ir_fn_0(`ifv`, [val_id_0, true_val_id_0, false_val_id_0], name_or_id_2, {
    loc: drec_3.loc
  }, ctx_3);
  return result_3;
};

const rec_g_0 = (rec_id_0, key_id_0, name_or_id_3, drec_4, ctx_4) => {
  const result_4 = ir_fn_0(`rec_g`, [rec_id_0, key_id_0], name_or_id_3, {
    loc: drec_4.loc
  }, ctx_4);
  return result_4;
};

const rec_d_0 = (rec_id_1, keys_0, name_or_id_4, drec_5, ctx_5) => {
  const result_5 = ir_fn_0(`rec_d`, [rec_id_1, ...keys_0], name_or_id_4, {
    loc: drec_5.loc
  }, ctx_5);
  return result_5;
};

const rec_get_0 = (rec_id_2, key_id_1, val_id_1, fallback_0, drec_6, ctx_6) => {
  const loc_6 = drec_6.loc;

  /* istanbul ignore else */
  if (fallback_0 === false) {
    const result_10 = rec_g_0(rec_id_2, key_id_1, val_id_1, {
      loc: loc_6
    }, ctx_6);
    return result_10;
  }

  const dlst_0 = rec_g_0(rec_id_2, key_id_1, `hdm`, {
    loc: loc_6
  }, ctx_6);
  const tmp_id_0 = dlst_0[1];
  const dlst_1 = if_v_0(tmp_id_0, tmp_id_0, fallback_0, val_id_1, {
    loc: loc_6
  }, dlst_0[2]);
  return [[...dlst_0[0], ...dlst_1[0]], dlst_1[1], dlst_1[2]];
};

const get_key_val_0 = (rec_id_3, expr_0, fallback_1, ctx_7) => {
  let ret_8;

  ret_8: {
    /* istanbul ignore else */
    if (null != expr_0) {
      const itm_8 = expr_0.left;

      /* istanbul ignore else */
      if (null != itm_8) {
        /* istanbul ignore else */
        if (itm_8.type === `ident`) {
          /* istanbul ignore else */
          if (expr_0.right === false) {
            const dlst_9 = bind_0(expr_0.left, ctx_7);
            const dlst_10 = str_5(expr_0.left.value, `key`, expr_0.left, dlst_9[1]);
            ret_8 = [dlst_10[0], dlst_10[1], dlst_9[0], dlst_10[2]];

            /* istanbul ignore next */
            break ret_8;
          }
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_0) {
      const itm_4 = expr_0.left;

      /* istanbul ignore else */
      if (null != itm_4) {
        /* istanbul ignore else */
        if (itm_4.type === `ident`) {
          const itm_6 = expr_0.right;

          /* istanbul ignore else */
          if (null != itm_6) {
            /* istanbul ignore else */
            if (itm_6.type === `ident`) {
              const dlst_7 = bind_0(expr_0.right, ctx_7);
              const dlst_8 = str_5(expr_0.left.value, `key`, expr_0.left, dlst_7[1]);
              ret_8 = [dlst_8[0], dlst_8[1], dlst_7[0], dlst_8[2]];

              /* istanbul ignore next */
              break ret_8;
            }
          }
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_0) {
      const itm_2 = expr_0.right;

      /* istanbul ignore else */
      if (null != itm_2) {
        /* istanbul ignore else */
        if (itm_2.type === `ident`) {
          const dlst_5 = bind_0(expr_0.right, ctx_7);
          const dlst_6 = transform_0(expr_0.left, `key`, dlst_5[1]);
          ret_8 = [dlst_6[0], dlst_6[1], dlst_5[0], dlst_6[2]];

          /* istanbul ignore next */
          break ret_8;
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_0) {
      const itm_0 = expr_0.left;

      /* istanbul ignore else */
      if (null != itm_0) {
        /* istanbul ignore else */
        if (itm_0.type === `ident`) {
          const dlst_4 = str_5(expr_0.left.value, `key`, expr_0.left, ctx_7);
          ret_8 = [dlst_4[0], dlst_4[1], `val`, dlst_4[2]];

          /* istanbul ignore next */
          break ret_8;
        }
      }
    }

    const dlst_3 = transform_0(expr_0.left, `key`, ctx_7);
    ret_8 = [dlst_3[0], dlst_3[1], `val`, dlst_3[2]];

    /* istanbul ignore next */
    break ret_8;
  }

  const dlst_2 = ret_8;
  const key_id_7 = dlst_2[1];
  const dlst_11 = rec_get_0(rec_id_3, key_id_7, dlst_2[2], fallback_1, expr_0, dlst_2[3]);
  return [[...dlst_2[0], ...dlst_11[0]], key_id_7, dlst_11[1], dlst_11[2]];
};

const transform_dr_0 = (...args_8) => {
  transform_dr_0: do {
    const dlst_12 = args_8[0];
    const hdm_0 = dlst_12[0];
    const expr_1 = undefined === hdm_0 ? false : hdm_0;
    const tail_72 = dlst_12.slice(1);
    const rec_id_4 = args_8[1];
    const ctx_8 = args_8[2];
    const transform_dl_0 = args_8[3];
    const hdm_1 = args_8[4];
    const keys_1 = undefined === hdm_1 ? [] : hdm_1;
    const hdm_2 = args_8[5];
    const prev_0 = undefined === hdm_2 ? [] : hdm_2;
    const hdm_3 = args_8[6];
    const fallback_2 = undefined === hdm_3 ? false : hdm_3;

    /* istanbul ignore else */
    if (expr_1 === false) {
      return [prev_0, rec_id_4, ctx_8];
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      /* istanbul ignore else */
      if (expr_1.type === `spread`) {
        const dlst_20 = bind_0(expr_1.right, ctx_8);
        const dlst_21 = rec_d_0(rec_id_4, keys_1, dlst_20[0], expr_1, dlst_20[1]);
        args_8 = [tail_72, rec_id_4, dlst_21[2], transform_dl_0, keys_1, [...prev_0, ...dlst_21[0]]];
        continue transform_dr_0;
      }
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      /* istanbul ignore else */
      if (expr_1.right === false) {
        const dlst_19 = get_key_val_0(rec_id_4, expr_1, fallback_2, ctx_8);
        args_8 = [tail_72, rec_id_4, dlst_19[3], transform_dl_0, [...keys_1, dlst_19[1]], [...prev_0, ...dlst_19[0]]];
        continue transform_dr_0;
      }
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      const itm_19 = expr_1.right;

      /* istanbul ignore else */
      if (null != itm_19) {
        /* istanbul ignore else */
        if (itm_19.type === `assign`) {
          const drec_8 = expr_1.right;
          const dlst_18 = transform_0(drec_8.right, `flbk`, ctx_8);
          args_8 = [[{ ...expr_1,
            right: drec_8.left
          }, ...tail_72], rec_id_4, dlst_18[2], transform_dl_0, keys_1, [...prev_0, ...dlst_18[0]], dlst_18[1]];
          continue transform_dr_0;
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      const itm_17 = expr_1.left;

      /* istanbul ignore else */
      if (null != itm_17) {
        /* istanbul ignore else */
        if (itm_17.type === `member`) {
          const drec_7 = members_as_rec_0(expr_1.left, expr_1.right);
          args_8 = [[...drec_7.exprs, ...tail_72], rec_id_4, ctx_8, transform_dl_0, keys_1, prev_0, fallback_2];
          continue transform_dr_0;
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      const itm_15 = expr_1.right;

      /* istanbul ignore else */
      if (null != itm_15) {
        /* istanbul ignore else */
        if (true === _in_(itm_15.type, [`ident`, `empty`])) {
          const dlst_17 = get_key_val_0(rec_id_4, expr_1, fallback_2, ctx_8);
          args_8 = [tail_72, rec_id_4, dlst_17[3], transform_dl_0, [...keys_1, dlst_17[1]], [...prev_0, ...dlst_17[0]]];
          continue transform_dr_0;
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      const itm_13 = expr_1.right;

      /* istanbul ignore else */
      if (null != itm_13) {
        /* istanbul ignore else */
        if (itm_13.type === `rec`) {
          const dlst_15 = get_key_val_0(rec_id_4, expr_1, fallback_2, ctx_8);
          const dlst_16 = transform_dr_0(expr_1.right.exprs, dlst_15[2], dlst_15[3], transform_dl_0);
          args_8 = [tail_72, rec_id_4, dlst_16[2], transform_dl_0, [...keys_1, dlst_15[1]], [...prev_0, ...dlst_15[0], ...dlst_16[0]]];
          continue transform_dr_0;
        }
      }
    }

    /* istanbul ignore else */
    if (null != expr_1) {
      const itm_11 = expr_1.right;

      /* istanbul ignore else */
      if (null != itm_11) {
        /* istanbul ignore else */
        if (itm_11.type === `list`) {
          const dlst_13 = get_key_val_0(rec_id_4, expr_1, fallback_2, ctx_8);
          const dlst_14 = transform_dl_0(expr_1.right.exprs, dlst_13[2], dlst_13[3], []);
          args_8 = [tail_72, rec_id_4, dlst_14[2], transform_dl_0, [...keys_1, dlst_13[1]], [...prev_0, ...dlst_13[0], ...dlst_14[0]]];
          continue transform_dr_0;
        }
      }
    }

    /* istanbul ignore next */
    return;
  } while (true);
};

const head_tail_0 = (lst_id_3, val_id_9, drec_9, ctx_9, hdm_4) => {
  const loc_7 = drec_9.loc;
  const fallback_3 = undefined === hdm_4 ? false : hdm_4;
  const dlst_22 = lst_t_0(lst_id_3, {
    loc: loc_7
  }, ctx_9);
  const hd_ctx_0 = dlst_22[2];
  let ret_12;

  ret_12: {
    /* istanbul ignore else */
    if (fallback_3 === false) {
      const dlst_26 = lst_h_0(lst_id_3, val_id_9, {
        loc: loc_7
      }, hd_ctx_0);
      ret_12 = [dlst_26[0], dlst_26[2]];

      /* istanbul ignore next */
      break ret_12;
    }

    const dlst_24 = lst_h_0(lst_id_3, `hdm`, {
      loc: loc_7
    }, hd_ctx_0);
    const hd_id_0 = dlst_24[1];
    const dlst_25 = if_v_0(hd_id_0, hd_id_0, fallback_3, val_id_9, {
      loc: loc_7
    }, dlst_24[2]);
    ret_12 = [[...dlst_24[0], ...dlst_25[0]], dlst_25[2]];

    /* istanbul ignore next */
    break ret_12;
  }

  const dlst_23 = ret_12;
  return [[...dlst_23[0], ...dlst_22[0]], dlst_22[1], dlst_23[1]];
};

const transform_dl_1 = (...args_10) => {
  transform_dl_1: do {
    const dlst_27 = args_10[0];
    const hdm_5 = dlst_27[0];
    const expr_2 = undefined === hdm_5 ? false : hdm_5;
    const tail_130 = dlst_27.slice(1);
    const lst_id_4 = args_10[1];
    const ctx_10 = args_10[2];
    const hdm_6 = args_10[3];
    const prev_1 = undefined === hdm_6 ? [] : hdm_6;
    const fallback_4 = args_10[4];

    /* istanbul ignore else */
    if (expr_2 === false) {
      return [prev_1, lst_id_4, ctx_10];
    }

    /* istanbul ignore else */
    if (null != expr_2) {
      /* istanbul ignore else */
      if (expr_2.type === `ident`) {
        const dlst_41 = bind_0(expr_2, ctx_10);
        const dlst_42 = head_tail_0(lst_id_4, dlst_41[0], expr_2, dlst_41[1], fallback_4);
        args_10 = [tail_130, dlst_42[1], dlst_42[2], [...prev_1, ...dlst_42[0]]];
        continue transform_dl_1;
      }
    }

    /* istanbul ignore else */
    if (null != expr_2) {
      /* istanbul ignore else */
      if (expr_2.type === `assign`) {
        const dlst_40 = transform_0(expr_2.right, `flbk`, ctx_10);
        args_10 = [[expr_2.left, ...tail_130], lst_id_4, dlst_40[2], [...prev_1, ...dlst_40[0]], dlst_40[1]];
        continue transform_dl_1;
      }
    }

    /* istanbul ignore else */
    if (null != expr_2) {
      /* istanbul ignore else */
      if (expr_2.type === `empty`) {
        const dlst_38 = unique_or_id_0(`unused`, expr_2, ctx_10);
        const dlst_39 = head_tail_0(lst_id_4, dlst_38[0], expr_2, dlst_38[1]);
        args_10 = [tail_130, dlst_39[1], dlst_39[2], [...prev_1, ...dlst_39[0]]];
        continue transform_dl_1;
      }
    }

    /* istanbul ignore else */
    if (null != expr_2) {
      /* istanbul ignore else */
      if (expr_2.type === `spread`) {
        const dlst_34 = lst_r_0(lst_id_4, `rtail`, expr_2, ctx_10);
        const rev_exprs_0 = reverse_0(tail_130);
        const dlst_35 = transform_dl_1(rev_exprs_0, dlst_34[1], dlst_34[2], [...prev_1, ...dlst_34[0]]);
        const out_8 = dlst_35[0];
        const tail_id_3 = dlst_35[1];
        const spread_ctx_0 = dlst_35[2];

        /* istanbul ignore else */
        if (expr_2.right === false) {
          return [out_8, tail_id_3, spread_ctx_0];
        }

        const dlst_36 = bind_0(expr_2.right, spread_ctx_0);
        const id_0 = dlst_36[0];
        const dlst_37 = lst_r_0(tail_id_3, id_0, expr_2, dlst_36[1]);
        return [[...out_8, ...dlst_37[0]], id_0, dlst_37[2]];
      }
    }

    /* istanbul ignore else */
    if (null != expr_2) {
      /* istanbul ignore else */
      if (expr_2.type === `list`) {
        const dlst_31 = unique_or_id_0(`dlst`, expr_2, ctx_10);
        const val_id_11 = dlst_31[0];
        const dlst_32 = head_tail_0(lst_id_4, val_id_11, expr_2, dlst_31[1], fallback_4);
        const dlst_33 = transform_dl_1(expr_2.exprs, val_id_11, dlst_32[2], []);
        args_10 = [tail_130, dlst_32[1], dlst_33[2], [...prev_1, ...dlst_32[0], ...dlst_33[0]]];
        continue transform_dl_1;
      }
    }

    /* istanbul ignore else */
    if (null != expr_2) {
      /* istanbul ignore else */
      if (expr_2.type === `rec`) {
        const dlst_28 = unique_or_id_0(`drec`, expr_2, ctx_10);
        const val_id_10 = dlst_28[0];
        const dlst_29 = head_tail_0(lst_id_4, val_id_10, expr_2, dlst_28[1], fallback_4);
        const dlst_30 = transform_dr_0(expr_2.exprs, val_id_10, dlst_29[2], transform_dl_1, []);
        args_10 = [tail_130, dlst_29[1], dlst_30[2], [...prev_1, ...dlst_29[0], ...dlst_30[0]]];
        continue transform_dl_1;
      }
    }

    /* istanbul ignore next */
    return;
  } while (true);
};

const transform_assign_0 = (node_0, _1, ctx_11) => {
  const value_6 = node_0.left;

  /* istanbul ignore else */
  if (null != value_6) {
    /* istanbul ignore else */
    if (value_6.type === `list`) {
      const dlst_47 = transform_0(node_0.right, `dlst`, ctx_11);
      const dlst_48 = transform_dl_1(node_0.left.exprs, dlst_47[1], dlst_47[2]);
      return [[...dlst_47[0], ...dlst_48[0]], dlst_48[2]];
    }
  }

  /* istanbul ignore else */
  if (null != value_6) {
    /* istanbul ignore else */
    if (value_6.type === `rec`) {
      const dlst_45 = transform_0(node_0.right, `drec`, ctx_11);
      const dlst_46 = transform_dr_0(node_0.left.exprs, dlst_45[1], dlst_45[2], transform_dl_1);
      return [[...dlst_45[0], ...dlst_46[0]], dlst_46[2]];
    }
  }

  /* istanbul ignore else */
  if (null != value_6) {
    /* istanbul ignore else */
    if (value_6.type === `ident`) {
      const name_0 = node_0.left.value;
      const dlst_43 = unique_or_id_0(name_0, node_0.left, { ...ctx_11,
        self_name: name_0
      });
      const l_id_0 = dlst_43[0];
      const dlst_44 = transform_0(node_0.right, l_id_0, dlst_43[1]);
      const {
        self_name: _key_116,
        ...bind_ctx_0
      } = dlst_44[2];
      const end_ctx_5 = bind_x_0(node_0.left, l_id_0, bind_ctx_0);
      return [dlst_44[0], end_ctx_5];
    }
  }

  /* istanbul ignore next */
  return;
};

const add_assignment_0 = ctx_12 => {
  const pfn_0 = add_0(any_0, `=`, transform_assign_0);
  const ppr_0 = pfn_0(ctx_12);
  return ppr_0;
};

export const lst_h = lst_h_0,
      lst_r = lst_r_0,
      lst_t = lst_t_0,
      if_v = if_v_0,
      rec_g = rec_g_0,
      rec_d = rec_d_0,
      rec_get = rec_get_0,
      get_key_val = get_key_val_0,
      transform_dr = transform_dr_0,
      head_tail = head_tail_0,
      transform_dl = transform_dl_1,
      transform_assign = transform_assign_0,
      add_assignment = add_assignment_0;