Method emitCondExpr

source/python.js:16964–17054

(expr)

                this.emitIfElseBlocks(stmt.range(), cond_value, stmt.body, stmt.orelse);
            }
            emitCondExpr(expr) {
                /*
                switch (expr.kind()) {
                    case TK_AND:
                    case TK_OR: {
                      const binop = BinOp(expr);
                      return emitShortCircuitLogical(
                          binop.range(), binop.lhs(), binop.rhs(), expr.kind() == TK_OR);
                    }
                    case TK_NOT: {
                      CondValue v = emitCondExpr(Expr(expr.tree().trees()[0]));
                      Value* result = emitBuiltinCall(
                          expr.range(), *graph, aten::__not__, {v.value()}, {});
                      std::optional<bool> static_if;
                      if (v.staticIf()) {
                        static_if = !*v.staticIf();
                      }
                      return CondValue(result, v.refinements().Not(), static_if);
                    } break;
                    case TK_IS:
                    case TK_ISNOT: {
                      // meta programming on AST for is/is not cases and emit branches base on
                      const cond_op = BinOp(expr);
                      Value* lhs_val = emitExpr(cond_op.lhs());
                      Value* rhs_val = emitExpr(cond_op.rhs());
                      const lhs_none = canBeNone(lhs_val);
                      const rhs_none = canBeNone(rhs_val);
                      // Dispatch logic (A: ALWAYS, N: NEVER, M: MAYBE):
                      // AA, -> statically IS always holds, IS_NOT never holds
                      // AN , NA-> statically IS_NOT always holds, IS never holds
                      // MA, MM, MN, NM, NN, AM -> cannot prove anything statically
                      bool its_is = expr.kind() == TK_IS;
                      if (lhs_none == ALWAYS && rhs_none == ALWAYS) {
                        return CondValue(*graph, expr.range(), its_is, {});
                      } else if (
                          (lhs_none == ALWAYS && rhs_none == NEVER) ||
                          (lhs_none == NEVER && rhs_none == ALWAYS)) {
                        // lhs_val/rhs_val with A/M: only emit never_none_branch
                        return CondValue(*graph, expr.range(), !its_is, {});
                      } else {
                        const kind = getNodeKind(expr.kind(), expr.get()->trees().size());
                        Value* cond_value = emitBuiltinCall(
                            expr.get()->range(),
                            *method.graph(),
                            kind,
                            {lhs_val, rhs_val},
                            {});
                        const refinements = RefinementSet(findIsNoneRefinements(
                            cond_op.lhs(), lhs_val, cond_op.rhs(), rhs_val, expr.kind()));
                        return CondValue(cond_value, refinements, null);
                      }
                    } break;
                */
                if (expr instanceof ast.UnaryOp) {
                    throw new python.Error('Not implemented.');
                }
                if (expr instanceof ast.Call) {
                    const apply = expr;