c - static and extern one again

Question

I'm checking various situations that could happen in declarations with different linkages, and I have 2 questions.

I. I have the following code:

#include <stdio.h>  

static int a = 19;
         
   int main(void)
   {
      extern int a;
      {
          extern int a;
          printf("braces - %d\n", a);
      }   
      printf("main - %d\n", a);
  }

which compiles well with both clang and gcc, with the same result of 19 being printed in both pritfs. As i may understand, all as are static as per 6.2.2., 4) of the Standard. The only thing that I don't understand in it is that why file-scope a is visible for a in main and braces? Should't the file-scope one be hidden as per footnote 31? When I define the other a in other file with different value, both printfs` output is still 19.

II. Now I do the following:

#include <stdio.h>  

static int a = 19;
         
   int main(void)
   {
      int a;                           //change in this line
      {
          extern int a;
          printf("braces - %d\n", a);
      }   
      printf("main - %d\n", a);
  }

gcc yells variable previously declared ‘static’ redeclared ‘extern’, while clang acts normal and prints a = 0 for a in main (yes, it is garbage value) and still 19 in braces.
I guess gcc applies here 6.2.2. 7) of the Standard, while clang doesn't. Which one's interpretation is correct and what is going on in here?

I can only assume that gcc ''matches'' a in braces with a in main (which has no linkage) and makes it's linkage external, and then sees that it conflicts with file-scope static a. And, once again, why not making braces a refer to a in the other file (footnote 31?)?

---

My current understanding is, in fact, close to the one in the accepted answer in here, even though i do understand that C++ has differences from C (and i ask about C).

Answer 1

The only thing that I don't understand in it is that why file-scope a is visible for a in main and braces?

The variable a declared in the file scope is visible in the block scope of main

   static int a = 19;
         
   int main(void)
   {
      extern int a;
      //...

until the declaration in main redeclares the variable in the file scope. So the variable in main denotes the same variable declared in the file scope.

In the block scope of the compound statement

int main(void)
{
   extern int a;
   {
       extern int a;
       //...

the declaration of the variable a in the enclosing scope of main is visible until the declaration of the variable a in the block scope of the compound statement. So the variable declared in the compound statement denotes the same variable that is declared in the enclosing block scope of the function main. All three variables denote the same variable with the internal linkage.

As for the second program then according to the C Standard (6.2.2 Linkages of identifiers)

7 If, within a translation unit, the same identifier appears with both internal and external linkage, the behavior is undefined

the program has undefined behavior because the variable declared in the block scope of the function main

static int a = 19;
     
int main(void)
{
    int a; 
    // ...

hides the variable declared in the file scope with internal linkage. So according to the C Standard (6.2.2 Linkages of identifiers)

4 For an identifier declared with the storage-class specifier extern in a scope in which a prior declaration of that identifier is visible,31) if the prior declaration specifies internal or external linkage, the linkage of the identifier at the later declaration is the same as the linkage specified at the prior declaration. If no prior declaration is visible, or if the prior declaration specifies no linkage, then the identifier has external linkage.

the variable a declared in the block scope of the compound statement has external linkage. As a result the same identifier in the translation unit has external and internal linkages.