C issue 0088: Are two incomplete structure types with a (lexically) identical tag always compatible?

This issue has been automatically converted from the original issue lists and some formatting may not have been preserved.

Authors: Clive Feather, WG14
Date: 1993-12-03
Submitted against: C90
Status: Closed
Cross-references: 0139
Converted from: dr.htm, dr_088.html

According to subclause 6.1.2.6 Compatible type and composite type, an incomplete structure type is incompatible with everything except “the same type:”

The C Standard fails to define when exactly two types are “the same.” It is intuitively clear in context of basic types and array or pointer derivation, but becomes vague when genuinely new structure or union types are involved, especially when they are created as incomplete types first and completed later.

a) Are two incomplete structure types with a (lexically) identical tag always “the same” in the sense of subclause 6.1.2.6? It would appear not, unless they are declared in the same scope of the same translation unit.

b) Can two different incomplete structure types be compatible in other ways? If so, how?

c) Is a structure type before and after completion “the same type” in the sense of subclause 6.1.2.6? If the answer to (c) is no, then questions (d) to (g) apply.

 struct tag;

 int a1 (struct tag * p)
        { a2 (p); }             /* Line A */

 struct tag { int i; } s;

 int main ()
        {
        a1 (&s);
        return 0;
        }

 int a2 (struct tag * p)
        { /* ... */ }

e) Is the call to a2 in line A valid? The parameter and argument types appear to be incompatible.

f) Suppose that the definition of a2 were moved to a separate translation unit, preceded by a definition of struct tag which was compatible with the one in the above translation unit. Would the call in line A then be valid?

struct tag;
 extern struct tag* p;          /* Line B */

 struct tag { int x; }
 extern struct tag* p;

requires a diagnostic since the two declarations of p specify incompatible types? If not, what is the type p is declared as in Line B ?

h) If two types A and B are compatible, is A compatible with all types that are the same as B? For example, is the call in line D below valid? If the redeclaration in line C is omitted, does undefined behavior result?

 /* First translation unit */

 struct tag;
 int c1 (struct tag * p)
        { /* ... */ }

 struct tag { int i; };         /* Line C */

 /* Second translation unit */

 struct tag { int i; } s;
 int main()
        {
        c1 (&s);            /* Line D */
        return 0;
        }

Response

c) Yes. The C Standard failed to make clear that the type remains the same, but that is the obvious intent.

Issue 0088: Are two incomplete structure types with a (lexically) identical tag always compatible?

Response