diff --git a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
index 55dc3a38fd..6cb7f40d62 100644
--- a/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
+++ b/jOOQ/src/main/java/org/jooq/impl/AbstractField.java
@@ -1502,26 +1502,6 @@ abstract class AbstractField<T> extends AbstractTypedNamed<T> implements Field<T
         return DSL.log(numeric(), base);
     }
 
-    @Override
-    public final Field<BigDecimal> pow(Number exponent) {
-        return DSL.power(numeric(), exponent);
-    }
-
-    @Override
-    public final Field<BigDecimal> power(Number exponent) {
-        return pow(exponent);
-    }
-
-    @Override
-    public final Field<BigDecimal> pow(Field<? extends Number> exponent) {
-        return DSL.power(numeric(), exponent);
-    }
-
-    @Override
-    public final Field<BigDecimal> power(Field<? extends Number> exponent) {
-        return pow(exponent);
-    }
-
     @Override
     @Deprecated
     public final Field<BigDecimal> acos() {
diff --git a/jOOQ/src/main/java/org/jooq/impl/BitAnd.java b/jOOQ/src/main/java/org/jooq/impl/BitAnd.java
index 020aabc413..be72809a78 100644
--- a/jOOQ/src/main/java/org/jooq/impl/BitAnd.java
+++ b/jOOQ/src/main/java/org/jooq/impl/BitAnd.java
@@ -112,10 +112,9 @@ extends
 
             default:
                 ctx.sql('(');
-                Expression.acceptAssociative(
+                Expression.<Field<T>, BitAnd<T>>acceptAssociative(
                     ctx,
                     this,
-                    BitAnd.class,
                     q -> new Expression.Expr<>(q.arg1, Operators.OP_AMP, q.arg2),
                     c -> c.sql(' ')
                 );
diff --git a/jOOQ/src/main/java/org/jooq/impl/BitOr.java b/jOOQ/src/main/java/org/jooq/impl/BitOr.java
index c65fc44639..a7bccc88e0 100644
--- a/jOOQ/src/main/java/org/jooq/impl/BitOr.java
+++ b/jOOQ/src/main/java/org/jooq/impl/BitOr.java
@@ -117,10 +117,9 @@ extends
 
             default:
                 ctx.sql('(');
-                Expression.acceptAssociative(
+                Expression.<Field<T>, BitOr<T>>acceptAssociative(
                     ctx,
                     this,
-                    BitOr.class,
                     q -> new Expression.Expr<>(q.arg1, Operators.OP_VERBAR, q.arg2),
                     c -> c.sql(' ')
                 );
diff --git a/jOOQ/src/main/java/org/jooq/impl/BitXor.java b/jOOQ/src/main/java/org/jooq/impl/BitXor.java
index 010ffee699..8c0aa4ff44 100644
--- a/jOOQ/src/main/java/org/jooq/impl/BitXor.java
+++ b/jOOQ/src/main/java/org/jooq/impl/BitXor.java
@@ -121,10 +121,9 @@ extends
             default:
                 ctx.sql('(');
                 SQL op = Expression.HASH_OP_FOR_BIT_XOR.contains(ctx.dialect()) ? Operators.OP_NUM : Operators.OP_HAT;
-                Expression.acceptAssociative(
+                Expression.<Field<T>, BitXor<T>>acceptAssociative(
                     ctx,
                     this,
-                    BitXor.class,
                     q -> new Expression.Expr<>(q.arg1, op, q.arg2),
                     c -> c.sql(' ')
                 );
diff --git a/jOOQ/src/main/java/org/jooq/impl/CombinedCondition.java b/jOOQ/src/main/java/org/jooq/impl/CombinedCondition.java
index ada4df54ba..305ad1a402 100644
--- a/jOOQ/src/main/java/org/jooq/impl/CombinedCondition.java
+++ b/jOOQ/src/main/java/org/jooq/impl/CombinedCondition.java
@@ -154,10 +154,9 @@ final class CombinedCondition extends AbstractCondition {
 
         {
             ctx.sqlIndentStart('(');
-            Expression.acceptAssociative(
+            Expression.<Condition, CombinedCondition>acceptAssociative(
                 ctx,
                 this,
-                CombinedCondition.class,
                 q -> new Expr<>(q.op1, q.operator.toKeyword(), q.op2),
                 Context::formatSeparator
             );
diff --git a/jOOQ/src/main/java/org/jooq/impl/Expression.java b/jOOQ/src/main/java/org/jooq/impl/Expression.java
index 7b5529bb65..8df39125c6 100644
--- a/jOOQ/src/main/java/org/jooq/impl/Expression.java
+++ b/jOOQ/src/main/java/org/jooq/impl/Expression.java
@@ -894,16 +894,17 @@ final class Expression<T> extends AbstractTransformable<T> {
         }
     }
 
-    static final /* record */ class Expr<Q> { private final Q lhs; private final QueryPart op; private final Q rhs; public Expr(Q lhs, QueryPart op, Q rhs) { this.lhs = lhs; this.op = op; this.rhs = rhs; } public Q lhs() { return lhs; } public QueryPart op() { return op; } public Q rhs() { return rhs; } @Override public boolean equals(Object o) { if (!(o instanceof Expr)) return false; Expr other = (Expr) o; if (!java.util.Objects.equals(this.lhs, other.lhs)) return false; if (!java.util.Objects.equals(this.op, other.op)) return false; if (!java.util.Objects.equals(this.rhs, other.rhs)) return false; return true; } @Override public int hashCode() { return java.util.Objects.hash(this.lhs, this.op, this.rhs); } @Override public String toString() { return new StringBuilder("Expr[").append("lhs=").append(this.lhs).append(", op=").append(this.op).append(", rhs=").append(this.rhs).append("]").toString(); } }
+    static final /* record */ class Expr<Q extends QueryPart> { private final Q lhs; private final QueryPart op; private final Q rhs; public Expr(Q lhs, QueryPart op, Q rhs) { this.lhs = lhs; this.op = op; this.rhs = rhs; } public Q lhs() { return lhs; } public QueryPart op() { return op; } public Q rhs() { return rhs; } @Override public boolean equals(Object o) { if (!(o instanceof Expr)) return false; Expr other = (Expr) o; if (!java.util.Objects.equals(this.lhs, other.lhs)) return false; if (!java.util.Objects.equals(this.op, other.op)) return false; if (!java.util.Objects.equals(this.rhs, other.rhs)) return false; return true; } @Override public int hashCode() { return java.util.Objects.hash(this.lhs, this.op, this.rhs); } @Override public String toString() { return new StringBuilder("Expr[").append("lhs=").append(this.lhs).append(", op=").append(this.op).append(", rhs=").append(this.rhs).append("]").toString(); } }
 
+    @SuppressWarnings("unchecked")
     static final <Q1 extends QueryPart, Q2 extends Q1> void acceptAssociative(
         Context<?> ctx,
         Q2 exp,
-        Class<Q2> expType,
         Function<? super Q2, ? extends Expr<Q1>> expProvider,
         Consumer<? super Context<?>> formatSeparator
     ) {
         Expr<Q1> e = expProvider.apply(exp);
+        Class<Q2> expType = (Class<Q2>) exp.getClass();
 
         // [#10665] Associativity is only given for two operands of the same data type
         boolean associativity = e.lhs instanceof Typed && e.rhs instanceof Typed
@@ -931,7 +932,7 @@ final class Expression<T> extends AbstractTransformable<T> {
             Expr<Q1> exp = expProvider.apply((Q2) q);
 
             if (op.equals(exp.op)) {
-                acceptAssociative(ctx, (Q2) q, expType, expProvider, formatSeparator);
+                acceptAssociative(ctx, (Q2) q, expProvider, formatSeparator);
                 return;
             }
         }