[mypyc] Tweak how tuple structs are defined (#7630)

Change how we declare and define tuple structs to prepare for separate compilation:
 * Wrap declarations in an #ifdef/#define so that multiple modules
   can define the same tuple types (since they are structural) and
   interoperate properly.
 * Declare the undefined values eagerly instead of only when they
   are needed, since they might be needed by another compilationg group.
 * Declare them with a typedef instead of always writing struct. This
   will very slightly simplify some logic for manipulating the type string
   later but mostly just looks better.

Author: msullivan

mypyc/emit.py

@@ -152,7 +152,11 @@ def native_function_name(self, fn: FuncDecl) -> str:
         return '{}{}'.format(NATIVE_PREFIX, fn.cname(self.names))
 
     def tuple_c_declaration(self, rtuple: RTuple) -> List[str]:
-        result = ['struct {} {{'.format(rtuple.struct_name)]
+        result = [
+            '#ifndef MYPYC_DECLARED_{}'.format(rtuple.struct_name),
+            '#define MYPYC_DECLARED_{}'.format(rtuple.struct_name),
+            'typedef struct {} {{'.format(rtuple.struct_name),
+        ]
         if len(rtuple.types) == 0:  # empty tuple
             # Empty tuples contain a flag so that they can still indicate
             # error values.
@@ -162,7 +166,11 @@ def tuple_c_declaration(self, rtuple: RTuple) -> List[str]:
             for typ in rtuple.types:
                 result.append('{}f{};'.format(self.ctype_spaced(typ), i))
                 i += 1
-        result.append('};')
+        result.append('}} {};'.format(rtuple.struct_name))
+        values = self.tuple_undefined_value_helper(rtuple)
+        result.append('static {} {} = {{ {} }};'.format(
+            self.ctype(rtuple), self.tuple_undefined_value(rtuple), ''.join(values)))
+        result.append('#endif')
         result.append('')
 
         return result
@@ -183,17 +191,7 @@ def tuple_undefined_check_cond(
                 tuple_expr_in_c, compare, c_type_compare_val(item_type))
 
     def tuple_undefined_value(self, rtuple: RTuple) -> str:
-        context = self.context
-        id = rtuple.unique_id
-        name = 'tuple_undefined_' + id
-        if name not in context.declarations:
-            values = self.tuple_undefined_value_helper(rtuple)
-            var = 'struct {} {}'.format(rtuple.struct_name, name)
-            decl = '{};'.format(var)
-            init = '{} = {{ {} }};'.format(var, ''.join(values))
-            context.declarations[name] = HeaderDeclaration(
-                set([rtuple.struct_name]), [decl], [init])
-        return name
+        return 'tuple_undefined_' + rtuple.unique_id
 
     def tuple_undefined_value_helper(self, rtuple: RTuple) -> List[str]:
         res = []

mypyc/ops.py

@@ -248,7 +248,7 @@ def __init__(self, types: List[RType]) -> None:
         self.unique_id = self.accept(TupleNameVisitor())
         # Nominally the max c length is 31 chars, but I'm not honestly worried about this.
         self.struct_name = 'tuple_{}'.format(self.unique_id)
-        self._ctype = 'struct {}'.format(self.struct_name)
+        self._ctype = '{}'.format(self.struct_name)
 
     def accept(self, visitor: 'RTypeVisitor[T]') -> T:
         return visitor.visit_rtuple(self)