1/* Test for multiple declarations and composite types.  Includes bug
2   13801.  */
3/* Origin: Joseph Myers <jsm@polyomino.org.uk> */
4/* { dg-do compile } */
5/* { dg-options "-g" } */
6
7typedef int IA[];
8typedef int A10[10];
9
10/* Test all combinations of: a variable declared at file scope (no
11   type specifiers, or extern, or static), or just inside a function
12   (with extern), redeclared in an inner scope (with extern), and
13   redeclared in an inner scope when the previous declaration is
14   hidden (with extern, and not if the original declaration was
15   static).  Test three times: incomplete variable types; pointers to
16   incomplete types; functions returning such pointers.  */
17
18IA a0;
19void
20f0 (void)
21{
22  sizeof(a0); /* { dg-error "incomplete" } */
23  {
24    extern IA a0;
25    sizeof(a0); /* { dg-error "incomplete" } */
26    {
27      int a0;
28      {
29        extern IA a0;
30        sizeof(a0); /* { dg-error "incomplete" } */
31      }
32    }
33    sizeof(a0); /* { dg-error "incomplete" } */
34  }
35  sizeof(a0); /* { dg-error "incomplete" } */
36}
37extern A10 a0;
38
39IA a1;
40void
41f1 (void)
42{
43  sizeof(a1); /* { dg-error "incomplete" } */
44  {
45    extern IA a1;
46    sizeof(a1); /* { dg-error "incomplete" } */
47    {
48      int a1;
49      {
50        extern A10 a1;
51        sizeof(a1);
52      }
53    }
54    sizeof(a1); /* { dg-error "incomplete" } */
55  }
56  sizeof(a1); /* { dg-error "incomplete" } */
57}
58extern A10 a1;
59
60IA a2;
61void
62f2 (void)
63{
64  sizeof(a2); /* { dg-error "incomplete" } */
65  {
66    extern A10 a2;
67    sizeof(a2);
68    {
69      int a2;
70      {
71        extern IA a2;
72        sizeof(a2); /* { dg-error "incomplete" } */
73      }
74    }
75    sizeof(a2);
76  }
77  sizeof(a2); /* { dg-error "incomplete" } */
78}
79extern A10 a2;
80
81IA a3;
82void
83f3 (void)
84{
85  sizeof(a3); /* { dg-error "incomplete" } */
86  {
87    extern A10 a3;
88    sizeof(a3);
89    {
90      int a3;
91      {
92        extern A10 a3;
93        sizeof(a3);
94      }
95    }
96    sizeof(a3);
97  }
98  sizeof(a3); /* { dg-error "incomplete" } */
99}
100extern A10 a3;
101
102A10 a4;
103void
104f4 (void)
105{
106  sizeof(a4);
107  {
108    extern IA a4;
109    sizeof(a4);
110    {
111      int a4;
112      {
113        extern IA a4;
114        sizeof(a4); /* { dg-error "incomplete" } */
115      }
116    }
117    sizeof(a4);
118  }
119  sizeof(a4);
120}
121extern A10 a4;
122
123A10 a5;
124void
125f5 (void)
126{
127  sizeof(a5);
128  {
129    extern IA a5;
130    sizeof(a5);
131    {
132      int a5;
133      {
134        extern A10 a5;
135        sizeof(a5);
136      }
137    }
138    sizeof(a5);
139  }
140  sizeof(a5);
141}
142extern A10 a5;
143
144A10 a6;
145void
146f6 (void)
147{
148  sizeof(a6);
149  {
150    extern A10 a6;
151    sizeof(a6);
152    {
153      int a6;
154      {
155        extern IA a6;
156        sizeof(a6); /* { dg-error "incomplete" } */
157      }
158    }
159    sizeof(a6);
160  }
161  sizeof(a6);
162}
163extern A10 a6;
164
165A10 a7;
166void
167f7 (void)
168{
169  sizeof(a7);
170  {
171    extern A10 a7;
172    sizeof(a7);
173    {
174      int a7;
175      {
176        extern A10 a7;
177        sizeof(a7);
178      }
179    }
180    sizeof(a7);
181  }
182  sizeof(a7);
183}
184extern A10 a7;
185
186extern IA a8;
187void
188f8 (void)
189{
190  sizeof(a8); /* { dg-error "incomplete" } */
191  {
192    extern IA a8;
193    sizeof(a8); /* { dg-error "incomplete" } */
194    {
195      int a8;
196      {
197        extern IA a8;
198        sizeof(a8); /* { dg-error "incomplete" } */
199      }
200    }
201    sizeof(a8); /* { dg-error "incomplete" } */
202  }
203  sizeof(a8); /* { dg-error "incomplete" } */
204}
205extern A10 a8;
206
207extern IA a9;
208void
209f9 (void)
210{
211  sizeof(a9); /* { dg-error "incomplete" } */
212  {
213    extern IA a9;
214    sizeof(a9); /* { dg-error "incomplete" } */
215    {
216      int a9;
217      {
218        extern A10 a9;
219        sizeof(a9);
220      }
221    }
222    sizeof(a9); /* { dg-error "incomplete" } */
223  }
224  sizeof(a9); /* { dg-error "incomplete" } */
225}
226extern A10 a9;
227
228extern IA a10;
229void
230f10 (void)
231{
232  sizeof(a10); /* { dg-error "incomplete" } */
233  {
234    extern A10 a10;
235    sizeof(a10);
236    {
237      int a10;
238      {
239        extern IA a10;
240        sizeof(a10); /* { dg-error "incomplete" } */
241      }
242    }
243    sizeof(a10);
244  }
245  sizeof(a10); /* { dg-error "incomplete" } */
246}
247extern A10 a10;
248
249extern IA a11;
250void
251f11 (void)
252{
253  sizeof(a11); /* { dg-error "incomplete" } */
254  {
255    extern A10 a11;
256    sizeof(a11);
257    {
258      int a11;
259      {
260        extern A10 a11;
261        sizeof(a11);
262      }
263    }
264    sizeof(a11);
265  }
266  sizeof(a11); /* { dg-error "incomplete" } */
267}
268extern A10 a11;
269
270extern A10 a12;
271void
272f12 (void)
273{
274  sizeof(a12);
275  {
276    extern IA a12;
277    sizeof(a12);
278    {
279      int a12;
280      {
281        extern IA a12;
282        sizeof(a12); /* { dg-error "incomplete" } */
283      }
284    }
285    sizeof(a12);
286  }
287  sizeof(a12);
288}
289extern A10 a12;
290
291extern A10 a13;
292void
293f13 (void)
294{
295  sizeof(a13);
296  {
297    extern IA a13;
298    sizeof(a13);
299    {
300      int a13;
301      {
302        extern A10 a13;
303        sizeof(a13);
304      }
305    }
306    sizeof(a13);
307  }
308  sizeof(a13);
309}
310extern A10 a13;
311
312extern A10 a14;
313void
314f14 (void)
315{
316  sizeof(a14);
317  {
318    extern A10 a14;
319    sizeof(a14);
320    {
321      int a14;
322      {
323        extern IA a14;
324        sizeof(a14); /* { dg-error "incomplete" } */
325      }
326    }
327    sizeof(a14);
328  }
329  sizeof(a14);
330}
331extern A10 a14;
332
333extern A10 a15;
334void
335f15 (void)
336{
337  sizeof(a15);
338  {
339    extern A10 a15;
340    sizeof(a15);
341    {
342      int a15;
343      {
344        extern A10 a15;
345        sizeof(a15);
346      }
347    }
348    sizeof(a15);
349  }
350  sizeof(a15);
351}
352extern A10 a15;
353
354static IA a16;
355void
356f16 (void)
357{
358  sizeof(a16); /* { dg-error "incomplete" } */
359  {
360    extern IA a16;
361    sizeof(a16); /* { dg-error "incomplete" } */
362  }
363  sizeof(a16); /* { dg-error "incomplete" } */
364}
365extern A10 a16;
366
367static IA a17;
368void
369f17 (void)
370{
371  sizeof(a17); /* { dg-error "incomplete" } */
372  {
373    extern A10 a17;
374    sizeof(a17);
375  }
376  sizeof(a17); /* { dg-error "incomplete" } */
377}
378extern A10 a17;
379
380static A10 a18;
381void
382f18 (void)
383{
384  sizeof(a18);
385  {
386    extern IA a18;
387    sizeof(a18);
388  }
389  sizeof(a18);
390}
391extern A10 a18;
392
393static A10 a19;
394void
395f19 (void)
396{
397  sizeof(a19);
398  {
399    extern A10 a19;
400    sizeof(a19);
401  }
402  sizeof(a19);
403}
404extern A10 a19;
405
406IA *b0;
407void
408g0 (void)
409{
410  sizeof(*b0); /* { dg-error "incomplete" } */
411  {
412    extern IA *b0;
413    sizeof(*b0); /* { dg-error "incomplete" } */
414    {
415      int b0;
416      {
417        extern IA *b0;
418        sizeof(*b0); /* { dg-error "incomplete" } */
419      }
420    }
421    sizeof(*b0); /* { dg-error "incomplete" } */
422  }
423  sizeof(*b0); /* { dg-error "incomplete" } */
424}
425extern A10 *b0;
426
427IA *b1;
428void
429g1 (void)
430{
431  sizeof(*b1); /* { dg-error "incomplete" } */
432  {
433    extern IA *b1;
434    sizeof(*b1); /* { dg-error "incomplete" } */
435    {
436      int b1;
437      {
438        extern A10 *b1;
439        sizeof(*b1);
440      }
441    }
442    sizeof(*b1); /* { dg-error "incomplete" } */
443  }
444  sizeof(*b1); /* { dg-error "incomplete" } */
445}
446extern A10 *b1;
447
448IA *b2;
449void
450g2 (void)
451{
452  sizeof(*b2); /* { dg-error "incomplete" } */
453  {
454    extern A10 *b2;
455    sizeof(*b2);
456    {
457      int b2;
458      {
459        extern IA *b2;
460        sizeof(*b2); /* { dg-error "incomplete" } */
461      }
462    }
463    sizeof(*b2);
464  }
465  sizeof(*b2); /* { dg-error "incomplete" } */
466}
467extern A10 *b2;
468
469IA *b3;
470void
471g3 (void)
472{
473  sizeof(*b3); /* { dg-error "incomplete" } */
474  {
475    extern A10 *b3;
476    sizeof(*b3);
477    {
478      int b3;
479      {
480        extern A10 *b3;
481        sizeof(*b3);
482      }
483    }
484    sizeof(*b3);
485  }
486  sizeof(*b3); /* { dg-error "incomplete" } */
487}
488extern A10 *b3;
489
490A10 *b4;
491void
492g4 (void)
493{
494  sizeof(*b4);
495  {
496    extern IA *b4;
497    sizeof(*b4);
498    {
499      int b4;
500      {
501        extern IA *b4;
502        sizeof(*b4); /* { dg-error "incomplete" } */
503      }
504    }
505    sizeof(*b4);
506  }
507  sizeof(*b4);
508}
509extern A10 *b4;
510
511A10 *b5;
512void
513g5 (void)
514{
515  sizeof(*b5);
516  {
517    extern IA *b5;
518    sizeof(*b5);
519    {
520      int b5;
521      {
522        extern A10 *b5;
523        sizeof(*b5);
524      }
525    }
526    sizeof(*b5);
527  }
528  sizeof(*b5);
529}
530extern A10 *b5;
531
532A10 *b6;
533void
534g6 (void)
535{
536  sizeof(*b6);
537  {
538    extern A10 *b6;
539    sizeof(*b6);
540    {
541      int b6;
542      {
543        extern IA *b6;
544        sizeof(*b6); /* { dg-error "incomplete" } */
545      }
546    }
547    sizeof(*b6);
548  }
549  sizeof(*b6);
550}
551extern A10 *b6;
552
553A10 *b7;
554void
555g7 (void)
556{
557  sizeof(*b7);
558  {
559    extern A10 *b7;
560    sizeof(*b7);
561    {
562      int b7;
563      {
564        extern A10 *b7;
565        sizeof(*b7);
566      }
567    }
568    sizeof(*b7);
569  }
570  sizeof(*b7);
571}
572extern A10 *b7;
573
574extern IA *b8;
575void
576g8 (void)
577{
578  sizeof(*b8); /* { dg-error "incomplete" } */
579  {
580    extern IA *b8;
581    sizeof(*b8); /* { dg-error "incomplete" } */
582    {
583      int b8;
584      {
585        extern IA *b8;
586        sizeof(*b8); /* { dg-error "incomplete" } */
587      }
588    }
589    sizeof(*b8); /* { dg-error "incomplete" } */
590  }
591  sizeof(*b8); /* { dg-error "incomplete" } */
592}
593extern A10 *b8;
594
595extern IA *b9;
596void
597g9 (void)
598{
599  sizeof(*b9); /* { dg-error "incomplete" } */
600  {
601    extern IA *b9;
602    sizeof(*b9); /* { dg-error "incomplete" } */
603    {
604      int b9;
605      {
606        extern A10 *b9;
607        sizeof(*b9);
608      }
609    }
610    sizeof(*b9); /* { dg-error "incomplete" } */
611  }
612  sizeof(*b9); /* { dg-error "incomplete" } */
613}
614extern A10 *b9;
615
616extern IA *b10;
617void
618g10 (void)
619{
620  sizeof(*b10); /* { dg-error "incomplete" } */
621  {
622    extern A10 *b10;
623    sizeof(*b10);
624    {
625      int b10;
626      {
627        extern IA *b10;
628        sizeof(*b10); /* { dg-error "incomplete" } */
629      }
630    }
631    sizeof(*b10);
632  }
633  sizeof(*b10); /* { dg-error "incomplete" } */
634}
635extern A10 *b10;
636
637extern IA *b11;
638void
639g11 (void)
640{
641  sizeof(*b11); /* { dg-error "incomplete" } */
642  {
643    extern A10 *b11;
644    sizeof(*b11);
645    {
646      int b11;
647      {
648        extern A10 *b11;
649        sizeof(*b11);
650      }
651    }
652    sizeof(*b11);
653  }
654  sizeof(*b11); /* { dg-error "incomplete" } */
655}
656extern A10 *b11;
657
658extern A10 *b12;
659void
660g12 (void)
661{
662  sizeof(*b12);
663  {
664    extern IA *b12;
665    sizeof(*b12);
666    {
667      int b12;
668      {
669        extern IA *b12;
670        sizeof(*b12); /* { dg-error "incomplete" } */
671      }
672    }
673    sizeof(*b12);
674  }
675  sizeof(*b12);
676}
677extern A10 *b12;
678
679extern A10 *b13;
680void
681g13 (void)
682{
683  sizeof(*b13);
684  {
685    extern IA *b13;
686    sizeof(*b13);
687    {
688      int b13;
689      {
690        extern A10 *b13;
691        sizeof(*b13);
692      }
693    }
694    sizeof(*b13);
695  }
696  sizeof(*b13);
697}
698extern A10 *b13;
699
700extern A10 *b14;
701void
702g14 (void)
703{
704  sizeof(*b14);
705  {
706    extern A10 *b14;
707    sizeof(*b14);
708    {
709      int b14;
710      {
711        extern IA *b14;
712        sizeof(*b14); /* { dg-error "incomplete" } */
713      }
714    }
715    sizeof(*b14);
716  }
717  sizeof(*b14);
718}
719extern A10 *b14;
720
721extern A10 *b15;
722void
723g15 (void)
724{
725  sizeof(*b15);
726  {
727    extern A10 *b15;
728    sizeof(*b15);
729    {
730      int b15;
731      {
732        extern A10 *b15;
733        sizeof(*b15);
734      }
735    }
736    sizeof(*b15);
737  }
738  sizeof(*b15);
739}
740extern A10 *b15;
741
742static IA *b16;
743void
744g16 (void)
745{
746  sizeof(*b16); /* { dg-error "incomplete" } */
747  {
748    extern IA *b16;
749    sizeof(*b16); /* { dg-error "incomplete" } */
750  }
751  sizeof(*b16); /* { dg-error "incomplete" } */
752}
753extern A10 *b16;
754
755static IA *b17;
756void
757g17 (void)
758{
759  sizeof(*b17); /* { dg-error "incomplete" } */
760  {
761    extern A10 *b17;
762    sizeof(*b17);
763  }
764  sizeof(*b17); /* { dg-error "incomplete" } */
765}
766extern A10 *b17;
767
768static A10 *b18;
769void
770g18 (void)
771{
772  sizeof(*b18);
773  {
774    extern IA *b18;
775    sizeof(*b18);
776  }
777  sizeof(*b18);
778}
779extern A10 *b18;
780
781static A10 *b19;
782void
783g19 (void)
784{
785  sizeof(*b19);
786  {
787    extern A10 *b19;
788    sizeof(*b19);
789  }
790  sizeof(*b19);
791}
792extern A10 *b19;
793
794IA *c0 (void);
795void
796h0 (void)
797{
798  sizeof(*c0()); /* { dg-error "incomplete" } */
799  {
800    extern IA *c0 (void);
801    sizeof(*c0()); /* { dg-error "incomplete" } */
802    {
803      int c0;
804      {
805        extern IA *c0 (void);
806        sizeof(*c0()); /* { dg-error "incomplete" } */
807      }
808    }
809    sizeof(*c0()); /* { dg-error "incomplete" } */
810  }
811  sizeof(*c0()); /* { dg-error "incomplete" } */
812}
813A10 *c0 (void) { return 0; }
814
815IA *c1 (void);
816void
817h1 (void)
818{
819  sizeof(*c1()); /* { dg-error "incomplete" } */
820  {
821    extern IA *c1 (void);
822    sizeof(*c1()); /* { dg-error "incomplete" } */
823    {
824      int c1;
825      {
826        extern A10 *c1 (void);
827        sizeof(*c1());
828      }
829    }
830    sizeof(*c1()); /* { dg-error "incomplete" } */
831  }
832  sizeof(*c1()); /* { dg-error "incomplete" } */
833}
834A10 *c1 (void) { return 0; }
835
836IA *c2 (void);
837void
838h2 (void)
839{
840  sizeof(*c2()); /* { dg-error "incomplete" } */
841  {
842    extern A10 *c2 (void);
843    sizeof(*c2());
844    {
845      int c2;
846      {
847        extern IA *c2 (void);
848        sizeof(*c2()); /* { dg-error "incomplete" } */
849      }
850    }
851    sizeof(*c2());
852  }
853  sizeof(*c2()); /* { dg-error "incomplete" } */
854}
855A10 *c2 (void) { return 0; }
856
857IA *c3 (void);
858void
859h3 (void)
860{
861  sizeof(*c3()); /* { dg-error "incomplete" } */
862  {
863    extern A10 *c3 (void);
864    sizeof(*c3());
865    {
866      int c3;
867      {
868        extern A10 *c3 (void);
869        sizeof(*c3());
870      }
871    }
872    sizeof(*c3());
873  }
874  sizeof(*c3()); /* { dg-error "incomplete" } */
875}
876A10 *c3 (void) { return 0; }
877
878A10 *c4 (void);
879void
880h4 (void)
881{
882  sizeof(*c4());
883  {
884    extern IA *c4 (void);
885    sizeof(*c4());
886    {
887      int c4;
888      {
889        extern IA *c4 (void);
890        sizeof(*c4()); /* { dg-error "incomplete" } */
891      }
892    }
893    sizeof(*c4());
894  }
895  sizeof(*c4());
896}
897A10 *c4 (void) { return 0; }
898
899A10 *c5 (void);
900void
901h5 (void)
902{
903  sizeof(*c5());
904  {
905    extern IA *c5 (void);
906    sizeof(*c5());
907    {
908      int c5;
909      {
910        extern A10 *c5 (void);
911        sizeof(*c5());
912      }
913    }
914    sizeof(*c5());
915  }
916  sizeof(*c5());
917}
918A10 *c5 (void) { return 0; }
919
920A10 *c6 (void);
921void
922h6 (void)
923{
924  sizeof(*c6());
925  {
926    extern A10 *c6 (void);
927    sizeof(*c6());
928    {
929      int c6;
930      {
931        extern IA *c6 (void);
932        sizeof(*c6()); /* { dg-error "incomplete" } */
933      }
934    }
935    sizeof(*c6());
936  }
937  sizeof(*c6());
938}
939A10 *c6 (void) { return 0; }
940
941A10 *c7 (void);
942void
943h7 (void)
944{
945  sizeof(*c7());
946  {
947    extern A10 *c7 (void);
948    sizeof(*c7());
949    {
950      int c7;
951      {
952        extern A10 *c7 (void);
953        sizeof(*c7());
954      }
955    }
956    sizeof(*c7());
957  }
958  sizeof(*c7());
959}
960A10 *c7 (void) { return 0; }
961
962extern IA *c8 (void);
963void
964h8 (void)
965{
966  sizeof(*c8()); /* { dg-error "incomplete" } */
967  {
968    extern IA *c8 (void);
969    sizeof(*c8()); /* { dg-error "incomplete" } */
970    {
971      int c8;
972      {
973        extern IA *c8 (void);
974        sizeof(*c8()); /* { dg-error "incomplete" } */
975      }
976    }
977    sizeof(*c8()); /* { dg-error "incomplete" } */
978  }
979  sizeof(*c8()); /* { dg-error "incomplete" } */
980}
981extern A10 *c8 (void) { return 0; }
982
983extern IA *c9 (void);
984void
985h9 (void)
986{
987  sizeof(*c9()); /* { dg-error "incomplete" } */
988  {
989    extern IA *c9 (void);
990    sizeof(*c9()); /* { dg-error "incomplete" } */
991    {
992      int c9;
993      {
994        extern A10 *c9 (void);
995        sizeof(*c9());
996      }
997    }
998    sizeof(*c9()); /* { dg-error "incomplete" } */
999  }
1000  sizeof(*c9()); /* { dg-error "incomplete" } */
1001}
1002extern A10 *c9 (void) { return 0; }
1003
1004extern IA *c10 (void);
1005void
1006h10 (void)
1007{
1008  sizeof(*c10()); /* { dg-error "incomplete" } */
1009  {
1010    extern A10 *c10 (void);
1011    sizeof(*c10());
1012    {
1013      int c10;
1014      {
1015        extern IA *c10 (void);
1016        sizeof(*c10()); /* { dg-error "incomplete" } */
1017      }
1018    }
1019    sizeof(*c10());
1020  }
1021  sizeof(*c10()); /* { dg-error "incomplete" } */
1022}
1023extern A10 *c10 (void) { return 0; }
1024
1025extern IA *c11 (void);
1026void
1027h11 (void)
1028{
1029  sizeof(*c11()); /* { dg-error "incomplete" } */
1030  {
1031    extern A10 *c11 (void);
1032    sizeof(*c11());
1033    {
1034      int c11;
1035      {
1036        extern A10 *c11 (void);
1037        sizeof(*c11());
1038      }
1039    }
1040    sizeof(*c11());
1041  }
1042  sizeof(*c11()); /* { dg-error "incomplete" } */
1043}
1044extern A10 *c11 (void) { return 0; }
1045
1046extern A10 *c12 (void);
1047void
1048h12 (void)
1049{
1050  sizeof(*c12());
1051  {
1052    extern IA *c12 (void);
1053    sizeof(*c12());
1054    {
1055      int c12;
1056      {
1057        extern IA *c12 (void);
1058        sizeof(*c12()); /* { dg-error "incomplete" } */
1059      }
1060    }
1061    sizeof(*c12());
1062  }
1063  sizeof(*c12());
1064}
1065extern A10 *c12 (void) { return 0; }
1066
1067extern A10 *c13 (void);
1068void
1069h13 (void)
1070{
1071  sizeof(*c13());
1072  {
1073    extern IA *c13 (void);
1074    sizeof(*c13());
1075    {
1076      int c13;
1077      {
1078        extern A10 *c13 (void);
1079        sizeof(*c13());
1080      }
1081    }
1082    sizeof(*c13());
1083  }
1084  sizeof(*c13());
1085}
1086extern A10 *c13 (void) { return 0; }
1087
1088extern A10 *c14 (void);
1089void
1090h14 (void)
1091{
1092  sizeof(*c14());
1093  {
1094    extern A10 *c14 (void);
1095    sizeof(*c14());
1096    {
1097      int c14;
1098      {
1099        extern IA *c14 (void);
1100        sizeof(*c14()); /* { dg-error "incomplete" } */
1101      }
1102    }
1103    sizeof(*c14());
1104  }
1105  sizeof(*c14());
1106}
1107extern A10 *c14 (void) { return 0; }
1108
1109extern A10 *c15 (void);
1110void
1111h15 (void)
1112{
1113  sizeof(*c15());
1114  {
1115    extern A10 *c15 (void);
1116    sizeof(*c15());
1117    {
1118      int c15;
1119      {
1120        extern A10 *c15 (void);
1121        sizeof(*c15());
1122      }
1123    }
1124    sizeof(*c15());
1125  }
1126  sizeof(*c15());
1127}
1128extern A10 *c15 (void) { return 0; }
1129
1130static IA *c16 (void);
1131void
1132h16 (void)
1133{
1134  sizeof(*c16()); /* { dg-error "incomplete" } */
1135  {
1136    extern IA *c16 (void);
1137    sizeof(*c16()); /* { dg-error "incomplete" } */
1138  }
1139  sizeof(*c16()); /* { dg-error "incomplete" } */
1140}
1141static A10 *c16 (void) { return 0; }
1142
1143static IA *c17 (void);
1144void
1145h17 (void)
1146{
1147  sizeof(*c17()); /* { dg-error "incomplete" } */
1148  {
1149    extern A10 *c17 (void);
1150    sizeof(*c17());
1151  }
1152  sizeof(*c17()); /* { dg-error "incomplete" } */
1153}
1154static A10 *c17 (void) { return 0; }
1155
1156static A10 *c18 (void);
1157void
1158h18 (void)
1159{
1160  sizeof(*c18());
1161  {
1162    extern IA *c18 (void);
1163    sizeof(*c18());
1164  }
1165  sizeof(*c18());
1166}
1167static A10 *c18 (void) { return 0; }
1168
1169static A10 *c19 (void);
1170void
1171h19 (void)
1172{
1173  sizeof(*c19());
1174  {
1175    extern A10 *c19 (void);
1176    sizeof(*c19());
1177  }
1178  sizeof(*c19());
1179}
1180static A10 *c19 (void) { return 0; }
1181