Fix #5042: Allow non-constant args for directionless action params

Signed-off-by: devalgupta404 <devalgupta4@gmail.com>

Author: devalgupta404

frontends/p4/typeChecking/typeCheckExpr.cpp

@@ -1893,15 +1893,8 @@ const IR::Expression *TypeInferenceBase::actionCall(bool inActionList,
                 typeError("%1%: parameter %2% cannot be bound: it is set by the control plane", arg,
                           param);
             } else if (inTable) {
-                // For actions None parameters are treated as IN
-                // parameters when the action is called directly.  We
-                // don't require them to be bound to a compile-time
-                // constant.  But if the action is instantiated in a
-                // table (as default_action or entries), then the
-                // arguments do have to be compile-time constants.
-                if (!isCompileTimeConstant(arg->expression))
-                    typeError("%1%: action argument must be a compile-time constant",
-                              arg->expression);
+                // Directionless action parameters behave like 'in'
+                // parameters even when used in tables (P4 Spec Section 6.8).
             }
             // This is like an assignment; may make additional conversions.
             newExpr = assignment(arg, param->type, arg->expression);

testdata/p4_16_samples/issue5042.p4

@@ -0,0 +1,85 @@
+/*
+Copyright 2026 Deval Gupta
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+/*
+ * Test for issue #5042: Directionless action parameters should accept
+ * non-compile-time-known values when provided by the P4 program.
+ * Per P4 Spec Section 6.8, such parameters behave as 'in' direction.
+ */
+
+#include <core.p4>
+#include <v1model.p4>
+
+header h_t {
+    bit<8> f;
+}
+
+struct metadata_t {
+    bit<8> x;
+}
+
+struct headers_t {
+    h_t h;
+}
+
+parser p(packet_in pkt, out headers_t hdr, inout metadata_t meta,
+         inout standard_metadata_t std_meta) {
+    state start {
+        pkt.extract(hdr.h);
+        meta.x = hdr.h.f;
+        transition accept;
+    }
+}
+
+control ingress(inout headers_t hdr, inout metadata_t meta,
+                inout standard_metadata_t std_meta) {
+    // Action with directionless parameter 'data'
+    action a(bit<8> data) {
+        hdr.h.f = data;
+    }
+
+    table t {
+        key = { hdr.h.f : exact; }
+        actions = { a; }
+        // meta.x is NOT compile-time known, but per P4 Spec 6.8
+        // directionless params behave as 'in' when provided by program
+        default_action = a(meta.x);
+    }
+
+    apply {
+        t.apply();
+    }
+}
+
+control egress(inout headers_t hdr, inout metadata_t meta,
+               inout standard_metadata_t std_meta) {
+    apply { }
+}
+
+control deparser(packet_out pkt, in headers_t hdr) {
+    apply { pkt.emit(hdr.h); }
+}
+
+control verifyChecksum(inout headers_t hdr, inout metadata_t meta) {
+    apply { }
+}
+
+control computeChecksum(inout headers_t hdr, inout metadata_t meta) {
+    apply { }
+}
+
+V1Switch(p(), verifyChecksum(), ingress(), egress(),
+         computeChecksum(), deparser()) main;