Function convertStmt

article/utils.ts:382–438

(i: number, ctx: Context)

function convertStmts(nodes: p.TSESTree.Statement[], requireReturn: boolean, ctx: Context): Term {
  function convertStmt(i: number, ctx: Context): Term {
    const last = nodes.length - 1 === i;
    const node = nodes[i];
    switch (node.type) {
      case "VariableDeclaration": {
        if (last && requireReturn) error("return is required", node);
        if (node.declarations.length !== 1) error("multiple variable declaration is not allowed", node);
        const decl = node.declarations[0];
        if (!decl.init) error("variable initializer is required", decl);
        const name = getIdentifier(decl.id);
        const init = convertExpr(decl.init, ctx);
        const rest: Term = last ? { tag: "var", name, loc: node.loc } : convertStmt(i + 1, ctx);
        return { tag: "const", name, init, rest, loc: node.loc };
      }
      case "ExportNamedDeclaration": {
        if (last && requireReturn) error("return is required", node);
        if (!node.declaration || node.declaration.type !== "FunctionDeclaration") {
          error("export must have a function declaration", node);
        }
        return getRecFunc(node.declaration, ctx, last ? null : () => convertStmt(i + 1, ctx));
      }
      case "FunctionDeclaration": {
        if (last && requireReturn) error("return is required", node);
        return getRecFunc(node, ctx, last ? null : () => convertStmt(i + 1, ctx));
      }
      case "ExpressionStatement": {
        if (last && requireReturn) error("return is required", node);
        const body = convertExpr(node.expression, ctx);
        return last ? body : { tag: "seq", body, rest: convertStmt(i + 1, ctx), loc: node.loc };
      }
      case "ReturnStatement": {
        if (!node.argument) error("return must have an argument", node);
        return convertExpr(node.argument, ctx);
      }
      case "IfStatement": {
        const cond = convertExpr(node.test, ctx);
        const thn = convertStmts([node.consequent], requireReturn, ctx);
        if (!node.alternate) error("else clause is requried", node);
        const els = convertStmts([node.alternate], requireReturn, ctx);
        return { tag: "if", cond, thn, els, loc: node.loc };
      }
      case "SwitchStatement": {
        const varName = getSwitchVarName(node.discriminant);
        const clauses: VariantTerm[] = [];
        node.cases.forEach((caseNode) => {
          if (!caseNode.test) error("default case is not allowed", caseNode);
          const conseq = caseNode.consequent;
          const stmts = conseq.length === 1 && conseq[0].type === "BlockStatement" ? conseq[0].body : conseq;
          const clause = convertStmts(stmts, requireReturn, ctx);
          clauses.push({ label: getLiteralString(caseNode.test), term: clause });
        });
        return { tag: "taggedUnionGet", varName, clauses, loc: node.loc };
      }
      default:
        error(`unsupported statement node: ${node.type}`, node);
    }
  }
  return convertStmt(0, ctx);