@fink/larix/cjs/testing/serialize.js

A parser for generating fink's AST.

const {
  starts_with
} = require("@fink/std-lib/str.js");

const {
  split
} = require("@fink/std-lib/regex.js");

const {
  map,
  join,
  length
} = require("@fink/std-lib/iter.js");

const {
  obj_to_json
} = require("@fink/std-lib/json.js");

const get_comment = (indent, comments) => {
  let ˆpipe_result_1 = comments;
  ˆpipe_result_1 = map(({
    op,
    value
  }) => {
    const ˆvalue_2 = op;

    /* istanbul ignore else */
    if (ˆvalue_2 === `#`) {
      return `${indent}#${value}`;
    }

    {
      {
        const lines = split(value, `\n`);
        {
          let ˆpipe_result_4 = lines;
          ˆpipe_result_4 = map(line => `${indent}--- ${line}`)(ˆpipe_result_4);
          return ˆpipe_result_4 = join(`\n`)(ˆpipe_result_4);
        }
      }
    }
  })(ˆpipe_result_1);
  return ˆpipe_result_1 = join(`\n`)(ˆpipe_result_1);
};

exports.get_comment = get_comment;

const trailing_comment = (indent, node) => {
  const ˆvalue_5 = node;

  /* istanbul ignore else */
  if (ˆvalue_5 != null) {
    const {
      comments: ˆp_7
    } = ˆvalue_5;

    /* istanbul ignore else */
    if (ˆp_7 != null) {
      const {
        trailing: ˆp_8
      } = ˆp_7;

      /* istanbul ignore else */
      if (0 < length(ˆp_8)) {
        {
          const comment = get_comment(`${indent}`, node.comments.trailing);
          return `\n${comment}`;
        }
      }
    }
  }

  {
    return ``;
  }
};

exports.trailing_comment = trailing_comment;

const str_type_op = ({
  type,
  op,
  comments,
  loc: {
    start,
    end
  }
}, indent) => {
  let _do_result;

  ˆmatch_10: {
    const ˆvalue_9 = op;

    /* istanbul ignore else */
    if (ˆvalue_9 && ˆvalue_9 !== type) {
      _do_result = `${type} ${op} (${start.line}:${start.column}-${end.line}:${end.column})`;
      break ˆmatch_10;
    }

    {
      _do_result = `${type} (${start.line}:${start.column}-${end.line}:${end.column})`;
      break ˆmatch_10;
    }
  }

  const head = _do_result;
  _do_result = undefined;

  let _do_result2;

  ˆmatch_12: {
    const ˆvalue_11 = comments;

    /* istanbul ignore else */
    if (ˆvalue_11 != null) {
      const {
        leading: ˆp_13
      } = ˆvalue_11;

      /* istanbul ignore else */
      if (0 < length(ˆp_13)) {
        {
          const comment = get_comment(`${indent}`, comments.leading);
          _do_result2 = `${comment}\n`;
        }
        break ˆmatch_12;
      }
    }

    {
      _do_result2 = ``;
      break ˆmatch_12;
    }
  }

  const leading = _do_result2;
  _do_result2 = undefined;
  return `${leading}${indent}${head}`;
};

exports.str_type_op = str_type_op;

const serialize_block = (node, serialize, indent) => {
  const head = str_type_op(node, indent);

  let _do_result3;

  {
    let ˆpipe_result_14 = node.exprs;
    ˆpipe_result_14 = map(expr => serialize(expr, `${indent}  `))(ˆpipe_result_14);
    _do_result3 = ˆpipe_result_14 = join(`\n`)(ˆpipe_result_14);
  }
  const exprs = _do_result3;
  _do_result3 = undefined;
  {
    const ˆvalue_15 = node;

    /* istanbul ignore else */
    if (ˆvalue_15 != null) {
      const {
        args: ˆp_17
      } = ˆvalue_15;

      /* istanbul ignore else */
      if (typeof ˆp_17?.[Symbol.iterator] === "function") {
        {
          let _do_result4;

          {
            let ˆpipe_result_18 = node.args;
            ˆpipe_result_18 = map(expr => serialize(expr, `${indent}  `))(ˆpipe_result_18);
            _do_result4 = ˆpipe_result_18 = join(`\n`)(ˆpipe_result_18);
          }
          const args = _do_result4;
          _do_result4 = undefined;

          let _do_result5;

          ˆmatch_20: {
            const ˆvalue_19 = node.args;

            /* istanbul ignore else */
            if (0 === length(ˆvalue_19)) {
              _do_result5 = `:`;
              break ˆmatch_20;
            }

            {
              _do_result5 = `\n${args}\n${indent}  :`;
              break ˆmatch_20;
            }
          }

          const arg_str = _do_result5;
          _do_result5 = undefined;
          return `${head}${arg_str}\n${exprs}`;
        }
      }
    }

    {
      return `${head}\n${exprs}`;
    }
  }
};

exports.serialize_block = serialize_block;

const serialize_call = (node, serialize, indent) => {
  const head = str_type_op(node, indent);
  const callee = serialize(node.callee, `${indent}  `);

  let _do_result6;

  {
    let ˆpipe_result_21 = node.args;
    ˆpipe_result_21 = map(expr => serialize(expr, `${indent}  `))(ˆpipe_result_21);
    _do_result6 = ˆpipe_result_21 = join(`\n`)(ˆpipe_result_21);
  }
  const args = _do_result6;
  _do_result6 = undefined;

  let _do_result7;

  ˆmatch_23: {
    const ˆvalue_22 = node.args;

    /* istanbul ignore else */
    if (0 < length(ˆvalue_22)) {
      _do_result7 = `\n${args}`;
      break ˆmatch_23;
    }

    {
      _do_result7 = ``;
      break ˆmatch_23;
    }
  }

  const arg_str = _do_result7;
  _do_result7 = undefined;
  return `${head}\n${callee}${arg_str}`;
};

exports.serialize_call = serialize_call;

const serialize_infix = (node, serialize, indent) => {
  const head = str_type_op(node, indent);
  const left = serialize(node.left, `${indent}  `);

  let _do_result8;

  ˆmatch_25: {
    const ˆvalue_24 = node;

    /* istanbul ignore else */
    if (ˆvalue_24 != null) {
      const {
        right: ˆp_26
      } = ˆvalue_24;

      /* istanbul ignore else */
      if (ˆp_26 === false) {
        _do_result8 = ``;
        break ˆmatch_25;
      }
    }

    {
      _do_result8 = `\n${serialize(node.right, `${indent}  `)}`;
      break ˆmatch_25;
    }
  }

  const right = _do_result8;
  _do_result8 = undefined;
  return `${head}\n${left}${right}`;
};

exports.serialize_infix = serialize_infix;

const serialize_prefix = (node, serialize, indent) => {
  const head = str_type_op(node, indent);
  const right = serialize(node.right, `${indent}  `);
  return `${head}\n${right}`;
};

exports.serialize_prefix = serialize_prefix;

const serialize_spread = (node, serialize, indent) => {
  const ˆvalue_27 = node;

  /* istanbul ignore else */
  if (ˆvalue_27 != null) {
    const {
      right: ˆp_29
    } = ˆvalue_27;

    /* istanbul ignore else */
    if (ˆp_29 === false) {
      return str_type_op(node, indent);
    }
  }

  {
    return serialize_prefix(node, serialize, indent);
  }
};

exports.serialize_spread = serialize_spread;

const serialize_str = (node, serialize, indent) => {
  const head = str_type_op(node, indent);

  let _do_result9;

  ˆmatch_31: {
    const ˆvalue_30 = node;

    /* istanbul ignore else */
    if (ˆvalue_30 != null) {
      const {
        tag: ˆp_32
      } = ˆvalue_30;

      /* istanbul ignore else */
      if (ˆp_32 === false) {
        _do_result9 = ``;
        break ˆmatch_31;
      }
    }

    {
      _do_result9 = ` ${node.tag.value}`;
      break ˆmatch_31;
    }
  }

  const tag = _do_result9;
  _do_result9 = undefined;

  let _do_result10;

  {
    let ˆpipe_result_33 = node.exprs;
    ˆpipe_result_33 = map(part => {
      const ˆvalue_34 = part.type;

      /* istanbul ignore else */
      if (ˆvalue_34 === `string:text`) {
        return `'${part.value}'`;
      }

      {
        {
          const value = serialize(part, `${indent}  `);
          return `\n${value}\n`;
        }
      }
    })(ˆpipe_result_33);
    ˆpipe_result_33 = join(``)(ˆpipe_result_33);
    _do_result10 = ˆpipe_result_33 = split(ˆpipe_result_33, `\n`);
  }
  const [lne, ...lns] = _do_result10;
  _do_result10 = undefined;
  {
    let ˆpipe_result_36 = lns;
    ˆpipe_result_36 = map(ln => `${indent}  ${ln}`)(ˆpipe_result_36);
  }

  let _do_result11;

  {
    let ˆpipe_result_37 = lns;
    _do_result11 = ˆpipe_result_37 = map(ln => `${indent}  ${ln}`)(ˆpipe_result_37);
  }
  const indented = _do_result11;
  _do_result11 = undefined;

  let _do_result12;

  {
    let ˆpipe_result_38 = [lne, ...indented];
    _do_result12 = ˆpipe_result_38 = join(`\n`)(ˆpipe_result_38);
  }
  const str = _do_result12;
  _do_result12 = undefined;
  return `${head}\n${indent}  ${tag}${str}`;
};

exports.serialize_str = serialize_str;

const serialize_regex = (node, indent) => {
  const head = str_type_op(node, indent);
  return `${head}\n${indent}  /${node.value}/${node.flags}`;
};

exports.serialize_regex = serialize_regex;

const serialize_other = (node, indent) => {
  const head = str_type_op(node, indent);
  return `${head} ${node.value}`;
};

exports.serialize_other = serialize_other;

const serialize_jsx = (node, serialize, indent) => {
  const head = str_type_op(node, indent);
  {
    const ˆvalue_39 = node;

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_41
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_41 === `jsx:frag`) {
        {
          let _do_result13;

          {
            let ˆpipe_result_42 = node.children;
            ˆpipe_result_42 = map(expr => serialize(expr, `${indent}  `))(ˆpipe_result_42);
            _do_result13 = ˆpipe_result_42 = join(`\n`)(ˆpipe_result_42);
          }
          const children = _do_result13;
          _do_result13 = undefined;

          let _do_result14;

          ˆmatch_44: {
            const ˆvalue_43 = node.children;

            /* istanbul ignore else */
            if (0 < length(ˆvalue_43)) {
              _do_result14 = `\n${indent}  :\n${children}`;
              break ˆmatch_44;
            }

            {
              _do_result14 = ``;
              break ˆmatch_44;
            }
          }

          const children_str = _do_result14;
          _do_result14 = undefined;
          return `${head} ${children_str}`;
        }
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_45
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_45 === `jsx:elem`) {
        {
          let _do_result15;

          {
            let ˆpipe_result_46 = node.props;
            ˆpipe_result_46 = map(expr => serialize(expr, `${indent}  `))(ˆpipe_result_46);
            _do_result15 = ˆpipe_result_46 = join(`\n`)(ˆpipe_result_46);
          }
          const props = _do_result15;
          _do_result15 = undefined;

          let _do_result16;

          {
            let ˆpipe_result_47 = node.children;
            ˆpipe_result_47 = map(expr => serialize(expr, `${indent}  `))(ˆpipe_result_47);
            _do_result16 = ˆpipe_result_47 = join(`\n`)(ˆpipe_result_47);
          }
          const children = _do_result16;
          _do_result16 = undefined;

          let _do_result17;

          ˆmatch_49: {
            const ˆvalue_48 = node.props;

            /* istanbul ignore else */
            if (0 < length(ˆvalue_48)) {
              _do_result17 = `\n${props}`;
              break ˆmatch_49;
            }

            {
              _do_result17 = ``;
              break ˆmatch_49;
            }
          }

          const props_str = _do_result17;
          _do_result17 = undefined;

          let _do_result18;

          ˆmatch_51: {
            const ˆvalue_50 = node.children;

            /* istanbul ignore else */
            if (0 < length(ˆvalue_50)) {
              _do_result18 = `\n${indent}  :\n${children}`;
              break ˆmatch_51;
            }

            {
              _do_result18 = ``;
              break ˆmatch_51;
            }
          }

          const children_str = _do_result18;
          _do_result18 = undefined;
          return `${head} ${node.name.value}${props_str}${children_str}`;
        }
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_52,
        value: ˆp_53
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_52 === `jsx:attr`)
        /* istanbul ignore else */
        if (ˆp_53 !== false) {
          {
            const name = serialize(node.name, `${indent}  `);
            const value = serialize(node.value, `${indent}  `);
            return `${head}\n${name}\n${value}`;
          }
        }
    }

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_54
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_54 === `jsx:attr`) {
        {
          const name = serialize(node.name, `${indent}  `);
          return `${head}\n${name}`;
        }
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_55
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_55 === `jsx:text`) {
        return `${head}\n${indent}  ${obj_to_json(node.value)}`;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_56
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_56 === `jsx:string`) {
        return `${head}\n${indent}  '${node.value}'`;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_39 != null) {
      const {
        type: ˆp_57
      } = ˆvalue_39;

      /* istanbul ignore else */
      if (ˆp_57 === `jsx:expr`) {
        {
          const expr = serialize(node.expr, `${indent}  `);
          return `${head}\n${expr}`;
        }
      }
    }
  }
};

exports.serialize_jsx = serialize_jsx;

const serialize = (node, indent = ``) => {
  let _do_result19;

  ˆmatch_59: {
    const ˆvalue_58 = node;

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        error: ˆp_60
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_60 != null) {
        _do_result19 = `${indent}::error::`;
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        type: ˆp_61
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_61 === `empty`) {
        _do_result19 = str_type_op(node, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        type: ˆp_62
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_62 === `string`) {
        _do_result19 = serialize_str(node, serialize, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        type: ˆp_63
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_63 === `call`) {
        _do_result19 = serialize_call(node, serialize, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        type: ˆp_64
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_64 === `regex`) {
        _do_result19 = serialize_regex(node, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        type: ˆp_65
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_65 === `spread`) {
        _do_result19 = serialize_spread(node, serialize, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        type: ˆp_66
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (starts_with(ˆp_66, `jsx:`)) {
        _do_result19 = serialize_jsx(node, serialize, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        left: ˆp_67,
        right: ˆp_68
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_67 != null)
        /* istanbul ignore else */
        if (ˆp_68 != null) {
          _do_result19 = serialize_infix(node, serialize, indent);
          break ˆmatch_59;
        }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        right: ˆp_69
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_69 != null) {
        _do_result19 = serialize_prefix(node, serialize, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        exprs: ˆp_70
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_70 != null) {
        _do_result19 = serialize_block(node, serialize, indent);
        break ˆmatch_59;
      }
    }

    /* istanbul ignore else */
    if (ˆvalue_58 != null) {
      const {
        value: ˆp_71
      } = ˆvalue_58;

      /* istanbul ignore else */
      if (ˆp_71 != null) {
        _do_result19 = serialize_other(node, indent);
        break ˆmatch_59;
      }
    }

    {
      {
        const head = str_type_op(node, indent);
        _do_result19 = `Error: cannot serialize ${head}`;
      }
      break ˆmatch_59;
    }
  }

  const result = _do_result19;
  _do_result19 = undefined;
  return `${result}${trailing_comment(`${indent}`, node)}`;
};

exports.serialize = serialize;