Function convertExpr

article/utils.ts:292–379

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

}

function convertExpr(node: p.TSESTree.Expression, ctx: Context): Term {
  switch (node.type) {
    case "BinaryExpression": {
      if (node.operator !== "+") error(`unsupported operator: ${node.operator}`, node);
      if (node.left.type === "PrivateIdentifier") error("private identifer is not allowed", node.left);
      const left = convertExpr(node.left, ctx);
      const right = convertExpr(node.right, ctx);
      return { tag: "add", left, right, loc: node.loc };
    }
    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 };
        default:
          error(`unsupported literal: ${node.value}`, node);
      }
    case "ArrowFunctionExpression": {
      const typeParams = node.typeParameters?.params.map((typeParameter) => typeParameter.name.name);
      const newCtx = typeParams ? addDefinedTypeVars(typeParams, ctx) : ctx;
      const params = node.params.map((param) => {
        const { name, type } = getParam(param);
        return { name, type: simplifyType(type, newCtx) };
      });
      if (node.returnType) error("return type is not required for arrow function", node.returnType);
      const body = node.body.type === "BlockStatement"
        ? convertStmts(node.body.body, true, newCtx)
        : convertExpr(node.body, newCtx);
      const func: Term = { tag: "func", params, body, loc: node.loc };
      return typeParams ? { tag: "typeAbs", typeParams, body: func, loc: node.typeParameters!.loc } : func;
    }
    case "CallExpression": {
      const args = node.arguments.map((argument) => {
        if (argument.type === "SpreadElement") error("argument must be an expression", argument);
        return convertExpr(argument, ctx);
      });
      let func = convertExpr(node.callee, ctx);
      if (node.typeArguments) {
        const typeArgs = node.typeArguments.params.map((param) => simplifyType(convertType(param), ctx));
        func = { tag: "typeApp", typeAbs: func, typeArgs, loc: node.loc };
      }
      return { tag: "call", func, args, loc: node.loc };
    }
    case "TSAsExpression":
    case "TSTypeAssertion": {
      if (node.expression.type !== "ObjectExpression") {
        error(`type assertion must be <TYPE>{ tag: "TAG", val: EXPR }`, node);
      }
      const ty = simplifyType(convertType(node.typeAnnotation), ctx);
      const { tag, val } = getTagAndVal(node.expression);
      const term = convertExpr(val, ctx);
      return { tag: "taggedUnionNew", label: tag, term, as: ty, loc: node.loc };
    }
    case "MemberExpression": {