Function convertExpr

book/tiny-ts-parser.ts:674–851

(node: p.TSESTree.Expression, ctx: Context)

// Convert estree expression node to our simplified node definition
function convertExpr(node: p.TSESTree.Expression, ctx: Context): Term {
  switch (node.type) {
    case "UnaryExpression": {
      if (node.operator !== "!") error(`unsupported operator: ${node.operator}`, node);
      const body = convertExpr(node.argument, ctx);
      return { tag: "not", cond: body, loc: node.loc };
    }
    // deno-lint-ignore no-fallthrough
    case "BinaryExpression": {
      if (node.left.type === "PrivateIdentifier") error("private identifer is not allowed", node.left);
      switch (node.operator) {
        case "+": {
          const left = convertExpr(node.left, ctx);
          const right = convertExpr(node.right, ctx);
          return { tag: "add", left, right, loc: node.loc };
        }
        case "===":
        case "!==": {
          const left = convertExpr(node.left, ctx);
          const right = convertExpr(node.right, ctx);
          return { tag: "compare", op: node.operator, left, right, loc: node.loc };
        }
        case "in": {
          const key = convertExpr(node.left, ctx);
          const record = convertExpr(node.right, ctx);
          return { tag: "recordIn", record, key, loc: node.loc };
        }
        default:
          error(`unsupported operator: ${node.operator}`, node);
      }
    }
    case "Identifier":
      return { tag: "var", name: node.name, loc: node.loc };
    // deno-lint-ignore no-fallthrough
    case "Literal":
      switch (typeof node.value) {
        case "number":
          return { tag: "number", n: node.value, loc: node.loc };
        case "boolean":
          return { tag: node.value ? "true" : "false", loc: node.loc };
        case "string":
          return { tag: "string", s: node.value, loc: node.loc };
        default:
          error(`unsupported literal: ${node.value}`, node);
      }
    case "ArrowFunctionExpression": {
      const typeParams = node.typeParameters?.params.map((typeParameter) => typeParameter.name.name);
      const newCtx = typeParams ? extendContextWithTypeVars(ctx, typeParams) : ctx;
      const params = node.params.map((param) => {
        const { name, type } = getParam(param);
        return { name, type: simplifyType(type, newCtx) };
      });
      let retType;
      if (node.returnType) {
        retType = simplifyType(convertType(node.returnType.typeAnnotation), ctx);
      }
      const body = node.body.type === "BlockStatement"
        ? convertStmts(node.body.body, true, newCtx)