Compiler: remove obsolete dead code

* remove older `ctv_analyser.get_value()` and ancillaries
* remove obsolete `TypeRef.printLiteral2()`

Author: chqrlie

analyser_utils/ctv_analyser.c2

@@ -35,232 +35,9 @@ fn void Limit.init(Limit* l, u32 width, bool is_signed) {
     }
 }
 
-#if 1
 public fn Value get_value(const Expr* e) {
     return ast.evalExpr(e);
 }
-#else
-public fn Value get_value(const Expr* e) {
-    Value result = { }
-
-    if (!e.isCtv()) {
-        e.dump(); // TEMP
-        assert(e.isCtv());
-    }
-
-    switch (e.getKind()) {
-    case IntegerLiteral:
-        const IntegerLiteral* i = (IntegerLiteral*)e;
-        return i.getValue();
-    case FloatLiteral:
-        const FloatLiteral* f = (FloatLiteral*)e;
-        return f.getValue();
-    case BooleanLiteral:
-        const BooleanLiteral* b = (BooleanLiteral*)e;
-        return b.getValue();
-    case CharLiteral:
-        const CharLiteral* c = (CharLiteral*)e;
-        return c.getValue();
-    case StringLiteral:
-        assert(0);
-        break;
-    case Nil:
-        break;
-    case Identifier:
-        const IdentifierExpr* i = (IdentifierExpr*)e;
-        return get_decl_value(i.getDecl());
-    case Type:
-    case Call:
-    case InitList:
-    case FieldDesignatedInit:
-    case ArrayDesignatedInit:
-        // should not happen
-        break;
-    case BinaryOperator:
-        return get_binaryop_value((BinaryOperator*)e);
-    case UnaryOperator:
-        return get_unaryop_value((UnaryOperator*)e);
-    case ConditionalOperator:
-        ConditionalOperator* c = (ConditionalOperator*)e;
-        Value v = get_value(c.getCond());
-        return !v.isZero() ? get_value(c.getLHS()) : get_value(c.getRHS());
-    case Builtin:
-        const BuiltinExpr* bi = (BuiltinExpr*)e;
-        return bi.getValue();
-    case ArraySubscript:  // a[high:low], both included
-        // note: can be CTV if BitOffsetExpr
-        ArraySubscriptExpr* a = (ArraySubscriptExpr*)e;
-
-        result = get_value(a.getBase());
-        // Dont allow negative/float
-        assert(result.isDecimal() && !result.isNegative());
-
-        Expr* index = a.getIndex();
-        assert(index.isBitOffset());
-        BitOffsetExpr* bo = (BitOffsetExpr*)index;
-        Value high = get_value(bo.getLHS());
-        Value low = get_value(bo.getRHS());
-        Value width = high.minus(&low);
-        width.incr();
-        // calculate result = (base >> low) & bitmask(width))
-        result = result.right_shift(&low);
-        result.mask(width.as_u32());
-        break;
-    case Member:
-        const MemberExpr* m = (MemberExpr*)e;
-        return get_decl_value(m.getFullDecl());
-    case Paren:
-        const ParenExpr* p = (ParenExpr*)e;
-        return get_value(p.getInner());
-    case BitOffset:
-        assert(0); // TODO
-        break;
-    case ExplicitCast:
-        const ExplicitCastExpr* i = (ExplicitCastExpr*)e;
-        result = get_value(i.getInner());
-        return result.castAs(e.getType());
-    case ImplicitCast:
-        const ImplicitCastExpr* i = (ImplicitCastExpr*)e;
-        return get_value(i.getInner());
-    case Range:
-        // should not happen
-        break;
-    }
-
-    return result;
-}
-
-fn Value get_decl_value(const Decl* d) {
-    assert(d);
-    switch (d.getKind()) {
-    case EnumConstant:
-        const EnumConstantDecl* ecd = (EnumConstantDecl*)d;
-        return ecd.getValue();
-    case Variable:
-        const VarDecl* vd = (VarDecl*)d;
-        const Expr* initval = vd.getInit();
-        assert(initval);
-        return get_value(initval);
-    default:
-        assert(0);
-        break;
-    }
-    return Value.error("not a constant value");
-}
-
-fn Value get_unaryop_value(const UnaryOperator* e) {
-    Value result = { }
-    const Expr* inner = e.getInner();
-    Value res2 = get_value(inner);
-
-    switch (e.getOpcode()) {
-    case PostInc:
-    case PostDec:
-    case PreInc:
-    case PreDec:
-        // should not happen
-        break;
-    case AddrOf:
-    case Deref:
-        // Allowed?
-        break;
-    case Plus:
-        result = res2;
-        break;
-    case Minus:
-        result = res2.negate();
-        break;
-    case Not:
-        assert(res2.isDecimal()); // TODO give error
-        result = res2.bitnot();
-        break;
-    case LNot:
-        assert(res2.isDecimal()); // TODO give error
-        result = res2.lnot();
-        break;
-    }
-    return result;
-}
-
-fn Value get_binaryop_value(const BinaryOperator* e) {
-    Value result = { }
-    Value left = get_value(e.getLHS());
-    Value right = get_value(e.getRHS());
-
-    switch (e.getOpcode()) {
-    case Multiply:
-        result = left.multiply(&right);
-        break;
-    case Divide:
-        // Note: should already be checked!
-        result = left.divide(&right);
-        break;
-    case Remainder:
-        // Note: should already be checked!
-        result = left.remainder(&right);
-        break;
-    case Add:
-        result = left.add(&right);
-        break;
-    case Subtract:
-        result = left.minus(&right);
-        break;
-    case ShiftLeft:
-        // Note: neither may be negative, should already be checked
-        // TODO warn about overflow
-        // TODO fix
-        result = left.left_shift(&right);
-        break;
-    case ShiftRight:
-        // Note: neither may be negative, should already be checked
-        // Note: rhs value should be less than bitwidth of lhs type, should already be checked
-        // TODO fix
-        result = left.right_shift(&right);
-        break;
-    case LessThan:
-        return Value.createBool(left.is_less(&right));
-    case GreaterThan:
-        return Value.createBool(left.is_greater(&right));
-    case LessEqual:
-        return Value.createBool(left.is_less_equal(&right));
-    case GreaterEqual:
-        return Value.createBool(left.is_greater_equal(&right));
-    case Equal:
-        return Value.createBool(left.is_equal(&right));
-    case NotEqual:
-        return Value.createBool(!left.is_equal(&right));
-    case And:
-        result = left.and(&right);
-        break;
-    case Xor:
-        result = left.xor(&right);
-        break;
-    case Or:
-        result = left.or(&right);
-        break;
-    case LAnd:
-        result = left.land(&right);
-        break;
-    case LOr:
-        result = left.lor(&right);
-        break;
-    case Assign:
-    case MulAssign:
-    case DivAssign:
-    case RemAssign:
-    case AddAssign:
-    case SubAssign:
-    case ShlAssign:
-    case ShrAssign:
-    case AndAssign:
-    case XorAssign:
-    case OrAssign:
-        assert(0);
-        break;
-    }
-    return result;
-}
-#endif
 
 public fn bool check(diagnostics.Diags* diags, QualType qt, const Expr* e) {
     QualType canon = qt.getCanonicalType();

ast/type_ref.c2

@@ -444,45 +444,6 @@ fn void TypeRef.printLiteral(const TypeRef* r, string_buffer.Buf* out, bool prin
     }
 }
 
-#if 0
-public type ExprPrinter fn void(void* arg, const Expr* e, string_buffer.Buf* out);
-
-// Prints arrays as arrays
-public fn void TypeRef.printLiteral2(const TypeRef* r, string_buffer.Buf* out, bool print_prefix, ExprPrinter print_expr, void* arg) {
-    if (r.isConst()) out.add("const ");
-    if (r.isVolatile()) out.add("volatile ");
-
-    if (r.flags.is_user) {
-        Decl* d = r.refs[0].decl;
-        assert(d);
-        if (print_prefix) {
-            out.add(d.getFullName());
-        } else {
-            out.add(d.getName());
-        }
-    } else {
-        out.add(builtinType_names[r.flags.builtin_kind]);
-    }
-
-    for (u32 i=0; i<r.flags.num_ptrs; i++) out.add1('*');
-
-    if (r.flags.incr_array) out.add("[+]");
-
-    for (u32 i=0; i<r.flags.num_arrays; i++) {
-        out.add1('[');
-        const Expr* a = r.getArray(i);
-        // note: a can be nil, when[]
-        if (a) {
-            if (print_expr)
-                print_expr(arg, a, out);
-            else
-                a.printLiteral(out);
-        }
-        out.add1(']');
-    }
-}
-#endif
-
 fn void TypeRef.print(const TypeRef* r, string_buffer.Buf* out, bool filled) {
     // eg. const test.Foo*[10]
 

generator/c/c_generator_pure_call.c2

@@ -51,7 +51,6 @@ fn void Evaluator.check(Evaluator* eval, FunctionDecl* fd, u32 num, Expr** args)
     eval.result = eval.get_value(r.getValue());
 }
 
-// TODO duplicate code with ctv_analyser!
 fn Value Evaluator.get_value(Evaluator* eval, const Expr* e) {
     Value result = { };