extend type checking to mark extern function call that returns enum a… (

#4941)

* extend type checking to mark extern function call that returns enum as compile time constant

Signed-off-by: Wang, Han2 <[email protected]>

* use @pure to annotate extern function that should be treated as compiled-time constant
update reference output

Signed-off-by: Wang, Han2 <[email protected]>

* address comment

Signed-off-by: Wang, Han2 <[email protected]>

---------

Signed-off-by: Wang, Han2 <[email protected]>

frontends/p4/typeChecking/typeCheckExpr.cpp

@@ -2085,12 +2085,14 @@ const IR::Node *TypeInferenceBase::postorder(const IR::MethodCallExpression *exp
             const IR::Type *baseReturnType = returnType;
             if (const auto *sc = returnType->to<IR::Type_SpecializedCanonical>())
                 baseReturnType = sc->baseType;
-            const bool factoryOrStaticAssert =
-                baseReturnType->is<IR::Type_Extern>() || ef->method->name == "static_assert";
-            if (constArgs && factoryOrStaticAssert) {
+            const bool factoryOrStaticAssertOrPureAnnot =
+                baseReturnType->is<IR::Type_Extern>() || ef->method->name == "static_assert" ||
+                ef->method->getAnnotation(IR::Annotation::pureAnnotation);
+            if (constArgs && factoryOrStaticAssertOrPureAnnot) {
                 // factory extern function calls (those that return extern objects) with constant
                 // args are compile-time constants.
-                // The result of a static_assert call is also a compile-time constant.
+                // The result of a static_assert call is also a compile-time constant
+                // Pure functions marked with @pure annotation is a compiled-time constant
                 setCompileTimeConstant(expression);
                 setCompileTimeConstant(getOriginal<IR::Expression>());
             }

testdata/p4_16_samples/hashext3.p4

@@ -0,0 +1,52 @@
+/*
+Copyright 2024 Intel Corp.
+
+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.
+*/
+
+enum HashAlgorithm_t {
+    IDENTITY,
+    RANDOM
+}
+
+@pure extern HashAlgorithm_t identity_hash(bool msb, bool extend);
+@pure extern HashAlgorithm_t random_hash(bool msb, bool extend);
+
+extern Hash<W> {
+    /// Constructor
+    /// @type_param W : width of the calculated hash.
+    /// @param algo : The default algorithm used for hash calculation.
+    Hash(HashAlgorithm_t algo);
+
+    /// Compute the hash for the given data.
+    /// @param data : The list of fields contributing to the hash.
+    /// @return The hash value.
+    W get<D>(in D data);
+}
+
+header h1_t {
+    bit<32>     f1;
+    bit<32>     f2;
+    bit<32>     f3;
+}
+
+struct hdrs {
+    h1_t        h1;
+    bit<16>     hash;
+}
+
+control test(inout hdrs hdr) {
+    apply {
+        hdr.hash = Hash<bit<16>>(random_hash(false, false)).get(hdr.h1);
+    }
+}

testdata/p4_16_samples_outputs/hashext3-first.p4

@@ -0,0 +1,29 @@
+enum HashAlgorithm_t {
+    IDENTITY,
+    RANDOM
+}
+
+@pure extern HashAlgorithm_t identity_hash(bool msb, bool extend);
+@pure extern HashAlgorithm_t random_hash(bool msb, bool extend);
+extern Hash<W> {
+    Hash(HashAlgorithm_t algo);
+    W get<D>(in D data);
+}
+
+header h1_t {
+    bit<32> f1;
+    bit<32> f2;
+    bit<32> f3;
+}
+
+struct hdrs {
+    h1_t    h1;
+    bit<16> hash;
+}
+
+control test(inout hdrs hdr) {
+    apply {
+        hdr.hash = Hash<bit<16>>(random_hash(false, false)).get<h1_t>(hdr.h1);
+    }
+}
+

testdata/p4_16_samples_outputs/hashext3-frontend.p4

@@ -0,0 +1,23 @@
+enum HashAlgorithm_t {
+    IDENTITY,
+    RANDOM
+}
+
+@pure extern HashAlgorithm_t identity_hash(bool msb, bool extend);
+@pure extern HashAlgorithm_t random_hash(bool msb, bool extend);
+extern Hash<W> {
+    Hash(HashAlgorithm_t algo);
+    W get<D>(in D data);
+}
+
+header h1_t {
+    bit<32> f1;
+    bit<32> f2;
+    bit<32> f3;
+}
+
+struct hdrs {
+    h1_t    h1;
+    bit<16> hash;
+}
+

testdata/p4_16_samples_outputs/hashext3.p4

@@ -0,0 +1,29 @@
+enum HashAlgorithm_t {
+    IDENTITY,
+    RANDOM
+}
+
+@pure extern HashAlgorithm_t identity_hash(bool msb, bool extend);
+@pure extern HashAlgorithm_t random_hash(bool msb, bool extend);
+extern Hash<W> {
+    Hash(HashAlgorithm_t algo);
+    W get<D>(in D data);
+}
+
+header h1_t {
+    bit<32> f1;
+    bit<32> f2;
+    bit<32> f3;
+}
+
+struct hdrs {
+    h1_t    h1;
+    bit<16> hash;
+}
+
+control test(inout hdrs hdr) {
+    apply {
+        hdr.hash = Hash<bit<16>>(random_hash(false, false)).get(hdr.h1);
+    }
+}
+

testdata/p4_16_samples_outputs/hashext3.p4-stderr

@@ -0,0 +1,4 @@
+hashext3.p4(48): [--Wwarn=unused] warning: Control test is not used; removing
+control test(inout hdrs hdr) {
+        ^^^^
+[--Wwarn=missing] warning: Program does not contain a `main' module

testdata/p4_16_samples_outputs/issue4661_pure_extern_function_const_args.p4-stderr

@@ -0,0 +1,3 @@
+issue4661_pure_extern_function_const_args.p4(13): [--Wwarn=mismatch] warning: baz(): constant expression in switch
+        switch(baz()) {
+               ^^^^^