LAL: unify arithmetic operators (+ - * /) with JLS-style type promotion (#13858)

Author: wu-sheng

docs/en/changes/changes.md

@@ -96,8 +96,8 @@
 * Fix: potential unexpected current directory inclusion in Docker OAP classpath.
 * MAL: add `safeDiv(divisor)` on `SampleFamily` that yields `0` when the divisor is `0` instead of `Infinity`/`NaN`. Replace `/` with `safeDiv(...)` in Envoy AI Gateway latency-average rules so `sum / count * 1000` no longer produces dropped or out-of-range samples when a counter is zero in a window.
 * Fix: `envoy-ai-gateway` metrics rules, make the metrics value return `0` when the divisor is `0`.
-* Fix: LAL compiler treated `(tag("x") as Integer) + (tag("y") as Integer)` as string concatenation instead of numeric addition. Expressions like `input_tokens + output_tokens < 10000` produced the concatenated string `"2589115"` rather than the integer sum `2704`, so token-threshold conditions never triggered `abort {}`. The compiler now detects all-numeric operands (cast to `Integer` or `Long`) and emits proper `long` arithmetic.
 * Custom `Layer`s can be declared without modifying the OAP source — via an operator-managed `layer-extensions.yml`, inline `layerDefinitions:` block in a MAL or LAL rule file, or a plugin extension. UI dashboard templates for new layers are auto-discovered from the `ui-initialized-templates/` directory. Recommended ordinal range for external layers is `>= 1000`; conflicting names or ordinals are reported at boot.
+* LAL: support full arithmetic (`+`, `-`, `*`, `/`) on numeric operands and fix the original bug where `(tag("x") as Integer) + (tag("y") as Integer)` was treated as string concatenation — expressions like `input_tokens + output_tokens < 10000` produced the concatenated string `"2589115"` rather than the integer sum `2704`, so token-threshold conditions never triggered `abort {}`. Operand types are now inferred from explicit casts (`as Integer` / `as Long` / `as Float` / `as Double`), typed proto fields, or numeric literal shape (with `L` / `F` / `D` suffix support, e.g. `1000L`). The compiler honours JLS-style binary numeric promotion and emits Java arithmetic in the declared primitive type — `(x as Integer) + (y as Integer)` compiles to `int + int` (not widened to `long`). `+` with any String operand falls back to string concatenation; `-` / `*` / `/` against non-numeric operands produces a compile-time error. The `as Double` and `as Float` casts are accepted in `typeCast` clauses, including in `def` declarations. Numeric comparisons honour declared casts on both sides (no more universal `h.toLong()` wrapper).
 
 #### UI
 * Add mobile menu icon and i18n labels for the iOS layer.

oap-server/analyzer/log-analyzer/src/main/antlr4/org/apache/skywalking/lal/rt/grammar/LALLexer.g4

@@ -66,6 +66,8 @@ AS:            'as';
 STRING_TYPE:   'String';
 LONG_TYPE:     'Long';
 INTEGER_TYPE:  'Integer';
+DOUBLE_TYPE:   'Double';
+FLOAT_TYPE:    'Float';
 BOOLEAN_TYPE:  'Boolean';
 
 // Keywords - built-in references
@@ -111,8 +113,17 @@ TRUE:          'true';
 FALSE:         'false';
 NULL:          'null';
 
+// Numeric literal. Suffix rules mirror Java:
+//   * `L` / `l` is valid only on integer literals (no decimal, no exponent).
+//   * `F` / `f` and `D` / `d` are valid on any form.
+// Bare integer literals (no suffix, no decimal, no exponent) are interpreted as int
+// by the compiler if they fit, otherwise long. Bare decimal/exponent literals are
+// double unless suffixed.
 NUMBER
-    : Digit+ ('.' Digit+)?
+    : Digit+ '.' Digit+ ([eE] [+\-]? Digit+)? [FfDd]?
+    | Digit+ [eE] [+\-]? Digit+ [FfDd]?
+    | '.' Digit+ ([eE] [+\-]? Digit+)? [FfDd]?
+    | Digit+ [LlFfDd]?
     ;
 
 // String literal: single or double quoted

oap-server/analyzer/log-analyzer/src/main/antlr4/org/apache/skywalking/lal/rt/grammar/LALParser.g4

@@ -321,8 +321,19 @@ conditionExpr
 //   tag("LOG_KIND")
 //   ProcessRegistry.generateVirtualLocalProcess(...)
 
+// Arithmetic / string-concat expressions.  Operator precedence: * / bind tighter than + -.
+// All four operators share the same flattened model in the AST: each level produces a
+// list of operands plus a list of operators (size N-1).
 valueAccess
-    : valueAccessTerm (PLUS valueAccessTerm)*
+    : valueAccessAdd
+    ;
+
+valueAccessAdd
+    : valueAccessMul ((PLUS | MINUS) valueAccessMul)*
+    ;
+
+valueAccessMul
+    : valueAccessTerm ((STAR | SLASH) valueAccessTerm)*
     ;
 
 valueAccessTerm
@@ -374,7 +385,7 @@ functionArg
 // ==================== Type cast ====================
 
 typeCast
-    : AS (STRING_TYPE | LONG_TYPE | INTEGER_TYPE | BOOLEAN_TYPE | qualifiedName)
+    : AS (STRING_TYPE | LONG_TYPE | INTEGER_TYPE | DOUBLE_TYPE | FLOAT_TYPE | BOOLEAN_TYPE | qualifiedName)
     ;
 
 qualifiedName

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALDefCodegen.java

@@ -148,12 +148,51 @@ static void generateDefStatement(final StringBuilder sb,
             });
         }
 
-        // Emit assignment in body (at the point where def appears)
+        // Emit assignment in body (at the point where def appears).
+        // For built-in scalar casts the initialiser usually returns String
+        // or Object (e.g. tag() returns String), so a plain Java cast would
+        // throw ClassCastException at runtime. Route through the runtime
+        // helper which performs the proper conversion. FQCN casts still use
+        // a direct Java cast — those name a concrete type the caller knows
+        // the initialiser already produces.
         sb.append("  ").append(javaVar).append(" = ");
         if (castType != null && !castType.isEmpty()) {
-            sb.append("(").append(resolvedType.getName()).append(") ");
+            final String conversion = scalarCastConversion(castType, initExpr);
+            if (conversion != null) {
+                sb.append(conversion);
+            } else {
+                sb.append("(").append(resolvedType.getName()).append(") ").append(initExpr);
+            }
+        } else {
+            sb.append(initExpr);
+        }
+        sb.append(";\n");
+    }
+
+    /**
+     * Render the boxed runtime-helper conversion for a scalar cast type
+     * (e.g. {@code Long.valueOf(h.toLong(<init>))}). Returns {@code null}
+     * for FQCN / unknown cast types so the caller can fall back to a
+     * direct Java cast.
+     */
+    private static String scalarCastConversion(final String castType,
+                                                 final CharSequence init) {
+        switch (castType) {
+            case "String":
+                return "h.toStr(" + init + ")";
+            case "Long":
+                return "Long.valueOf(h.toLong(" + init + "))";
+            case "Integer":
+                return "Integer.valueOf(h.toInt(" + init + "))";
+            case "Double":
+                return "Double.valueOf(h.toDouble(" + init + "))";
+            case "Float":
+                return "Float.valueOf(h.toFloat(" + init + "))";
+            case "Boolean":
+                return "Boolean.valueOf(h.toBool(" + init + "))";
+            default:
+                return null;
         }
-        sb.append(initExpr).append(";\n");
     }
 
     /**
@@ -169,6 +208,10 @@ private static Class<?> resolveDefCastType(final String castType) {
                 return Long.class;
             case "Integer":
                 return Integer.class;
+            case "Double":
+                return Double.class;
+            case "Float":
+                return Float.class;
             case "Boolean":
                 return Boolean.class;
             default:

oap-server/analyzer/log-analyzer/src/main/java/org/apache/skywalking/oap/log/analyzer/v2/compiler/LALScriptModel.java

@@ -347,6 +347,32 @@ public ExprCondition(final ValueAccess expr, final String castType) {
 
     // ==================== Value access ====================
 
+    /**
+     * Binary arithmetic / concat operator joining adjacent {@code concatParts}.
+     * The list of operators aligns with the gaps between parts: for N parts there
+     * are N-1 operators, where {@code concatOps[i]} joins {@code concatParts[i]}
+     * and {@code concatParts[i + 1]}.  Precedence is already encoded by the parser
+     * (mul-level expressions sit inside add-level parts). The {@code symbol}
+     * field carries the Java source token so the codegen doesn't need a parallel
+     * switch.
+     */
+    public enum BinaryOp {
+        PLUS("+"),
+        MINUS("-"),
+        STAR("*"),
+        SLASH("/");
+
+        private final String symbol;
+
+        BinaryOp(final String symbol) {
+            this.symbol = symbol;
+        }
+
+        public String symbol() {
+            return symbol;
+        }
+    }
+
     @Getter
     public static final class ValueAccess {
         private final List<String> segments;
@@ -359,6 +385,7 @@ public static final class ValueAccess {
         private final String functionCallName;
         private final List<FunctionArg> functionCallArgs;
         private final List<ValueAccess> concatParts;
+        private final List<BinaryOp> concatOps;
         private final ValueAccess parenInner;
         private final String parenCast;
 
@@ -368,7 +395,7 @@ public ValueAccess(final List<String> segments,
                            final List<ValueAccessSegment> chain) {
             this(segments, parsedRef, logRef, false, false, false,
                 chain, null, Collections.emptyList(),
-                Collections.emptyList(), null, null);
+                Collections.emptyList(), Collections.emptyList(), null, null);
         }
 
         public ValueAccess(final List<String> segments,
@@ -383,7 +410,26 @@ public ValueAccess(final List<String> segments,
             this(segments, parsedRef, logRef, processRegistryRef,
                 stringLiteral, numberLiteral, chain,
                 functionCallName, functionCallArgs,
-                Collections.emptyList(), null, null);
+                Collections.emptyList(), Collections.emptyList(), null, null);
+        }
+
+        public ValueAccess(final List<String> segments,
+                           final boolean parsedRef,
+                           final boolean logRef,
+                           final boolean processRegistryRef,
+                           final boolean stringLiteral,
+                           final boolean numberLiteral,
+                           final List<ValueAccessSegment> chain,
+                           final String functionCallName,
+                           final List<FunctionArg> functionCallArgs,
+                           final List<ValueAccess> concatParts,
+                           final ValueAccess parenInner,
+                           final String parenCast) {
+            this(segments, parsedRef, logRef, processRegistryRef,
+                stringLiteral, numberLiteral, chain,
+                functionCallName, functionCallArgs,
+                concatParts, defaultPlusOps(concatParts),
+                parenInner, parenCast);
         }
 
         public ValueAccess(final List<String> segments,
@@ -396,6 +442,7 @@ public ValueAccess(final List<String> segments,
                            final String functionCallName,
                            final List<FunctionArg> functionCallArgs,
                            final List<ValueAccess> concatParts,
+                           final List<BinaryOp> concatOps,
                            final ValueAccess parenInner,
                            final String parenCast) {
             this.segments = Collections.unmodifiableList(segments);
@@ -411,13 +458,26 @@ public ValueAccess(final List<String> segments,
                 ? Collections.unmodifiableList(functionCallArgs) : Collections.emptyList();
             this.concatParts = concatParts != null
                 ? Collections.unmodifiableList(concatParts) : Collections.emptyList();
+            this.concatOps = concatOps != null
+                ? Collections.unmodifiableList(concatOps) : Collections.emptyList();
             this.parenInner = parenInner;
             this.parenCast = parenCast;
         }
 
         public String toPathString() {
             return String.join(".", segments);
         }
+
+        private static List<BinaryOp> defaultPlusOps(final List<ValueAccess> parts) {
+            if (parts == null || parts.size() <= 1) {
+                return Collections.emptyList();
+            }
+            final BinaryOp[] ops = new BinaryOp[parts.size() - 1];
+            for (int i = 0; i < ops.length; i++) {
+                ops[i] = BinaryOp.PLUS;
+            }
+            return List.of(ops);
+        }
     }
 
     @Getter
@@ -486,9 +546,22 @@ public StringConditionValue(final String value) {
     @Getter
     public static final class NumberConditionValue implements ConditionValue {
         private final double value;
+        /**
+         * Original literal text from the LAL source (e.g. {@code "10000"},
+         * {@code "10000L"}, {@code "1.5"}, {@code "1e6"}). Codegen uses this
+         * to preserve the user-declared numeric type — a bare {@code 10000}
+         * stays {@code int}, an {@code L}-suffixed literal becomes {@code long},
+         * etc. May be {@code null} for synthesised values.
+         */
+        private final String literal;
 
         public NumberConditionValue(final double value) {
+            this(value, null);
+        }
+
+        public NumberConditionValue(final double value, final String literal) {
             this.value = value;
+            this.literal = literal;
         }
     }