Fix issue #105 do not override the original incomplete array type siz…

ppci/lang/c/nodes/types.py

@@ -217,6 +217,18 @@ def decay(self):
         """ Decay into pointer type. """
         return PointerType(self.element_type)
 
+    @property
+    def incomplete(self):
+        """ Test if this type is incomplete """
+        if self.size is None:
+          return True
+        return self.element_type.is_compound and self.element_type.incomplete
+
+    @property
+    def complete(self):
+        """ Test if this type is complete """
+        return not self.incomplete
+
 
 class PointerType(IndexableType):
     """ The famous pointer! """

ppci/lang/c/parser.py

@@ -484,14 +484,22 @@ def parse_variable_declaration(self, decl_spec, declarator):
             declarator.type_modifiers,
             declarator.location,
         )
-
         self.semantics.register_declaration(variable)
 
         # Handle the initial value:
         if self.has_consumed("="):
             initializer = self.parse_initializer(variable.typ)
             self.semantics.on_variable_initialization(variable, initializer)
 
+        # Ensure that the variable type is complete
+        # TODO to avoid an error when computing the variable size in IR
+        # generation, we should detect there all type incompleteness
+        # struct/union, component type of arrays, etc.
+        if variable.typ.is_compound and variable.typ.incomplete:
+            self.error(
+                "Type of variable '{}' is incomplete".format(declarator.name),
+                declarator.location)
+
     def parse_typedef(self, decl_spec, declarator):
         """ Process typedefs """
         self.typedefs.add(declarator.name)

ppci/lang/c/semantics.py

@@ -174,19 +174,30 @@ def on_variable_initialization(self, variable, expression):
         if self.scope.is_definition(variable.name):
             self.error("Invalid redefinition.", variable.location)
 
-        self.patch_size_from_initializer(variable.typ, expression)
+        variable.typ = self.patch_size_from_initializer(
+            variable.typ,
+            expression
+        )
         variable.initial_value = expression
 
     def patch_size_from_initializer(self, typ, initializer):
-        """ Fill array size from elements! """
-
+        """ Fill array type size from elements if the type size is unknown.
+            Return a new type if modified 
+        """
         if typ.is_array and typ.size is None:
             if isinstance(initializer, expressions.ArrayInitializer):
-                typ.size = len(initializer.values)
+                new_type = types.ArrayType(
+                    typ.element_type,
+                    len(initializer.values)
+                ) 
+                initializer.typ = new_type
+                return new_type
             else:  # pragma: no cover
                 raise NotImplementedError(
                     "What else could be used to init an array?"
                 )
+        else:
+            return typ
 
     def new_init_cursor(self):
         return init.InitCursor(self.context)