Modify analyzer and optimizer rules to be sync rules.

Author: afoucret

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/Analyzer.java

@@ -212,7 +212,7 @@ protected List<Batch<LogicalPlan>> batches() {
         return RULES;
     }
 
-    private static class ResolveTable extends ParameterizedAnalyzerRule<UnresolvedRelation, AnalyzerContext> {
+    private static class ResolveTable extends ParameterizedAnalyzerRule.Sync<UnresolvedRelation, AnalyzerContext> {
 
         @Override
         protected LogicalPlan rule(UnresolvedRelation plan, AnalyzerContext context) {
@@ -312,7 +312,7 @@ private static void mappingAsAttributes(List<Attribute> list, Source source, Str
         }
     }
 
-    private static class ResolveEnrich extends ParameterizedAnalyzerRule<Enrich, AnalyzerContext> {
+    private static class ResolveEnrich extends ParameterizedAnalyzerRule.Sync<Enrich, AnalyzerContext> {
 
         @Override
         protected LogicalPlan rule(Enrich plan, AnalyzerContext context) {
@@ -398,7 +398,7 @@ private static NamedExpression createEnrichFieldExpression(
         }
     }
 
-    private static class ResolveInference extends ParameterizedAnalyzerRule<InferencePlan<?>, AnalyzerContext> {
+    private static class ResolveInference extends ParameterizedAnalyzerRule.Sync<InferencePlan<?>, AnalyzerContext> {
         @Override
         protected LogicalPlan rule(InferencePlan<?> plan, AnalyzerContext context) {
             assert plan.inferenceId().resolved() && plan.inferenceId().foldable();
@@ -426,7 +426,7 @@ protected LogicalPlan rule(InferencePlan<?> plan, AnalyzerContext context) {
         }
     }
 
-    private static class ResolveLookupTables extends ParameterizedAnalyzerRule<Lookup, AnalyzerContext> {
+    private static class ResolveLookupTables extends ParameterizedAnalyzerRule.Sync<Lookup, AnalyzerContext> {
 
         @Override
         protected LogicalPlan rule(Lookup lookup, AnalyzerContext context) {
@@ -474,7 +474,7 @@ private LocalRelation tableMapAsRelation(Source source, Map<String, Column> mapT
         }
     }
 
-    public static class ResolveRefs extends ParameterizedAnalyzerRule<LogicalPlan, AnalyzerContext> {
+    public static class ResolveRefs extends ParameterizedAnalyzerRule.Sync<LogicalPlan, AnalyzerContext> {
         @Override
         protected LogicalPlan rule(LogicalPlan plan, AnalyzerContext context) {
             if (plan.childrenResolved() == false) {
@@ -1286,7 +1286,7 @@ private static Attribute handleSpecialFields(UnresolvedAttribute u, Attribute na
         return named.withLocation(u.source());
     }
 
-    private static class ResolveFunctions extends ParameterizedAnalyzerRule<LogicalPlan, AnalyzerContext> {
+    private static class ResolveFunctions extends ParameterizedAnalyzerRule.Sync<LogicalPlan, AnalyzerContext> {
 
         @Override
         protected LogicalPlan rule(LogicalPlan plan, AnalyzerContext context) {
@@ -1319,7 +1319,7 @@ public static org.elasticsearch.xpack.esql.core.expression.function.Function res
         }
     }
 
-    private static class AddImplicitLimit extends ParameterizedRule<LogicalPlan, LogicalPlan, AnalyzerContext> {
+    private static class AddImplicitLimit extends ParameterizedRule.Sync<LogicalPlan, LogicalPlan, AnalyzerContext> {
         @Override
         public LogicalPlan apply(LogicalPlan logicalPlan, AnalyzerContext context) {
             List<LogicalPlan> limits = logicalPlan.collectFirstChildren(Limit.class::isInstance);
@@ -1338,7 +1338,7 @@ public LogicalPlan apply(LogicalPlan logicalPlan, AnalyzerContext context) {
         }
     }
 
-    private static class AddImplicitForkLimit extends ParameterizedRule<LogicalPlan, LogicalPlan, AnalyzerContext> {
+    private static class AddImplicitForkLimit extends ParameterizedRule.Sync<LogicalPlan, LogicalPlan, AnalyzerContext> {
         private final AddImplicitLimit addImplicitLimit = new AddImplicitLimit();
 
         @Override
@@ -1386,7 +1386,7 @@ private BitSet gatherPreAnalysisMetrics(LogicalPlan plan, BitSet b) {
      * </ul>
      * Coalesce(Int, Long) will NOT be converted to Coalesce(Long, Long) or Coalesce(Int, Int).
      */
-    private static class ImplicitCasting extends ParameterizedRule<LogicalPlan, LogicalPlan, AnalyzerContext> {
+    private static class ImplicitCasting extends ParameterizedRule.Sync<LogicalPlan, LogicalPlan, AnalyzerContext> {
         @Override
         public LogicalPlan apply(LogicalPlan plan, AnalyzerContext context) {
             // do implicit casting for function arguments
@@ -1634,15 +1634,16 @@ private static Expression processVectorFunction(org.elasticsearch.xpack.esql.cor
     }
 
     /**
-     * The EsqlIndexResolver will create InvalidMappedField instances for fields that are ambiguous (i.e. have multiple mappings).
-     * During {@link ResolveRefs} we do not convert these to UnresolvedAttribute instances, as we want to first determine if they can
-     * instead be handled by conversion functions within the query. This rule looks for matching conversion functions and converts
-     * those fields into MultiTypeEsField, which encapsulates the knowledge of how to convert these into a single type.
-     * This knowledge will be used later in generating the FieldExtractExec with built-in type conversion.
-     * Any fields which could not be resolved by conversion functions will be converted to UnresolvedAttribute instances in a later rule
-     * (See {@link UnionTypesCleanup} below).
+     * {@link ResolveUnionTypes} creates new, synthetic attributes for union types:
+     * If there was no {@code AbstractConvertFunction} that resolved multi-type fields in the {@link ResolveUnionTypes} rule,
+     * then there could still be some {@code FieldAttribute}s that contain unresolved {@link MultiTypeEsField}s.
+     * These need to be converted back to actual {@code UnresolvedAttribute} in order for validation to generate appropriate failures.
+     * <p>
+     * Finally, if {@code client_ip} is present in 2 indices, once with type {@code ip} and once with type {@code keyword},
+     * using {@code EVAL x = to_ip(client_ip)} will create a single attribute @{code $$client_ip$converted_to$ip}.
+     * This should not spill into the query output, so we drop such attributes at the end.
      */
-    private static class ResolveUnionTypes extends Rule<LogicalPlan, LogicalPlan> {
+    private static class ResolveUnionTypes extends Rule.Sync<LogicalPlan, LogicalPlan> {
 
         record TypeResolutionKey(String fieldName, DataType fieldType) {}
 
@@ -1652,6 +1653,7 @@ record TypeResolutionKey(String fieldName, DataType fieldType) {}
         public LogicalPlan apply(LogicalPlan plan) {
             unionFieldAttributes = new ArrayList<>();
             return plan.transformUp(LogicalPlan.class, p -> p.childrenResolved() == false ? p : doRule(p));
+
         }
 
         private LogicalPlan doRule(LogicalPlan plan) {
@@ -1850,7 +1852,7 @@ private static Expression typeSpecificConvert(ConvertFunction convert, Source so
      * using {@code EVAL x = to_ip(client_ip)} will create a single attribute @{code $$client_ip$converted_to$ip}.
      * This should not spill into the query output, so we drop such attributes at the end.
      */
-    private static class UnionTypesCleanup extends Rule<LogicalPlan, LogicalPlan> {
+    private static class UnionTypesCleanup extends Rule.Sync<LogicalPlan, LogicalPlan> {
         public LogicalPlan apply(LogicalPlan plan) {
             LogicalPlan planWithCheckedUnionTypes = plan.transformUp(
                 LogicalPlan.class,
@@ -1898,7 +1900,7 @@ private static LogicalPlan planWithoutSyntheticAttributes(LogicalPlan plan) {
     /**
      * Cast the union typed fields in EsRelation to date_nanos if they are mixed date and date_nanos types.
      */
-    private static class DateMillisToNanosInEsRelation extends Rule<LogicalPlan, LogicalPlan> {
+    private static class DateMillisToNanosInEsRelation extends Rule.Sync<LogicalPlan, LogicalPlan> {
 
         private final boolean isSnapshot;
 

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/analysis/AnalyzerRules.java

@@ -22,51 +22,37 @@
 
 public final class AnalyzerRules {
 
-    public abstract static class AnalyzerRule<SubPlan extends LogicalPlan> extends Rule<SubPlan, LogicalPlan> {
-
-        // transformUp (post-order) - that is first children and then the node
-        // but with a twist; only if the tree is not resolved or analyzed
-        @Override
-        public final LogicalPlan apply(LogicalPlan plan) {
-            return plan.transformUp(typeToken(), t -> t.analyzed() || skipResolved() && t.resolved() ? t : rule(t));
-        }
+    public interface AnalyzerRule<SubPlan extends LogicalPlan> extends Rule<SubPlan, LogicalPlan> {
+        abstract class Sync<SubPlan extends LogicalPlan> extends Rule.Sync<SubPlan, LogicalPlan> {
+            // transformUp (post-order) - that is first children and then the node
+            // but with a twist; only if the tree is not resolved or analyzed
+            @Override
+            public final LogicalPlan apply(LogicalPlan plan) {
+                return plan.transformUp(typeToken(), t -> t.analyzed() || skipResolved() && t.resolved() ? t : rule(t));
+            }
 
-        protected abstract LogicalPlan rule(SubPlan plan);
+            protected abstract LogicalPlan rule(SubPlan plan);
 
-        protected boolean skipResolved() {
-            return true;
+            protected boolean skipResolved() {
+                return true;
+            }
         }
     }
 
-    public abstract static class ParameterizedAnalyzerRule<SubPlan extends LogicalPlan, P> extends ParameterizedRule<
-        SubPlan,
-        LogicalPlan,
-        P> {
-
-        // transformUp (post-order) - that is first children and then the node
-        // but with a twist; only if the tree is not resolved or analyzed
-        public final LogicalPlan apply(LogicalPlan plan, P context) {
-            return plan.transformUp(typeToken(), t -> t.analyzed() || skipResolved() && t.resolved() ? t : rule(t, context));
-        }
-
-        protected abstract LogicalPlan rule(SubPlan plan, P context);
-
-        protected boolean skipResolved() {
-            return true;
-        }
-    }
+    public interface ParameterizedAnalyzerRule<SubPlan extends LogicalPlan, P> extends ParameterizedRule<SubPlan, LogicalPlan, P> {
+        abstract class Sync<SubPlan extends LogicalPlan, P> extends ParameterizedRule.Sync<SubPlan, LogicalPlan, P> {
+            // transformUp (post-order) - that is first children and then the node
+            // but with a twist; only if the tree is not resolved or analyzed
+            public final LogicalPlan apply(LogicalPlan plan, P context) {
+                return plan.transformUp(typeToken(), t -> t.analyzed() || skipResolved() && t.resolved() ? t : rule(t, context));
+            }
 
-    public abstract static class BaseAnalyzerRule extends AnalyzerRule<LogicalPlan> {
+            protected abstract LogicalPlan rule(SubPlan plan, P context);
 
-        @Override
-        protected LogicalPlan rule(LogicalPlan plan) {
-            if (plan.childrenResolved() == false) {
-                return plan;
+            protected boolean skipResolved() {
+                return true;
             }
-            return doRule(plan);
         }
-
-        protected abstract LogicalPlan doRule(LogicalPlan plan);
     }
 
     public static List<Attribute> maybeResolveAgainstList(

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/PhysicalOptimizerRules.java

@@ -7,57 +7,61 @@
 
 package org.elasticsearch.xpack.esql.optimizer;
 
+import org.elasticsearch.xpack.esql.optimizer.rules.logical.OptimizerRules;
 import org.elasticsearch.xpack.esql.optimizer.rules.logical.OptimizerRules.TransformDirection;
 import org.elasticsearch.xpack.esql.plan.physical.PhysicalPlan;
 import org.elasticsearch.xpack.esql.rule.ParameterizedRule;
 import org.elasticsearch.xpack.esql.rule.Rule;
 
 public class PhysicalOptimizerRules {
 
-    public abstract static class ParameterizedOptimizerRule<SubPlan extends PhysicalPlan, P> extends ParameterizedRule<
-        SubPlan,
-        PhysicalPlan,
-        P> {
+    public interface ParameterizedOptimizerRule<SubPlan extends PhysicalPlan, P> extends ParameterizedRule<SubPlan, PhysicalPlan, P> {
+        abstract class Sync<SubPlan extends PhysicalPlan, P> extends ParameterizedRule.Sync<SubPlan, PhysicalPlan, P>
+            implements
+                ParameterizedOptimizerRule<SubPlan, P> {
 
-        private final TransformDirection direction;
+            private final TransformDirection direction;
 
-        public ParameterizedOptimizerRule() {
-            this(TransformDirection.DOWN);
-        }
+            public Sync() {
+                this(OptimizerRules.TransformDirection.DOWN);
+            }
 
-        protected ParameterizedOptimizerRule(TransformDirection direction) {
-            this.direction = direction;
-        }
+            protected Sync(TransformDirection direction) {
+                this.direction = direction;
+            }
 
-        @Override
-        public final PhysicalPlan apply(PhysicalPlan plan, P context) {
-            return direction == TransformDirection.DOWN
-                ? plan.transformDown(typeToken(), t -> rule(t, context))
-                : plan.transformUp(typeToken(), t -> rule(t, context));
-        }
+            @Override
+            public final PhysicalPlan apply(PhysicalPlan plan, P context) {
+                return direction == OptimizerRules.TransformDirection.DOWN
+                    ? plan.transformDown(typeToken(), t -> rule(t, context))
+                    : plan.transformUp(typeToken(), t -> rule(t, context));
+            }
 
-        protected abstract PhysicalPlan rule(SubPlan plan, P context);
+            protected abstract PhysicalPlan rule(SubPlan plan, P context);
+        }
     }
 
-    public abstract static class OptimizerRule<SubPlan extends PhysicalPlan> extends Rule<SubPlan, PhysicalPlan> {
+    public interface OptimizerRule<SubPlan extends PhysicalPlan> extends Rule<SubPlan, PhysicalPlan> {
+        abstract class Sync<SubPlan extends PhysicalPlan> extends Rule.Sync<SubPlan, PhysicalPlan> implements OptimizerRule<SubPlan> {
 
-        private final TransformDirection direction;
+            private final TransformDirection direction;
 
-        public OptimizerRule() {
-            this(TransformDirection.DOWN);
-        }
+            public Sync() {
+                this(OptimizerRules.TransformDirection.DOWN);
+            }
 
-        protected OptimizerRule(TransformDirection direction) {
-            this.direction = direction;
-        }
+            protected Sync(TransformDirection direction) {
+                this.direction = direction;
+            }
 
-        @Override
-        public final PhysicalPlan apply(PhysicalPlan plan) {
-            return direction == TransformDirection.DOWN
-                ? plan.transformDown(typeToken(), this::rule)
-                : plan.transformUp(typeToken(), this::rule);
-        }
+            @Override
+            public final PhysicalPlan apply(PhysicalPlan plan) {
+                return direction == OptimizerRules.TransformDirection.DOWN
+                    ? plan.transformDown(typeToken(), this::rule)
+                    : plan.transformUp(typeToken(), this::rule);
+            }
 
-        protected abstract PhysicalPlan rule(SubPlan plan);
+            protected abstract PhysicalPlan rule(SubPlan plan);
+        }
     }
 }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/BooleanFunctionEqualsElimination.java

@@ -22,7 +22,7 @@
  * This rule must always be placed after {@link LiteralsOnTheRight}
  * since it looks at TRUE/FALSE literals' existence on the right hand-side of the {@link Equals}/{@link NotEquals} expressions.
  */
-public final class BooleanFunctionEqualsElimination extends OptimizerRules.OptimizerExpressionRule<BinaryComparison> {
+public final class BooleanFunctionEqualsElimination extends OptimizerRules.OptimizerExpressionRule.Sync<BinaryComparison> {
 
     public BooleanFunctionEqualsElimination() {
         super(OptimizerRules.TransformDirection.UP);

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/BooleanSimplification.java

@@ -29,7 +29,7 @@
 import static org.elasticsearch.xpack.esql.expression.predicate.Predicates.splitOr;
 import static org.elasticsearch.xpack.esql.expression.predicate.Predicates.subtract;
 
-public final class BooleanSimplification extends OptimizerRules.OptimizerExpressionRule<ScalarFunction> {
+public final class BooleanSimplification extends OptimizerRules.OptimizerExpressionRule.Sync<ScalarFunction> {
 
     public BooleanSimplification() {
         super(OptimizerRules.TransformDirection.UP);

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/CombineBinaryComparisons.java

@@ -26,7 +26,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
-public final class CombineBinaryComparisons extends OptimizerRules.OptimizerExpressionRule<BinaryLogic> {
+public final class CombineBinaryComparisons extends OptimizerRules.OptimizerExpressionRule.Sync<BinaryLogic> {
 
     public CombineBinaryComparisons() {
         super(OptimizerRules.TransformDirection.DOWN);

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/CombineDisjunctions.java

@@ -44,7 +44,7 @@
  * This rule does NOT check for type compatibility as that phase has been
  * already be verified in the analyzer.
  */
-public final class CombineDisjunctions extends OptimizerRules.OptimizerExpressionRule<Or> {
+public final class CombineDisjunctions extends OptimizerRules.OptimizerExpressionRule.Sync<Or> {
     public CombineDisjunctions() {
         super(OptimizerRules.TransformDirection.UP);
     }

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/CombineEvals.java

@@ -15,7 +15,7 @@
  * Combine multiple Evals into one in order to reduce the number of nodes in a plan.
  * TODO: eliminate unnecessary fields inside the eval as well
  */
-public final class CombineEvals extends OptimizerRules.OptimizerRule<Eval> {
+public final class CombineEvals extends OptimizerRules.OptimizerRule.Sync<Eval> {
 
     public CombineEvals() {
         super(OptimizerRules.TransformDirection.UP);

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/CombineProjections.java

@@ -29,7 +29,7 @@
 import java.util.List;
 import java.util.Set;
 
-public final class CombineProjections extends OptimizerRules.OptimizerRule<UnaryPlan> {
+public final class CombineProjections extends OptimizerRules.OptimizerRule.Sync<UnaryPlan> {
     // don't drop groupings from a local plan, as the layout has already been agreed upon
     private final boolean local;
 

x-pack/plugin/esql/src/main/java/org/elasticsearch/xpack/esql/optimizer/rules/logical/ConstantFolding.java

@@ -11,7 +11,7 @@
 import org.elasticsearch.xpack.esql.core.expression.Literal;
 import org.elasticsearch.xpack.esql.optimizer.LogicalOptimizerContext;
 
-public final class ConstantFolding extends OptimizerRules.OptimizerExpressionRule<Expression> {
+public final class ConstantFolding extends OptimizerRules.OptimizerExpressionRule.Sync<Expression> {
 
     public ConstantFolding() {
         super(OptimizerRules.TransformDirection.DOWN);