Fix zero-sized fields in struct initializers

For things like:
struct S { union { int a; int[0] b; int c;} }
we need to recognize that a and c are part of the same union. We need to
check the size as well as the offset.

src/struct.c

@@ -245,15 +245,24 @@ int AggregateDeclaration::isNested()
  */
 int AggregateDeclaration::firstFieldInUnion(int indx)
 {
+    if (isUnionDeclaration())
+        return 0;
     VarDeclaration * vd = (VarDeclaration *)fields.data[indx];
+    int firstNonZero = indx; // first index in the union with non-zero size
     for (; ;)
     {
         if (indx == 0)
-            return indx;
+            return firstNonZero;
         VarDeclaration * v = (VarDeclaration *)fields.data[indx - 1];
         if (v->offset != vd->offset)
-            return indx;
+            return firstNonZero;
         --indx;
+        /* If it is a zero-length field, it's ambiguous: we don't know if it is
+         * in the union unless we find an earlier non-zero sized field with the
+         * same offset.
+         */
+        if (v->size(loc) != 0)
+            firstNonZero = indx;
     }
 }
 
@@ -264,11 +273,17 @@ int AggregateDeclaration::firstFieldInUnion(int indx)
 int AggregateDeclaration::numFieldsInUnion(int firstIndex)
 {
     VarDeclaration * vd = (VarDeclaration *)fields.data[firstIndex];
+    /* If it is a zero-length field, AND we can't find an earlier non-zero
+     * sized field with the same offset, we assume it's not part of a union.
+     */
+    if (vd->size(loc) == 0 && !isUnionDeclaration() &&
+        firstFieldInUnion(firstIndex) == firstIndex)
+        return 1;
     int count = 1;
     for (int i = firstIndex+1; i < fields.dim; ++i)
     {
         VarDeclaration * v = (VarDeclaration *)fields.data[i];
-        // They are in a union if they have the same offset
+        // If offsets are different, they are not in the same union
         if (v->offset != vd->offset)
             break;
         ++count;