Disallow duplicate declarations within the same scope

[jaehyun1ee]

This PR revises the specification to disallow duplicate declarations within the same scope. This has been discussed in P4 LDWG.

• It disallows duplicate declarations, e.g.,

control p() {
    const bit<8> x = 8;
    const bit<4> x = 4;   // Error: duplicate declaration of x
    apply {}
}

• But it still allows declaration shadowing (same identifier in an inner scope), e.g.,

const bit<4> x = 1;
control p() {
    const bit<8> x = 8;   // x declaration shadows global x
    apply {}
}

• And it still allows functions and methods with the same names (up to overload resolution). Recall that P4 allows overloading of functions and methods, when they can be differentiated by either the number of parameters or the names of parameters:

extern void f(in bit<8> x);
extern void f(in bit<8> y); // allowed: different parameter names
extern void f(in bit<16> x, in bit<8> y); // allowed: different number of parameters
extern void f(in bit<16> x, in bit<8> x); // Error: duplicate declaration of previous function

Some related past issues in p4-spec and p4c are:

• Name duplication and name shadowing #974
  • This is perhaps the first issue asking for clarification regarding name duplication. Was closed after it got stale.
• Is shadowing of functions in the same namespace intended? p4c#5096
  • The recent p4c issue, which led to a discussion in 2025-November P4 LDWG meeting. The consensus was to disallow duplicate declarations within the same scope.

In particular, this PR modifies sections 6.6.1. Scopes, 6.9. Name Resolution, and 7.2.11.2. Extern Objects.

• 6.6.1 add that duplicate declarations are disallowed.
• 6.9 adds a detailed explanation of duplicate declaration, and also explains that name shadowing (up to compiler warning) and function/method overloading are still allowed.
• The part explaining function/method overloading in 7.2.11.2 was moved to 6.9.

[ajwalton]

Thanks @rcgoodfellow
It would seem that this text still doesn't resolve the meaning of "X a = a", where "a" is also defined in an out scope. (@ChrisDodd suggested that the declaration is for the whole scope, so this is really setting "a" to itself, which is a use before definition, not the value from the outer scope.)
Does this also make clear whether parameters are in the same scope as the enclosing block?

[jafingerhut]

@jafingerhut Review this.

[jafingerhut]

I am confused by this example for a couple of reasons.

(1) There are two parameters named x. That seems like the primary reason that it would be an error to me, regardless of overloading considerations.

(2) If we changed the parameters names to 'x' and 'z' instead of 'x' and 'x', would it be legal? The sequence of parameter names is different, so it is not clear to me whether that is sufficient to be similar to the example a couple of lines above where it has the comment "allowed: different parameter names". Does each individual parameter name need to be different? Or does the entire sequence of names need to differ in at least one of the names?

(3) I had not realized (or perhaps seen it before, but forgotten) that the example with the comment "allowed: different parameter names" was allowed. Is it expected that calls to such an overloaded function must use the parameter name in calls, in order to distinguish which instance of f is meant? e.g. f(x = 5) or f(y=a+b) are legal, but f(5) is not?

[jaehyun1ee]

Thank you for pointing it out, it was actually a typo, where I fixed the example to:

extern void f(in bit<8> x);
extern void f(in bit<8> y); // allowed: different parameter names
extern void f(in bit<16> x, in bit<8> y); // allowed: different number of parameters
extern void f(in bit<16> x, in bit<8> y); // Error: duplicate declaration of previous function

So I believe this resolves (1) and (2), sorry for making the confusion. And yes, declaration such as extern void f(in bit<16> x, in bit<8> x); is already invalid because it has duplicate parameter names.

For (3), in P4, overload resolution occurs via parameter names and the number of parameters. So, extern void f(in bit<8> x); and extern void f(in bit<8> y); are overloaded, and the caller MUST explicitly disambiguate by specifying either x=... or y=... in the argument. It is an error if they cannot be distinguished, as per the spec:

When overloading is used, the compiler must be able to disambiguate at compile-time which method or function is being called, either by the number of arguments or by the names of the arguments, when calls are specifying argument names. (7.2.11.2)