p4lang · ChrisDodd · Jul 10, 2025 · Jul 10, 2025
diff --git a/frontends/p4/typeChecking/typeChecker.cpp b/frontends/p4/typeChecking/typeChecker.cpp
@@ -81,7 +81,7 @@ const IR::Type *TypeInferenceBase::cloneWithFreshTypeVariables(const IR::IMayBeG
         BUG_CHECK(b, "%1%: failed replacing %2% with %3%", type, v, tv);
     }
 
-    TypeVariableSubstitutionVisitor sv(&tvs, true);
+    TypeVariableSubstitutionVisitor sv(&tvs, true, true);
     sv.setCalledBy(this);
     auto cl = type->to<IR::Type>()->apply(sv, getChildContext());
     CHECK_NULL(cl);

diff --git a/frontends/p4/typeChecking/typeInference.cpp b/frontends/p4/typeChecking/typeInference.cpp
@@ -12,6 +12,7 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
+#include "ir/dump.h"
 #include "typeChecker.h"
 
 namespace P4 {
@@ -143,6 +144,7 @@ DEFINE_POSTORDER(IR::Annotation)
 Visitor::profile_t TypeInference::init_apply(const IR::Node *node) {
     auto rv = Transform::init_apply(node);
     TypeInferenceBase::start(node);
+    LOG5(Dump(node));
 
     return rv;
 }

diff --git a/frontends/p4/typeChecking/typeSubstitution.h b/frontends/p4/typeChecking/typeSubstitution.h
@@ -62,7 +62,7 @@ class TypeSubstitution : public IHasDbPrint {
         bool first = true;
         for (auto it : binding) {
             if (!first) out << std::endl;
-            out << dbp(it.first) << " " << it.first << " -> " << dbp(it.second) << " " << it.second;
+            out << dbp(it.first) << " -> " << dbp(it.second);
             first = false;
         }
     }

diff --git a/frontends/p4/typeChecking/typeSubstitutionVisitor.h b/frontends/p4/typeChecking/typeSubstitutionVisitor.h
@@ -45,15 +45,17 @@ class TypeOccursVisitor : public Inspector {
 class TypeVariableSubstitutionVisitor : public Transform {
  protected:
     const TypeVariableSubstitution *bindings;
-    bool replace;  // If true variables that map to variables are just replaced
-                   // in the TypeParameterList of the replaced object; else they
-                   // are removed.
+    bool replace;      // If true variables that map to variables are just replaced
+                       // in the TypeParameterList of the replaced object; else they
+                       // are removed.
+    bool cloneInfInt;  // If true, ensure that Type_InfInt nodes are replaced with
+                       // new ones as fresh type variables
     const IR::Node *replacement(const IR::ITypeVar *original, const IR::Node *node);
 
  public:
     explicit TypeVariableSubstitutionVisitor(const TypeVariableSubstitution *bindings,
-                                             bool replace = false)
-        : bindings(bindings), replace(replace) {
+                                             bool replace = false, bool cloneInfInt = false)
+        : bindings(bindings), replace(replace), cloneInfInt(cloneInfInt) {
         setName("TypeVariableSubstitution");
     }
 
@@ -65,7 +67,8 @@ class TypeVariableSubstitutionVisitor : public Transform {
         return replacement(getOriginal<IR::Type_Var>(), tv);
     }
     const IR::Node *preorder(IR::Type_InfInt *ti) override {
-        return replacement(getOriginal<IR::Type_InfInt>(), ti);
+        const auto *n = cloneInfInt ? IR::Type_InfInt::get() : ti;
+        return replacement(getOriginal<IR::Type_InfInt>(), n);
     }
 };
 

diff --git a/ir/node.cpp b/ir/node.cpp
@@ -85,9 +85,9 @@ cstring IR::dbp(const IR::INode *node) {
         } else if (node->is<IR::PathExpression>() || node->is<IR::Path>() ||
                    node->is<IR::TypeNameExpression>() || node->is<IR::Constant>() ||
                    node->is<IR::Type_Name>() || node->is<IR::Type_Base>() ||
-                   node->is<IR::Type_Specialized>()) {
+                   node->is<IR::ITypeVar>() || node->is<IR::Type_Specialized>()) {
             node->getNode()->Node::dbprint(str);
-            str << " " << node->toString();
+            str << " " << node->getNode();
         } else {
             node->getNode()->Node::dbprint(str);
         }

diff --git a/testdata/p4_16_errors_outputs/issue3273.p4-stderr b/testdata/p4_16_errors_outputs/issue3273.p4-stderr
@@ -1,3 +1,7 @@
 issue3273.p4(3): [--Werror=type-error] error: int: illegal return type for method
     abstract int f();
              ^^^
+[--Werror=type-error] error: int: illegal return type for method
+issue3273.p4(1): [--Werror=type-error] error: Error while analyzing e
+extern e {
+       ^
diff --git a/testdata/p4_16_samples/extern-int-arg1.p4 b/testdata/p4_16_samples/extern-int-arg1.p4
@@ -0,0 +1,45 @@
+#include <core.p4>
+
+control generic<M>(inout M m);
+package top<M>(generic<M> c);
+
+header h1_t {
+    bit<32>     f1;
+    bit<16>     h1;
+    bit<8>      b1;
+    bit<8>      cnt;
+}
+
+struct headers_t {
+    h1_t        head;
+}
+
+extern Counter {
+    Counter(int size);
+    void count(int idx);
+}
+
+control c(inout headers_t hdrs) {
+    Counter(256) ctr;
+
+    action a0() {
+        ctr.count(0);
+    }
+    action a1(bit<8> idx) {
+        ctr.count(idx);
+    }
+    action a2(bit<4> idx) {
+        ctr.count(idx);
+    }
+
+    table t1 {
+        key = { hdrs.head.f1 : exact; }
+        actions = { a0; a1; a2; }
+    }
+
+    apply {
+        t1.apply();
+    }
+}
+
+top(c()) main;
diff --git a/testdata/p4_16_samples_outputs/extern-int-arg1-first.p4 b/testdata/p4_16_samples_outputs/extern-int-arg1-first.p4
@@ -0,0 +1,49 @@
+#include <core.p4>
+
+control generic<M>(inout M m);
+package top<M>(generic<M> c);
+header h1_t {
+    bit<32> f1;
+    bit<16> h1;
+    bit<8>  b1;
+    bit<8>  cnt;
+}
+
+struct headers_t {
+    h1_t head;
+}
+
+extern Counter {
+    Counter(int size);
+    void count(int idx);
+}
+
+control c(inout headers_t hdrs) {
+    Counter(256) ctr;
+    action a0() {
+        ctr.count(0);
+    }
+    action a1(bit<8> idx) {
+        ctr.count(idx);
+    }
+    action a2(bit<4> idx) {
+        ctr.count(idx);
+    }
+    table t1 {
+        key = {
+            hdrs.head.f1: exact @name("hdrs.head.f1");
+        }
+        actions = {
+            a0();
+            a1();
+            a2();
+            @defaultonly NoAction();
+        }
+        default_action = NoAction();
+    }
+    apply {
+        t1.apply();
+    }
+}
+
+top<headers_t>(c()) main;
diff --git a/testdata/p4_16_samples_outputs/extern-int-arg1-frontend.p4 b/testdata/p4_16_samples_outputs/extern-int-arg1-frontend.p4
@@ -0,0 +1,51 @@
+#include <core.p4>
+
+control generic<M>(inout M m);
+package top<M>(generic<M> c);
+header h1_t {
+    bit<32> f1;
+    bit<16> h1;
+    bit<8>  b1;
+    bit<8>  cnt;
+}
+
+struct headers_t {
+    h1_t head;
+}
+
+extern Counter {
+    Counter(int size);
+    void count(int idx);
+}
+
+control c(inout headers_t hdrs) {
+    @noWarn("unused") @name(".NoAction") action NoAction_1() {
+    }
+    @name("c.ctr") Counter(256) ctr_0;
+    @name("c.a0") action a0() {
+        ctr_0.count(0);
+    }
+    @name("c.a1") action a1(@name("idx") bit<8> idx_2) {
+        ctr_0.count(idx_2);
+    }
+    @name("c.a2") action a2(@name("idx") bit<4> idx_3) {
+        ctr_0.count(idx_3);
+    }
+    @name("c.t1") table t1_0 {
+        key = {
+            hdrs.head.f1: exact @name("hdrs.head.f1");
+        }
+        actions = {
+            a0();
+            a1();
+            a2();
+            @defaultonly NoAction_1();
+        }
+        default_action = NoAction_1();
+    }
+    apply {
+        t1_0.apply();
+    }
+}
+
+top<headers_t>(c()) main;
diff --git a/testdata/p4_16_samples_outputs/extern-int-arg1-midend.p4 b/testdata/p4_16_samples_outputs/extern-int-arg1-midend.p4
@@ -0,0 +1,51 @@
+#include <core.p4>
+
+control generic<M>(inout M m);
+package top<M>(generic<M> c);
+header h1_t {
+    bit<32> f1;
+    bit<16> h1;
+    bit<8>  b1;
+    bit<8>  cnt;
+}
+
+struct headers_t {
+    h1_t head;
+}
+
+extern Counter {
+    Counter(int size);
+    void count(int idx);
+}
+
+control c(inout headers_t hdrs) {
+    @noWarn("unused") @name(".NoAction") action NoAction_1() {
+    }
+    @name("c.ctr") Counter(256) ctr_0;
+    @name("c.a0") action a0() {
+        ctr_0.count(0);
+    }
+    @name("c.a1") action a1(@name("idx") bit<8> idx_2) {
+        ctr_0.count(idx_2);
+    }
+    @name("c.a2") action a2(@name("idx") bit<4> idx_3) {
+        ctr_0.count(idx_3);
+    }
+    @name("c.t1") table t1_0 {
+        key = {
+            hdrs.head.f1: exact @name("hdrs.head.f1");
+        }
+        actions = {
+            a0();
+            a1();
+            a2();
+            @defaultonly NoAction_1();
+        }
+        default_action = NoAction_1();
+    }
+    apply {
+        t1_0.apply();
+    }
+}
+
+top<headers_t>(c()) main;
diff --git a/testdata/p4_16_samples_outputs/extern-int-arg1.p4 b/testdata/p4_16_samples_outputs/extern-int-arg1.p4
@@ -0,0 +1,47 @@
+#include <core.p4>
+
+control generic<M>(inout M m);
+package top<M>(generic<M> c);
+header h1_t {
+    bit<32> f1;
+    bit<16> h1;
+    bit<8>  b1;
+    bit<8>  cnt;
+}
+
+struct headers_t {
+    h1_t head;
+}
+
+extern Counter {
+    Counter(int size);
+    void count(int idx);
+}
+
+control c(inout headers_t hdrs) {
+    Counter(256) ctr;
+    action a0() {
+        ctr.count(0);
+    }
+    action a1(bit<8> idx) {
+        ctr.count(idx);
+    }
+    action a2(bit<4> idx) {
+        ctr.count(idx);
+    }
+    table t1 {
+        key = {
+            hdrs.head.f1: exact;
+        }
+        actions = {
+            a0;
+            a1;
+            a2;
+        }
+    }
+    apply {
+        t1.apply();
+    }
+}
+
+top(c()) main;
diff --git a/testdata/p4_16_samples_outputs/extern-int-arg1.p4-stderr b/testdata/p4_16_samples_outputs/extern-int-arg1.p4-stderr