comtypes 1.4.9__zip → 1.4.10__zip

{comtypes-1.4.9 → comtypes-1.4.10}/comtypes/tools/codegenerator/codegenerator.py

@@ -1,31 +1,29 @@
 # Code generator to generate code for everything contained in COM type
 # libraries.
+import contextlib
+import io
 import keyword
 import logging
 import os
 import textwrap
-from typing import Any
-from typing import Dict, List, Tuple
-from typing import Sequence
-from typing import Optional, Union as _UnionT
-import io
+import warnings
+from typing import Any, Dict, Iterator, List, Literal, Optional, Sequence, Tuple
+from typing import Union as _UnionT
 
 import comtypes
 from comtypes import typeinfo
 from comtypes.tools import tlbparser, typedesc
-from comtypes.tools.codegenerator import namespaces
-from comtypes.tools.codegenerator import packing
-from comtypes.tools.codegenerator.modulenamer import name_wrapper_module
+from comtypes.tools.codegenerator import heads, namespaces, packing
+from comtypes.tools.codegenerator.comments import ComInterfaceBodyImplCommentWriter
 from comtypes.tools.codegenerator.helpers import (
-    get_real_type,
     ASSUME_STRINGS,
     ComMethodGenerator,
     DispMethodGenerator,
     DispPropertyGenerator,
     TypeNamer,
+    get_real_type,
 )
-from comtypes.tools.codegenerator import typeannotator
-
+from comtypes.tools.codegenerator.modulenamer import name_wrapper_module
 
 version = comtypes.__version__
 
@@ -59,7 +57,29 @@ class CodeGenerator(object):
         self.names = set()  # names that have been generated
         self.externals = []  # typelibs imported to generated module
         self.enum_aliases: Dict[str, str] = {}
-        self.last_item_class = False
+        self.last_item = "attribute"
+
+    @contextlib.contextmanager
+    def adjust_blank(
+        self, item: Literal["assert", "attribute", "class", "comment", "variable"]
+    ) -> Iterator[io.StringIO]:
+        if self.last_item == "class":
+            print(file=self.stream)
+            print(file=self.stream)
+        elif self.last_item == "attribute":
+            print(file=self.stream)
+            if item == "class":
+                print(file=self.stream)
+        elif self.last_item in ("variable", "assert", "comment"):
+            if item == "class":
+                print(file=self.stream)
+                print(file=self.stream)
+            elif item == "attribute":
+                print(file=self.stream)
+        else:
+            raise TypeError
+        yield self.stream
+        self.last_item = item
 
     def generate(self, item):
         if item in self.done:
@@ -128,8 +148,8 @@ class CodeGenerator(object):
                 path = self._make_relative_path(filename, comtypes.gen.__path__[0])
                 self.imports.add("os")
                 definition = (
-                    f"os.path.normpath(\n"
-                    f"    os.path.abspath(os.path.join(os.path.dirname(__file__),\n"
+                    "os.path.normpath(\n"
+                    "    os.path.abspath(os.path.join(os.path.dirname(__file__),\n"
                     f"                                 {path!r})))"
                 )
                 self.declarations.add("typelib_path", definition)
@@ -218,7 +238,7 @@ class CodeGenerator(object):
         print(self._make_dunder_all_part(), file=output)
         print(file=output)
         if tlib_mtime is not None:
-            print("_check_version(%r, %f)" % (version, tlib_mtime), file=output)
+            print(f"_check_version({version!r}, {tlib_mtime:f})", file=output)
         return output.getvalue()
 
     def generate_friendly_code(self, modname: str) -> str:
@@ -288,19 +308,11 @@ class CodeGenerator(object):
         if "datetime.datetime(" in text:
             self.imports.add("datetime")
 
-    def _to_docstring(self, orig: str, depth: int = 1) -> str:
-        # increasing `depth` by one increases indentation by one
-        indent = "    " * depth
-        # some chars are replaced to avoid causing a `SyntaxError`
-        repled = orig.replace("\\", r"\\").replace('"', r"'")
-        return f'{indent}"""{repled}"""'
-
     def ArrayType(self, tp: typedesc.ArrayType) -> None:
         self.generate(get_real_type(tp.typ))
         self.generate(tp.typ)
 
     def EnumValue(self, tp: typedesc.EnumValue) -> None:
-        self.last_item_class = False
         value = int(tp.value)
         if keyword.iskeyword(tp.name):
             # XXX use logging!
@@ -314,7 +326,6 @@ class CodeGenerator(object):
         self.names.add(tp_name)
 
     def Enumeration(self, tp: typedesc.Enumeration) -> None:
-        self.last_item_class = False
         for item in tp.values:
             self.generate(item)
         if tp.name:
@@ -334,8 +345,8 @@ class CodeGenerator(object):
                 if isinstance(tp.typ, typedesc.Enumeration):
                     self.enum_aliases[tp.name] = definition
                 else:
-                    print(f"{tp.name} = {definition}", file=self.stream)
-                    self.last_item_class = False
+                    with self.adjust_blank("variable") as ofi:
+                        print(f"{tp.name} = {definition}", file=ofi)
         self.names.add(tp.name)
 
     def FundamentalType(self, item: typedesc.FundamentalType) -> None:
@@ -345,90 +356,12 @@ class CodeGenerator(object):
         for struct in head.struct.bases:
             self.generate(struct.get_head())
             self.more.add(struct)
-        if head.struct.location:
-            self.last_item_class = False
-            print(f"# {head.struct.location}", file=self.stream)
         basenames = [self._to_type_name(b) for b in head.struct.bases]
         if basenames:
             self.imports.add("comtypes", "GUID")
 
-            if not self.last_item_class:
-                print(file=self.stream)
-                print(file=self.stream)
-
-            self.last_item_class = True
-
-            method_names = [
-                m.name for m in head.struct.members if type(m) is typedesc.Method
-            ]
-            print(
-                f"class {head.struct.name}({', '.join(basenames)}):",
-                file=self.stream,
-            )
-            print(
-                "    _iid_ = GUID('{}') # please look up iid and fill in!",
-                file=self.stream,
-            )
-            if "Enum" in method_names:
-                print("    def __iter__(self):", file=self.stream)
-                print("        return self.Enum()", file=self.stream)
-            elif method_names == "Next Skip Reset Clone".split():
-                print("    def __iter__(self):", file=self.stream)
-                print("        return self", file=self.stream)
-                print(file=self.stream)
-                print("    def next(self):", file=self.stream)
-                print("         arr, fetched = self.Next(1)", file=self.stream)
-                print("         if fetched == 0:", file=self.stream)
-                print("             raise StopIteration", file=self.stream)
-                print("         return arr[0]", file=self.stream)
-
-            print(file=self.stream)
-            print(file=self.stream)
-
-        else:
-            methods = [m for m in head.struct.members if type(m) is typedesc.Method]
-
-            if methods:
-                # Hm. We cannot generate code for IUnknown...
-                if not self.last_item_class:
-                    print(file=self.stream)
-
-                self.last_item_class = True
-                print("assert 0, 'cannot generate code for IUnknown'", file=self.stream)
-                print(file=self.stream)
-                print(file=self.stream)
-                print(f"class {head.struct.name}(_com_interface):", file=self.stream)
-                print("    pass", file=self.stream)
-                print(file=self.stream)
-                print(file=self.stream)
-            elif type(head.struct) == typedesc.Structure:
-                if not self.last_item_class:
-                    print(file=self.stream)
-                    print(file=self.stream)
-
-                self.last_item_class = True
-
-                print(f"class {head.struct.name}(Structure):", file=self.stream)
-                if hasattr(head.struct, "_recordinfo_"):
-                    print(
-                        f"    _recordinfo_ = {head.struct._recordinfo_!r}",
-                        file=self.stream,
-                    )
-                else:
-                    print("    pass", file=self.stream)
-                print(file=self.stream)
-                print(file=self.stream)
-            elif type(head.struct) == typedesc.Union:
-                if not self.last_item_class:
-                    print(file=self.stream)
-                    print(file=self.stream)
-
-                self.last_item_class = True
-
-                print(f"class {head.struct.name}(Union):", file=self.stream)
-                print("    pass", file=self.stream)
-                print(file=self.stream)
-                print(file=self.stream)
+        with self.adjust_blank("class") as ofi:
+            heads.StructureHeadWriter(ofi).write(head, basenames)
         self.names.add(head.struct.name)
 
     def Structure(self, struct: typedesc.Structure) -> None:
@@ -461,104 +394,99 @@ class CodeGenerator(object):
             try:
                 pack = packing.calc_packing(body.struct, fields)
                 if pack is not None:
-                    self.last_item_class = False
-                    print(f"{body.struct.name}._pack_ = {pack}", file=self.stream)
+                    with self.adjust_blank("attribute") as ofi:
+                        print(f"{body.struct.name}._pack_ = {pack}", file=ofi)
             except packing.PackingError as details:
                 # if packing fails, write a warning comment to the output.
-                import warnings
-
-                message = "Structure %s: %s" % (body.struct.name, details)
+                message = f"Structure {body.struct.name}: {details}"
                 warnings.warn(message, UserWarning)
-                print(f"# WARNING: {details}", file=self.stream)
-                self.last_item_class = False
-
+                with self.adjust_blank("comment") as ofi:
+                    print(f"# WARNING: {details}", file=ofi)
         if fields:
             if body.struct.bases:
                 assert len(body.struct.bases) == 1
                 self.generate(body.struct.bases[0].get_body())
-
-            if not self.last_item_class:
-                print(file=self.stream)
-
-            self.last_item_class = False
-
-            print(f"{body.struct.name}._fields_ = [", file=self.stream)
-            if body.struct.location:
-                print(f"    # {body.struct.location}", file=self.stream)
-            # unnamed fields will get autogenerated names "_", "_1". "_2", "_3", ...
-            unnamed_index = 0
-            for f in fields:
-                if not f.name:
-                    if unnamed_index:
-                        fieldname = "_%d" % unnamed_index
-                    else:
-                        fieldname = "_"
-                    unnamed_index += 1
-                    print(
-                        f"    # Unnamed field renamed to '{fieldname}'",
-                        file=self.stream,
-                    )
-                else:
-                    fieldname = f.name
-                if f.bits is None:
-                    print(
-                        f"    ('{fieldname}', {self._to_type_name(f.typ)}),",
-                        file=self.stream,
-                    )
-                else:
-                    print(
-                        f"    ('{fieldname}', {self._to_type_name(f.typ)}, {f.bits}),",
-                        file=self.stream,
-                    )
-            print("]", file=self.stream)
-
+            with self.adjust_blank("attribute") as ofi:
+                self._write_structbody_fields(body, fields, ofi)
             if body.struct.size is None:
-                print(file=self.stream)
-                msg = (
-                    "# The size provided by the typelib is incorrect.\n"
-                    "# The size and alignment check for %s is skipped."
-                )
-                print(msg % body.struct.name, file=self.stream)
+                with self.adjust_blank("comment") as ofi:
+                    self._write_structbody_size_comments(body, ofi)
             elif body.struct.name not in packing.dont_assert_size:
-                print(file=self.stream)
-                size = body.struct.size // 8
-                print(
-                    f"assert sizeof({body.struct.name}) == {size}, sizeof({body.struct.name})",
-                    file=self.stream,
-                )
-                align = body.struct.align // 8
-                print(
-                    f"assert alignment({body.struct.name}) == {align}, alignment({body.struct.name})",
-                    file=self.stream,
-                )
-
+                with self.adjust_blank("assert") as ofi:
+                    self._write_structbody_size_assertion(body, ofi)
         if methods:
             self.imports.add("comtypes", "COMMETHOD")
-
-            if not self.last_item_class:
-                print(file=self.stream)
-
-            self.last_item_class = False
-            print(f"{body.struct.name}._methods_ = [", file=self.stream)
-            if body.struct.location:
-                print(f"# {body.struct.location}", file=self.stream)
-
-            for m in methods:
-                if m.location:
-                    print(f"    # {m.location}", file=self.stream)
-                print(
-                    (
-                        f"    COMMETHOD(\n"
-                        f"        [], \n"
-                        f"        {self._to_type_name(m.returns)},\n"
-                        f"        '{m.name}',\n"
-                    ),
-                    file=self.stream,
-                )
-                for a in m.iterArgTypes():
-                    print(f"        ([], {self._to_type_name(a)}),\n", file=self.stream)
-                    print("    ),", file=self.stream)
-            print("]", file=self.stream)
+            with self.adjust_blank("attribute") as ofi:
+                self._write_structbody_commethods(body, methods, ofi)
+
+    def _write_structbody_fields(
+        self,
+        body: typedesc.StructureBody,
+        fields: List[typedesc.Field],
+        ofi: io.StringIO,
+    ) -> None:
+        print(f"{body.struct.name}._fields_ = [", file=ofi)
+        if body.struct.location:
+            print(f"    # {body.struct.location}", file=ofi)
+        # unnamed fields will get autogenerated names "_", "_1". "_2", "_3", ...
+        unnamed_index = 0
+        for f in fields:
+            if not f.name:
+                fieldname = "_" if not unnamed_index else f"_{unnamed_index:d}"
+                unnamed_index += 1
+                print(f"    # Unnamed field renamed to '{fieldname}'", file=ofi)
+            else:
+                fieldname = f.name
+            typename = self._to_type_name(f.typ)
+            if f.bits is None:
+                print(f"    ('{fieldname}', {typename}),", file=ofi)
+            else:
+                print(f"    ('{fieldname}', {typename}, {f.bits}),", file=ofi)
+        print("]", file=ofi)
+
+    def _write_structbody_size_comments(
+        self, body: typedesc.StructureBody, ofi: io.StringIO
+    ) -> None:
+        msg1 = "# The size provided by the typelib is incorrect."
+        msg2 = f"# The size and alignment check for {body.struct.name} is skipped."
+        print(msg1, file=ofi)
+        print(msg2, file=ofi)
+
+    def _write_structbody_size_assertion(
+        self, body: typedesc.StructureBody, ofi: io.StringIO
+    ) -> None:
+        name = body.struct.name
+        assert body.struct.size is not None
+        size = body.struct.size // 8
+        print(f"assert sizeof({name}) == {size}, sizeof({name})", file=ofi)
+        align = body.struct.align // 8
+        print(f"assert alignment({name}) == {align}, alignment({name})", file=ofi)
+
+    def _write_structbody_commethods(
+        self,
+        body: typedesc.StructureBody,
+        methods: List[typedesc.Method],
+        ofi: io.StringIO,
+    ) -> None:
+        print(f"{body.struct.name}._methods_ = [", file=ofi)
+        if body.struct.location:
+            print(f"# {body.struct.location}", file=ofi)
+        for m in methods:
+            if m.location:
+                print(f"    # {m.location}", file=ofi)
+            print(
+                (
+                    "    COMMETHOD(\n"
+                    "        [],\n"
+                    f"        {self._to_type_name(m.returns)},\n"
+                    f"        '{m.name}',\n"
+                ),
+                file=ofi,
+            )
+            for a in m.iterArgTypes():
+                print(f"        ([], {self._to_type_name(a)}),\n", file=ofi)
+                print("    ),", file=ofi)
+        print("]", file=ofi)
 
     ################################################################
     # top-level typedesc generators
@@ -572,25 +500,9 @@ class CodeGenerator(object):
         # Should the '_reg_typelib_' attribute be at top-level in the
         # generated code, instead as being an attribute of the
         # 'Library' symbol?
-        if not self.last_item_class:
-            print(file=self.stream)
-            print(file=self.stream)
-
-        self.last_item_class = True
-
-        print("class Library(object):", file=self.stream)
-        if lib.doc:
-            print(self._to_docstring(lib.doc), file=self.stream)
 
-        if lib.name:
-            print(f"    name = {lib.name!r}", file=self.stream)
-
-        print(
-            f"    _reg_typelib_ = ({lib.guid!r}, {lib.major!r}, {lib.minor!r})",
-            file=self.stream,
-        )
-        print(file=self.stream)
-        print(file=self.stream)
+        with self.adjust_blank("class") as ofi:
+            heads.LibraryHeadWriter(ofi).write(lib)
         self.names.add("Library")
 
     def External(self, ext: typedesc.External) -> None:
@@ -600,12 +512,10 @@ class CodeGenerator(object):
             self.imports.add(modname)
 
     def Constant(self, tp: typedesc.Constant) -> None:
-        self.last_item_class = False
-        print(
-            f"{tp.name} = {tp.value!r}  # Constant {self._to_type_name(tp.typ)}",
-            file=self.stream,
-        )
-        self.names.add(tp.name)
+        with self.adjust_blank("variable") as ofi:
+            type_name = self._to_type_name(tp.typ)
+            print(f"{tp.name} = {tp.value!r}  # Constant {type_name}", file=ofi)
+            self.names.add(tp.name)
 
     def SAFEARRAYType(self, sa: typedesc.SAFEARRAYType) -> None:
         self.generate(sa.typ)
@@ -638,30 +548,8 @@ class CodeGenerator(object):
     def CoClass(self, coclass: typedesc.CoClass) -> None:
         self.imports.add("comtypes", "GUID")
         self.imports.add("comtypes", "CoClass")
-        if not self.last_item_class:
-            print(file=self.stream)
-            print(file=self.stream)
-
-        self.last_item_class = True
-
-        print(f"class {coclass.name}(CoClass):", file=self.stream)
-        if coclass.doc:
-            print(self._to_docstring(coclass.doc), file=self.stream)
-        print(f"    _reg_clsid_ = GUID({coclass.clsid!r})", file=self.stream)
-        print(f"    _idlflags_ = {coclass.idlflags}", file=self.stream)
-        if self.filename is not None:
-            print("    _typelib_path_ = typelib_path", file=self.stream)
-        # X print
-        # >> self.stream, "POINTER(%s).__ctypes_from_outparam__ = wrap" % coclass.name
-
-        libid = coclass.tlibattr.guid
-        wMajor, wMinor = coclass.tlibattr.wMajorVerNum, coclass.tlibattr.wMinorVerNum
-        print(
-            f"    _reg_typelib_ = ({str(libid)!r}, {wMajor}, {wMinor})",
-            file=self.stream,
-        )
-        print(file=self.stream)
-        print(file=self.stream)
+        with self.adjust_blank("class") as ofi:
+            heads.CoClassHeadWriter(ofi, self.filename).write(coclass)
 
         for itf, _ in coclass.interfaces:
             self.generate(itf.get_head())
@@ -669,18 +557,13 @@ class CodeGenerator(object):
         implemented = [self._to_type_name(itf) for itf in impl]
         sources = [self._to_type_name(itf) for itf in src]
 
-        if implemented:
-            self.last_item_class = False
-            print(
-                f"{coclass.name}._com_interfaces_ = [{', '.join(implemented)}]",
-                file=self.stream,
-            )
-        if sources:
-            self.last_item_class = False
-            print(
-                f"{coclass.name}._outgoing_interfaces_ = [{', '.join(sources)}]",
-                file=self.stream,
-            )
+        with self.adjust_blank("attribute") as ofi:
+            if implemented:
+                itfs = ", ".join(implemented)
+                print(f"{coclass.name}._com_interfaces_ = [{itfs}]", file=ofi)
+            if sources:
+                itfs = ", ".join(sources)
+                print(f"{coclass.name}._outgoing_interfaces_ = [{itfs}]", file=ofi)
 
         self.names.add(coclass.name)
 
@@ -741,16 +624,6 @@ class CodeGenerator(object):
             return self.known_interfaces[item.name] == item.iid
         return False
 
-    def _is_enuminterface(self, itf: typedesc.ComInterface) -> bool:
-        # Check if this is an IEnumXXX interface
-        if not itf.name.startswith("IEnum"):
-            return False
-        member_names = [mth.name for mth in itf.members]
-        for name in ("Next", "Skip", "Reset", "Clone"):
-            if name not in member_names:
-                return False
-        return True
-
     def ComInterfaceHead(self, head: typedesc.ComInterfaceHead) -> None:
         if head.itf.base is None:
             # we don't beed to generate IUnknown
@@ -761,49 +634,8 @@ class CodeGenerator(object):
 
         self.imports.add("comtypes", "GUID")
 
-        if not self.last_item_class:
-            print(file=self.stream)
-            print(file=self.stream)
-
-        self.last_item_class = True
-
-        print(f"class {head.itf.name}({basename}):", file=self.stream)
-        if head.itf.doc:
-            print(self._to_docstring(head.itf.doc), file=self.stream)
-
-        print("    _case_insensitive_ = True", file=self.stream)
-        print(f"    _iid_ = GUID({head.itf.iid!r})", file=self.stream)
-        print(f"    _idlflags_ = {head.itf.idlflags}", file=self.stream)
-
-        if self._is_enuminterface(head.itf):
-            print(file=self.stream)
-            print("    def __iter__(self):", file=self.stream)
-            print("        return self", file=self.stream)
-            print(file=self.stream)
-
-            print("    def __next__(self):", file=self.stream)
-            print("        item, fetched = self.Next(1)", file=self.stream)
-            print("        if fetched:", file=self.stream)
-            print("            return item", file=self.stream)
-            print("        raise StopIteration", file=self.stream)
-            print(file=self.stream)
-
-            print("    def __getitem__(self, index):", file=self.stream)
-            print("        self.Reset()", file=self.stream)
-            print("        self.Skip(index)", file=self.stream)
-            print("        item, fetched = self.Next(1)", file=self.stream)
-            print("        if fetched:", file=self.stream)
-            print("            return item", file=self.stream)
-            print("        raise IndexError(index)", file=self.stream)
-
-        annotations = typeannotator.ComInterfaceMembersAnnotator(head.itf).generate()
-        if annotations:
-            print(file=self.stream)
-            print("    if TYPE_CHECKING:  # commembers", file=self.stream)
-            print(annotations, file=self.stream)
-
-        print(file=self.stream)
-        print(file=self.stream)
+        with self.adjust_blank("class") as ofi:
+            heads.ComInterfaceHeadWriter(ofi).write(head, basename)
 
     def ComInterfaceBody(self, body: typedesc.ComInterfaceBody) -> None:
         # The base class must be fully generated, including the
@@ -816,88 +648,19 @@ class CodeGenerator(object):
                 self.generate(a[0])
             self.generate(m.returns)
 
-        if not self.last_item_class:
-            print(file=self.stream)
-
-        self.last_item_class = False
-        print(f"{body.itf.name}._methods_ = [", file=self.stream)
-        for m in body.itf.members:
-            if isinstance(m, typedesc.ComMethod):
-                self.make_ComMethod(m, "dual" in body.itf.idlflags)
-            else:
-                raise TypeError("what's this?")
-
-        print("]", file=self.stream)
-        print(file=self.stream)
-        print(
-            "################################################################",
-            file=self.stream,
-        )
-        print(f"# code template for {body.itf.name} implementation", file=self.stream)
-        print(f"# class {body.itf.name}_Impl(object):", file=self.stream)
-
-        methods = {}
-        for m in body.itf.members:
-            if isinstance(m, typedesc.ComMethod):
-                # m.arguments is a sequence of tuples:
-                # (argtype, argname, idlflags, docstring)
-                # Some typelibs have unnamed method parameters!
-                inargs = [a[1] or "<unnamed>" for a in m.arguments if not "out" in a[2]]
-                outargs = [a[1] or "<unnamed>" for a in m.arguments if "out" in a[2]]
-                if "propget" in m.idlflags:
-                    methods.setdefault(m.name, [0, inargs, outargs, m.doc])[0] |= 1
-                elif "propput" in m.idlflags:
-                    methods.setdefault(m.name, [0, inargs[:-1], inargs[-1:], m.doc])[
-                        0
-                    ] |= 2
+        with self.adjust_blank("attribute") as ofi:
+            print(f"{body.itf.name}._methods_ = [", file=ofi)
+            for m in body.itf.members:
+                if isinstance(m, typedesc.ComMethod):
+                    isdual = "dual" in body.itf.idlflags
+                    print(ComMethodGenerator(m, isdual).generate(), file=ofi)
+                    self.add_ComMth_requirements(m, isdual)
                 else:
-                    methods[m.name] = [0, inargs, outargs, m.doc]
+                    raise TypeError("what's this?")
 
-        for name, (typ, inargs, outargs, doc) in methods.items():
-            if typ == 0:  # method
-                print(
-                    f"#     def {name}({', '.join(['self'] + inargs)}):",
-                    file=self.stream,
-                )
-                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
-                print(f"#         #return {', '.join(outargs)}", file=self.stream)
-            elif typ == 1:  # propget
-                print("#     @property", file=self.stream)
-                print(
-                    f"#     def {name}({', '.join(['self'] + inargs)}):",
-                    file=self.stream,
-                )
-                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
-                print(f"#         #return {', '.join(outargs)}", file=self.stream)
-            elif typ == 2:  # propput
-                print(
-                    f"#     def _set({', '.join(['self'] + inargs + outargs)}):",
-                    file=self.stream,
-                )
-                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
-                print(
-                    f"#     {name} = property(fset = _set, doc = _set.__doc__)",
-                    file=self.stream,
-                )
-            elif typ == 3:  # propget + propput
-                print(
-                    f"#     def _get({', '.join(['self'] + inargs)}):",
-                    file=self.stream,
-                )
-                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
-                print(f"#         #return {', '.join(outargs)}", file=self.stream)
-                print(
-                    f"#     def _set({', '.join(['self'] + inargs + outargs)}):",
-                    file=self.stream,
-                )
-                print(f"#         {(doc or '-no docstring-')!r}", file=self.stream)
-                print(
-                    f"#     {name} = property(_get, _set, doc = _set.__doc__)",
-                    file=self.stream,
-                )
-            else:
-                raise RuntimeError("BUG")
-            print("#", file=self.stream)
+            print("]", file=ofi)
+        print(file=self.stream)
+        ComInterfaceBodyImplCommentWriter(self.stream).write(body)
 
     def DispInterface(self, itf: typedesc.DispInterface) -> None:
         self.generate(itf.get_head())
@@ -909,28 +672,9 @@ class CodeGenerator(object):
         basename = self._to_type_name(head.itf.base)
 
         self.imports.add("comtypes", "GUID")
-        if not self.last_item_class:
-            print(file=self.stream)
-            print(file=self.stream)
-
-        self.last_item_class = True
 
-        print(f"class {head.itf.name}({basename}):", file=self.stream)
-        if head.itf.doc:
-            print(self._to_docstring(head.itf.doc), file=self.stream)
-        print("    _case_insensitive_ = True", file=self.stream)
-        print(f"    _iid_ = GUID({head.itf.iid!r})", file=self.stream)
-        print(f"    _idlflags_ = {head.itf.idlflags}", file=self.stream)
-        print("    _methods_ = []", file=self.stream)
-
-        annotations = typeannotator.DispInterfaceMembersAnnotator(head.itf).generate()
-        if annotations:
-            print(file=self.stream)
-            print("    if TYPE_CHECKING:  # dispmembers", file=self.stream)
-            print(annotations, file=self.stream)
-
-        print(file=self.stream)
-        print(file=self.stream)
+        with self.adjust_blank("class") as ofi:
+            heads.DispInterfaceHeadWriter(ofi).write(head, basename)
 
     def DispInterfaceBody(self, body: typedesc.DispInterfaceBody) -> None:
         # make sure we can generate the body
@@ -943,34 +687,28 @@ class CodeGenerator(object):
                 self.generate(m.typ)
             else:
                 raise TypeError(m)
-
-        if not self.last_item_class:
-            print(file=self.stream)
-
-        self.last_item_class = False
-
-        print(f"{body.itf.name}._disp_methods_ = [", file=self.stream)
-        for m in body.itf.members:
-            if isinstance(m, typedesc.DispMethod):
-                self.make_DispMethod(m)
-            elif isinstance(m, typedesc.DispProperty):
-                self.make_DispProperty(m)
-            else:
-                raise TypeError(m)
-        print("]", file=self.stream)
+        with self.adjust_blank("attribute") as ofi:
+            print(f"{body.itf.name}._disp_methods_ = [", file=ofi)
+            for m in body.itf.members:
+                if isinstance(m, typedesc.DispMethod):
+                    print(DispMethodGenerator(m).generate(), file=ofi)
+                    self.add_DispMth_requirements(m)
+                elif isinstance(m, typedesc.DispProperty):
+                    print(DispPropertyGenerator(m).generate(), file=ofi)
+                    self.add_DispProp_requirements(m)
+                else:
+                    raise TypeError(m)
+            print("]", file=ofi)
 
     ################################################################
-    # non-toplevel method generators
+    # non-toplevel method requirements
     #
-    def make_ComMethod(self, m: typedesc.ComMethod, isdual: bool) -> None:
+    def add_ComMth_requirements(self, m: typedesc.ComMethod, isdual: bool) -> None:
         self.imports.add("comtypes", "COMMETHOD")
         if isdual:
             self.imports.add("comtypes", "dispid")
         if __debug__ and m.doc:
             self.imports.add("comtypes", "helpstring")
-        gen = ComMethodGenerator(m, isdual)
-        print(gen.generate(), file=self.stream)
-        self.last_item_class = False
         for typ, _, _, default in m.arguments:
             if isinstance(typ, typedesc.ComInterface):
                 self.declarations.add(
@@ -981,23 +719,17 @@ class CodeGenerator(object):
             if default is not None:
                 self.need_VARIANT_imports(default)
 
-    def make_DispMethod(self, m: typedesc.DispMethod) -> None:
+    def add_DispMth_requirements(self, m: typedesc.DispMethod) -> None:
         self.imports.add("comtypes", "DISPMETHOD")
         self.imports.add("comtypes", "dispid")
         if __debug__ and m.doc:
             self.imports.add("comtypes", "helpstring")
-        gen = DispMethodGenerator(m)
-        print(gen.generate(), file=self.stream)
-        self.last_item_class = False
         for _, _, _, default in m.arguments:
             if default is not None:
                 self.need_VARIANT_imports(default)
 
-    def make_DispProperty(self, prop: typedesc.DispProperty) -> None:
+    def add_DispProp_requirements(self, prop: typedesc.DispProperty) -> None:
         self.imports.add("comtypes", "DISPPROPERTY")
         self.imports.add("comtypes", "dispid")
         if __debug__ and prop.doc:
             self.imports.add("comtypes", "helpstring")
-        gen = DispPropertyGenerator(prop)
-        print(gen.generate(), file=self.stream)
-        self.last_item_class = False