diff --git a/compiler/back_end/cpp/header_generator.py b/compiler/back_end/cpp/header_generator.py
index e599585..6a66461 100644
--- a/compiler/back_end/cpp/header_generator.py
+++ b/compiler/back_end/cpp/header_generator.py
@@ -188,7 +188,7 @@
 
 
 def _get_namespace_components(namespace):
-    """Gets the components of a C++ namespace
+    """Gets the components of a C++ namespace.
 
     Examples:
       "::some::name::detail" -> ["some", "name", "detail"]
@@ -1339,10 +1339,12 @@
     Arguments:
       type_ir: The IR for the struct definition.
       ir: The full IR; used for type lookups.
+      config: The code generation configuration to use.
 
     Returns:
-      A tuple of: (forward declaration for classes, class bodies, method bodies),
-      suitable for insertion into the appropriate places in the generated header.
+      A tuple of: (forward declaration for classes, class bodies, method
+      bodies), suitable for insertion into the appropriate places in the
+      generated header.
     """
     subtype_bodies, subtype_forward_declarations, subtype_method_definitions = (
         _generate_subtype_definitions(type_ir, ir, config)
@@ -1530,10 +1532,17 @@
 def _split_enum_case_values_into_spans(enum_case_value):
     """Yields spans containing each enum case in an enum_case attribute value.
 
-    Each span is of the form (start, end), which is the start and end position
-    relative to the beginning of the enum_case_value string. To keep the grammar
-    of this attribute simple, this only splits on delimiters and trims whitespace
-    for each case.
+    Arguments:
+        enum_case_value: the value of the `enum_case` attribute to be parsed.
+
+    Returns:
+        An iterator over spans, where each span covers one enum case name.
+        Each span is a half-open range of the form [start, end), which is the
+        start and end position relative to the beginning of the enum_case_value
+        string.  The name can be retrieved with `enum_case_value[start:end]`.
+
+        To keep the grammar of this attribute simple, this only splits on
+        delimiters and trims whitespace for each case.
 
     Example: 'SHOUTY_CASE, kCamelCase' -> [(0, 11), (13, 23)]"""
     # Scan the string from left to right, finding commas and trimming whitespace.
@@ -1568,6 +1577,12 @@
 def _split_enum_case_values(enum_case_value):
     """Returns all enum cases in an enum case value.
 
+    Arguments:
+        enum_case_value: the value of the enum case attribute to parse.
+
+    Returns:
+        All enum case names from `enum_case_value`.
+
     Example: 'SHOUTY_CASE, kCamelCase' -> ['SHOUTY_CASE', 'kCamelCase']"""
     return [
         enum_case_value[start:end]
@@ -1576,7 +1591,7 @@
 
 
 def _get_enum_value_names(enum_value):
-    """Determines one or more enum names based on attributes"""
+    """Determines one or more enum names based on attributes."""
     cases = ["SHOUTY_CASE"]
     name = enum_value.name.name.text
     if enum_case := ir_util.get_attribute(
@@ -1698,14 +1713,16 @@
     Traverses the IR to propagate default values to target nodes.
 
     Arguments:
-      targets: A list of target IR types to add attributes to.
-      ancestors: Ancestor types which may contain the default values.
-      add_fn: Function to add the attribute. May use any parameter available in
-        fast_traverse_ir_top_down actions as well as `defaults` containing the
-        default attributes set by ancestors.
+        ir: The IR to process.
+        targets: A list of target IR types to add attributes to.
+        ancestors: Ancestor types which may contain the default values.
+        add_fn: Function to add the attribute. May use any parameter available
+            in fast_traverse_ir_top_down actions as well as `defaults`
+            containing the
+            default attributes set by ancestors.
 
     Returns:
-      None
+        None
     """
     traverse_ir.fast_traverse_ir_top_down(
         ir,
@@ -1719,14 +1736,19 @@
 
 
 def _offset_source_location_column(source_location, offset):
-    """Adds offsets from the start column of the supplied source location
+    """Adds offsets from the start column of the supplied source location.
 
-    Returns a new source location with all of the same properties as the provided
-    source location, but with the columns modified by offsets from the original
-    start column.
+    Arguments:
+        source_location: the initial source location
+        offset: a tuple of (start, end), which are the offsets relative to
+            source_location.start.column to set the new start.column and
+            end.column.
 
-    Offset should be a tuple of (start, end), which are the offsets relative to
-    source_location.start.column to set the new start.column and end.column."""
+    Returns:
+        A new source location with all of the same properties as the provided
+        source location, but with the columns modified by offsets from the
+        original start column.
+    """
 
     new_location = ir_data_utils.copy(source_location)
     new_location.start.column = source_location.start.column + offset[0]
@@ -1863,8 +1885,12 @@
 def _propagate_defaults_and_verify_attributes(ir):
     """Verify attributes and ensure defaults are set when not overridden.
 
-    Returns a list of errors if there are errors present, or an empty list if
-    verification completed successfully."""
+    Arguments:
+        ir: The IR to process.
+
+    Returns:
+        A list of errors if there are errors present, or an empty list if
+        verification completed successfully."""
     if errors := attribute_util.check_attributes_in_ir(
         ir,
         back_end="cpp",
diff --git a/compiler/back_end/util/code_template_test.py b/compiler/back_end/util/code_template_test.py
index e4354fe..8149aaa 100644
--- a/compiler/back_end/util/code_template_test.py
+++ b/compiler/back_end/util/code_template_test.py
@@ -55,7 +55,7 @@
     """Tests for code_template.parse_templates."""
 
     def assertTemplatesEqual(self, expected, actual):  # pylint:disable=invalid-name
-        """Compares the results of a parse_templates"""
+        """Compares the results of a parse_templates."""
         # Extract the name and template from the result tuple
         actual = {k: v.template for k, v in actual._asdict().items()}
         self.assertEqual(expected, actual)
diff --git a/compiler/front_end/attribute_checker.py b/compiler/front_end/attribute_checker.py
index 78a2a1e..9c867d2 100644
--- a/compiler/front_end/attribute_checker.py
+++ b/compiler/front_end/attribute_checker.py
@@ -44,6 +44,7 @@
 
 
 def _valid_back_ends(attr, module_source_file):
+    """Checks that `attr` holds a valid list of back end specifiers."""
     if not re.fullmatch(
         r"(?:\s*[a-z][a-z0-9_]*\s*(?:,\s*[a-z][a-z0-9_]*\s*)*,?)?\s*",
         attr.value.string_constant.text,
diff --git a/compiler/front_end/constraints.py b/compiler/front_end/constraints.py
index 3249e6d..852c9ad 100644
--- a/compiler/front_end/constraints.py
+++ b/compiler/front_end/constraints.py
@@ -436,6 +436,7 @@
 
 
 def _check_allowed_in_bits(type_ir, type_definition, source_file_name, ir, errors):
+    """Verifies that atomic fields have types that are allowed in `bits`."""
     if not type_ir.HasField("atomic_type"):
         return
     referenced_type_definition = ir_util.find_object(type_ir.atomic_type.reference, ir)
diff --git a/compiler/front_end/dependency_checker.py b/compiler/front_end/dependency_checker.py
index 8a9e903..fb622e1 100644
--- a/compiler/front_end/dependency_checker.py
+++ b/compiler/front_end/dependency_checker.py
@@ -23,14 +23,15 @@
 def _add_reference_to_dependencies(
     reference, dependencies, name, source_file_name, errors
 ):
+    """Adds the specified `reference` to the `dependencies` set."""
     if reference.canonical_name.object_path[0] in {
         "$is_statically_sized",
         "$static_size_in_bits",
         "$next",
     }:
-        # This error is a bit opaque, but given that the compiler used to crash on
-        # this case -- for a couple of years -- and no one complained, it seems
-        # safe to assume that this is a rare error.
+        # This error is a bit opaque, but given that the compiler used to crash
+        # on this case -- for a couple of years -- and no one complained, it
+        # seems safe to assume that this is a rare error.
         errors.append(
             [
                 error.error(
diff --git a/compiler/front_end/format_emb.py b/compiler/front_end/format_emb.py
index df9bcf3..fc7bf94 100644
--- a/compiler/front_end/format_emb.py
+++ b/compiler/front_end/format_emb.py
@@ -485,6 +485,7 @@
     "               type-definition* struct-field-block Dedent"
 )
 def _structure_body(indent, docs, attributes, type_definitions, fields, dedent, config):
+    """Formats a structure (`bits` or `struct`) body."""
     del indent, dedent  # Unused.
     spacing = [_Row("field-separator")] if _should_add_blank_lines(fields) else []
     columnized_fields = _columnize(fields, config.indent_width, indent_columns=2)
@@ -609,6 +610,7 @@
     '    field-location "bits" ":" Comment? eol anonymous-bits-body'
 )
 def _inline_bits(location, bits, colon, comment, eol, body):
+    """Formats an inline `bits` definition."""
     # Even though an anonymous bits field technically defines a new, anonymous
     # type, conceptually it's more like defining a bunch of fields on the
     # surrounding type, so it is treated as an inline list of blocks, instead of
@@ -1017,6 +1019,7 @@
 @_formats("or-expression-right -> or-operator comparison-expression")
 @_formats("and-expression-right -> and-operator comparison-expression")
 def _concatenate_with_prefix_spaces(*elements):
+    """Concatenates non-empty `elements` with leading spaces."""
     return "".join(" " + element for element in elements if element)
 
 
@@ -1032,10 +1035,12 @@
 )
 @_formats('parameter-definition-list-tail -> "," parameter-definition')
 def _concatenate_with_spaces(*elements):
+    """Concatenates non-empty `elements` with spaces between."""
     return _concatenate_with(" ", *elements)
 
 
 def _concatenate_with(joiner, *elements):
+    """Concatenates non-empty `elements` with `joiner` between."""
     return joiner.join(element for element in elements if element)
 
 
diff --git a/compiler/front_end/lr1.py b/compiler/front_end/lr1.py
index be99f95..579d729 100644
--- a/compiler/front_end/lr1.py
+++ b/compiler/front_end/lr1.py
@@ -36,16 +36,17 @@
 ):
     """An Item is an LR(1) Item: a production, a cursor location, and a terminal.
 
-    An Item represents a partially-parsed production, and a lookahead symbol.  The
-    position of the dot indicates what portion of the production has been parsed.
-    Generally, Items are an internal implementation detail, but they can be useful
-    elsewhere, particularly for debugging.
+    An Item represents a partially-parsed production, and a lookahead symbol.
+    The position of the dot indicates what portion of the production has been
+    parsed.  Generally, Items are an internal implementation detail, but they
+    can be useful elsewhere, particularly for debugging.
 
     Attributes:
-      production: The Production this Item covers.
-      dot: The index of the "dot" in production's rhs.
-      terminal: The terminal lookahead symbol that follows the production in the
-          input stream.
+        production: The Production this Item covers.
+        dot: The index of the "dot" in production's rhs.
+        terminal: The terminal lookahead symbol that follows the production in
+            the input stream.
+        next_symbol: The lookahead symbol.
     """
 
     def __str__(self):
diff --git a/compiler/front_end/module_ir.py b/compiler/front_end/module_ir.py
index bd27c8a..4a459c2 100644
--- a/compiler/front_end/module_ir.py
+++ b/compiler/front_end/module_ir.py
@@ -339,6 +339,7 @@
     attribute_value,
     close_bracket,
 ):
+    """Assembles an attribute IR node."""
     del open_bracket, colon, close_bracket  # Unused.
     if context_specifier.list:
         return ir_data.Attribute(
@@ -460,14 +461,15 @@
     '                                        ":" logical-expression'
 )
 def _choice_expression(condition, question, if_true, colon, if_false):
+    """Constructs an IR node for a choice operator (`?:`) expression."""
     location = parser_types.make_location(
         condition.source_location.start, if_false.source_location.end
     )
     operator_location = parser_types.make_location(
         question.source_location.start, colon.source_location.end
     )
-    # The function_name is a bit weird, but should suffice for any error messages
-    # that might need it.
+    # The function_name is a bit weird, but should suffice for any error
+    # messages that might need it.
     return ir_data.Expression(
         function=ir_data.Function(
             function=ir_data.FunctionMapping.CHOICE,
@@ -1284,6 +1286,7 @@
 def _enum_value(
     name, equals, expression, attribute, documentation, comment, newline, body
 ):
+    """Constructs an IR node for an enum value statement (`NAME = value`)."""
     del equals, comment, newline  # Unused.
     result = ir_data.EnumValue(
         name=name,
diff --git a/compiler/front_end/synthetics.py b/compiler/front_end/synthetics.py
index 1b331a3..f55e32f 100644
--- a/compiler/front_end/synthetics.py
+++ b/compiler/front_end/synthetics.py
@@ -236,6 +236,7 @@
 def _maybe_replace_next_keyword_in_expression(
     expression_ir, last_location, source_file_name, errors
 ):
+    """Replaces the `$next` keyword in an expression."""
     if not expression_ir.HasField("builtin_reference"):
         return
     if (
diff --git a/compiler/front_end/type_check.py b/compiler/front_end/type_check.py
index f562cc8..c3f7870 100644
--- a/compiler/front_end/type_check.py
+++ b/compiler/front_end/type_check.py
@@ -133,6 +133,7 @@
 
 
 def _type_check_operation(expression, source_file_name, ir, errors):
+    """Type checks a function or operator expression."""
     for arg in expression.function.args:
         _type_check_expression(arg, source_file_name, ir, errors)
     function = expression.function.function
diff --git a/compiler/util/attribute_util.py b/compiler/util/attribute_util.py
index a83cf51..2ebbffa 100644
--- a/compiler/util/attribute_util.py
+++ b/compiler/util/attribute_util.py
@@ -323,22 +323,24 @@
 ):
     """Performs basic checks on the given list of attributes.
 
-    Checks the given attribute_list for duplicates, unknown attributes, attributes
-    with incorrect type, and attributes whose values are not constant.
+    Checks the given attribute_list for duplicates, unknown attributes,
+    attributes with incorrect type, and attributes whose values are not
+    constant.
 
     Arguments:
-      attribute_list: An iterable of ir_data.Attribute.
-      back_end: The qualifier for attributes to check, or None.
-      attribute_specs: A dict of attribute names to _Attribute structures
-        specifying the allowed attributes.
-      context_name: A name for the context of these attributes, such as "struct
-        'Foo'" or "module 'm.emb'".  Used in error messages.
-      module_source_file: The value of module.source_file_name from the module
-        containing 'attribute_list'.  Used in error messages.
+        attribute_list: An iterable of ir_data.Attribute.
+        types: A map of attribute types to validators.
+        back_end: The qualifier for attributes to check, or None.
+        attribute_specs: A dict of attribute names to _Attribute structures
+            specifying the allowed attributes.
+        context_name: A name for the context of these attributes, such as
+            "struct 'Foo'" or "module 'm.emb'".  Used in error messages.
+        module_source_file: The value of module.source_file_name from the module
+            containing 'attribute_list'.  Used in error messages.
 
     Returns:
-      A list of lists of error.Errors.  An empty list indicates no errors were
-      found.
+        A list of lists of error.Errors.  An empty list indicates no errors were
+        found.
     """
     if attribute_specs is None:
         attribute_specs = []
@@ -395,17 +397,17 @@
 
 
 def gather_default_attributes(obj, defaults):
-    """Gathers default attributes for an IR object
+    """Gathers default attributes for an IR object.
 
-    This is designed to be able to be used as-is as an incidental action in an IR
-    traversal to accumulate defaults for child nodes.
+    This is designed to be able to be used as-is as an incidental action in an
+    IR traversal to accumulate defaults for child nodes.
 
     Arguments:
-      defaults: A dict of `{ "defaults": { attr.name.text: attr } }`
+        defaults: A dict of `{ "defaults": { attr.name.text: attr } }`
 
     Returns:
-      A dict of `{ "defaults": { attr.name.text: attr } }` with any defaults
-      provided by `obj` added/overridden.
+        A dict of `{ "defaults": { attr.name.text: attr } }` with any defaults
+        provided by `obj` added/overridden.
     """
     defaults = defaults.copy()
     for attr in obj.attribute:
diff --git a/compiler/util/ir_data.py b/compiler/util/ir_data.py
index af8c2f7..fda124e 100644
--- a/compiler/util/ir_data.py
+++ b/compiler/util/ir_data.py
@@ -110,7 +110,10 @@
     def WhichOneof(self, oneof_name):  # pylint:disable=invalid-name
         """Indicates which field has been set for the oneof value.
 
-        Returns None if no field has been set.
+        Args:
+            oneof_name: the name of the oneof construct to test.
+
+        Returns: the field name, or None if no field has been set.
         """
         for field_name, oneof in self.field_specs.oneof_mappings:
             if oneof == oneof_name and self.HasField(field_name):
@@ -207,7 +210,7 @@
 
 
 class FunctionMapping(int, enum.Enum):
-    """Enum of supported function types"""
+    """Enum of supported function types."""
 
     UNKNOWN = 0
     ADDITION = 1
@@ -823,8 +826,9 @@
 
 
 class AddressableUnit(int, enum.Enum):
-    """The "addressable unit" is the size of the smallest unit that can be read
+    """The 'atom size' for a structure.
 
+    The "addressable unit" is the size of the smallest unit that can be read
     from the backing store that this type expects.  For `struct`s, this is
     BYTE; for `enum`s and `bits`, this is BIT, and for `external`s it depends
     on the specific type
diff --git a/compiler/util/ir_data_fields.py b/compiler/util/ir_data_fields.py
index 002ea3b..248518b 100644
--- a/compiler/util/ir_data_fields.py
+++ b/compiler/util/ir_data_fields.py
@@ -76,10 +76,10 @@
 
 
 class CopyValuesList(list[CopyValuesListT]):
-    """A list that makes copies of any value that is inserted"""
+    """A list that makes copies of any value that is inserted."""
 
     def __init__(
-        self, value_type: CopyValuesListT, iterable: Optional[Iterable] = None
+        self, value_type: CopyValuesListT, iterable: Optional[Iterable[Any]] = None
     ):
         if iterable:
             super().__init__(iterable)
@@ -96,7 +96,7 @@
         return super().extend([self._copy(i) for i in iterable])
 
     def shallow_copy(self, iterable: Iterable) -> None:
-        """Explicitly performs a shallow copy of the provided list"""
+        """Explicitly performs a shallow copy of the provided list."""
         return super().extend(iterable)
 
     def append(self, obj: Any) -> None:
@@ -107,15 +107,13 @@
 
 
 class TemporaryCopyValuesList(NamedTuple):
-    """Class used to temporarily hold a CopyValuesList while copying and
-    constructing an IR dataclass.
-    """
+    """Holder for a CopyValuesList while copying/constructing an IR dataclass."""
 
     temp_list: CopyValuesList
 
 
 class FieldContainer(enum.Enum):
-    """Indicates a fields container type"""
+    """Indicates a fields container type."""
 
     NONE = 0
     OPTIONAL = 1
@@ -125,8 +123,8 @@
 class FieldSpec(NamedTuple):
     """Indicates the container and type of a field.
 
-    `FieldSpec` objects are accessed millions of times during runs so we cache as
-    many operations as possible.
+    `FieldSpec` objects are accessed millions of times during runs so we cache
+    as many operations as possible.
       - `is_dataclass`: `dataclasses.is_dataclass(data_type)`
       - `is_sequence`: `container is FieldContainer.LIST`
       - `is_enum`: `issubclass(data_type, enum.Enum)`
@@ -162,7 +160,7 @@
 
 
 def build_default(field_spec: FieldSpec):
-    """Builds a default instance of the given field"""
+    """Builds a default instance of the given field."""
     if field_spec.is_sequence:
         return CopyValuesList(field_spec.data_type)
     if field_spec.is_enum:
@@ -216,11 +214,20 @@
 
 
 def cache_message_specs(mod, cls):
-    """Adds a cached `field_specs` attribute to IR dataclasses in `mod`
-    excluding the given base `cls`.
+    """Adds `field_specs` to `mod`, excluding `cls`.
+
+    Adds a cached `field_specs` attribute to IR dataclasses in module `mod`
+    excluding the given base class `cls`.
 
     This needs to be done after the dataclass decorators run and create the
     wrapped classes.
+
+    Arguments:
+        mod: The module to process.
+        cls: The base class to exclude.
+
+    Returns:
+        None
     """
     for data_class in all_ir_classes(mod):
         if data_class is not cls:
@@ -228,7 +235,7 @@
 
 
 def _field_specs(cls: type[IrDataT]) -> Mapping[str, FieldSpec]:
-    """Gets the IR data field names and types for the given IR data class"""
+    """Gets the IR data field names and types for the given IR data class."""
     # Get the dataclass fields
     class_fields = dataclasses.fields(cast(Any, cls))
 
@@ -287,6 +294,12 @@
     """Retrieves the fields specs for the the give data type.
 
     The results of this method are cached to reduce lookup overhead.
+
+    Arguments:
+        obj: Either an IR dataclass type, or an instance of such a type.
+
+    Returns:
+        The field specs for `obj`.
     """
     cls = obj if isinstance(obj, type) else type(obj)
     if cls is type(None):
@@ -301,8 +314,11 @@
     """Retrieves the fields and their values for a given IR data class.
 
     Args:
-      ir: The IR data class or a read-only wrapper of an IR data class.
-      value_filt: Optional filter used to exclude values.
+        ir: The IR data class or a read-only wrapper of an IR data class.
+        value_filt: Optional filter used to exclude values.
+
+    Returns:
+        None
     """
     set_fields: list[Tuple[FieldSpec, Any]] = []
     specs: FilteredIrFieldSpecs = ir.field_specs
@@ -329,6 +345,7 @@
 # 5. None checks are only done in `copy()`, `_copy_set_fields` only
 #    references `_copy()` to avoid this step.
 def _copy_set_fields(ir: IrDataT):
+    """Deep copies fields from IR node `ir`."""
     values: MutableMapping[str, Any] = {}
 
     specs: FilteredIrFieldSpecs = ir.field_specs
@@ -355,7 +372,7 @@
 
 
 def copy(ir: IrDataT) -> Optional[IrDataT]:
-    """Creates a copy of the given IR data class"""
+    """Creates a copy of the given IR data class."""
     if not ir:
         return None
     return _copy(ir)
@@ -413,14 +430,14 @@
 
 
 def oneof_field(name: str):
-    """Alternative for `datclasses.field` that sets up a oneof variable"""
+    """Alternative for `datclasses.field` that sets up a oneof variable."""
     return dataclasses.field(  # pylint:disable=invalid-field-call
         default=OneOfField(name), metadata={"oneof": name}, init=True
     )
 
 
 def str_field():
-    """Helper used to define a defaulted str field"""
+    """Helper used to define a defaulted str field."""
     return dataclasses.field(default_factory=str)  # pylint:disable=invalid-field-call
 
 
@@ -436,7 +453,10 @@
     ```
 
     Args:
-      cls_or_fn: The class type or a function that resolves to the class type.
+        cls_or_fn: The class type or a function that resolves to the class type.
+
+    Returns:
+        A field with a `default_factory` that produces an appropriate list.
     """
 
     def list_factory(c):
diff --git a/compiler/util/ir_data_fields_test.py b/compiler/util/ir_data_fields_test.py
index 2853fde..103c1ad 100644
--- a/compiler/util/ir_data_fields_test.py
+++ b/compiler/util/ir_data_fields_test.py
@@ -34,12 +34,12 @@
 
 @dataclasses.dataclass
 class Opaque(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
 
 @dataclasses.dataclass
 class ClassWithUnion(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
     opaque: Optional[Opaque] = ir_data_fields.oneof_field("type")
     integer: Optional[int] = ir_data_fields.oneof_field("type")
@@ -50,7 +50,7 @@
 
 @dataclasses.dataclass
 class ClassWithTwoUnions(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
     opaque: Optional[Opaque] = ir_data_fields.oneof_field("type_1")
     integer: Optional[int] = ir_data_fields.oneof_field("type_1")
@@ -62,7 +62,7 @@
 
 @dataclasses.dataclass
 class NestedClass(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
     one_union_class: Optional[ClassWithUnion] = None
     two_union_class: Optional[ClassWithTwoUnions] = None
@@ -78,7 +78,7 @@
 
 @dataclasses.dataclass
 class OneofFieldTest(ir_data.Message):
-    """Basic test class for oneof fields"""
+    """Basic test class for oneof fields."""
 
     int_field_1: Optional[int] = ir_data_fields.oneof_field("type_1")
     int_field_2: Optional[int] = ir_data_fields.oneof_field("type_1")
@@ -86,7 +86,7 @@
 
 
 class OneOfTest(unittest.TestCase):
-    """Tests for the the various oneof field helpers"""
+    """Tests for the the various oneof field helpers."""
 
     def test_field_attribute(self):
         """Test the `oneof_field` helper."""
@@ -97,48 +97,48 @@
         self.assertEqual(test_field.metadata.get("oneof"), "type_1")
 
     def test_init_default(self):
-        """Test creating an instance with default fields"""
+        """Test creating an instance with default fields."""
         one_of_field_test = OneofFieldTest()
         self.assertIsNone(one_of_field_test.int_field_1)
         self.assertIsNone(one_of_field_test.int_field_2)
         self.assertTrue(one_of_field_test.normal_field)
 
     def test_init(self):
-        """Test creating an instance with non-default fields"""
+        """Test creating an instance with non-default fields."""
         one_of_field_test = OneofFieldTest(int_field_1=10, normal_field=False)
         self.assertEqual(one_of_field_test.int_field_1, 10)
         self.assertIsNone(one_of_field_test.int_field_2)
         self.assertFalse(one_of_field_test.normal_field)
 
     def test_set_oneof_field(self):
-        """Tests setting oneof fields causes others in the group to be unset"""
+        """Tests setting oneof fields causes others in the group to be unset."""
         one_of_field_test = OneofFieldTest()
         one_of_field_test.int_field_1 = 10
         self.assertEqual(one_of_field_test.int_field_1, 10)
-        self.assertEqual(one_of_field_test.int_field_2, None)
+        self.assertIsNone(one_of_field_test.int_field_2)
         one_of_field_test.int_field_2 = 20
-        self.assertEqual(one_of_field_test.int_field_1, None)
+        self.assertIsNone(one_of_field_test.int_field_1)
         self.assertEqual(one_of_field_test.int_field_2, 20)
 
         # Do it again
         one_of_field_test.int_field_1 = 10
         self.assertEqual(one_of_field_test.int_field_1, 10)
-        self.assertEqual(one_of_field_test.int_field_2, None)
+        self.assertIsNone(one_of_field_test.int_field_2)
         one_of_field_test.int_field_2 = 20
-        self.assertEqual(one_of_field_test.int_field_1, None)
+        self.assertIsNone(one_of_field_test.int_field_1)
         self.assertEqual(one_of_field_test.int_field_2, 20)
 
-        # Now create a new instance and make sure changes to it are not reflected
-        # on the original object.
+        # Now create a new instance and make sure changes to it are not
+        # reflected on the original object.
         one_of_field_test_2 = OneofFieldTest()
         one_of_field_test_2.int_field_1 = 1000
         self.assertEqual(one_of_field_test_2.int_field_1, 1000)
-        self.assertEqual(one_of_field_test_2.int_field_2, None)
-        self.assertEqual(one_of_field_test.int_field_1, None)
+        self.assertIsNone(one_of_field_test_2.int_field_2)
+        self.assertIsNone(one_of_field_test.int_field_1)
         self.assertEqual(one_of_field_test.int_field_2, 20)
 
     def test_set_to_none(self):
-        """Tests explicitly setting a oneof field to None"""
+        """Tests explicitly setting a oneof field to None."""
         one_of_field_test = OneofFieldTest(int_field_1=10, normal_field=False)
         self.assertEqual(one_of_field_test.int_field_1, 10)
         self.assertIsNone(one_of_field_test.int_field_2)
@@ -163,7 +163,7 @@
         self.assertFalse(one_of_field_test.normal_field)
 
     def test_oneof_specs(self):
-        """Tests the `oneof_field_specs` filter"""
+        """Tests the `oneof_field_specs` filter."""
         expected = {
             "int_field_1": ir_data_fields.make_field_spec(
                 "int_field_1", int, ir_data_fields.FieldContainer.OPTIONAL, "type_1"
@@ -178,7 +178,7 @@
         self.assertDictEqual(actual, expected)
 
     def test_oneof_mappings(self):
-        """Tests the `oneof_mappings` function"""
+        """Tests the `oneof_mappings` function."""
         expected = (("int_field_1", "type_1"), ("int_field_2", "type_1"))
         actual = ir_data_fields.IrDataclassSpecs.get_specs(
             OneofFieldTest
@@ -187,10 +187,16 @@
 
 
 class IrDataFieldsTest(unittest.TestCase):
-    """Tests misc methods in ir_data_fields"""
+    """Tests misc methods in ir_data_fields."""
+
+    def assertEmpty(self, obj):
+        self.assertEqual(len(obj), 0, msg=f"{obj} is not empty.")
+
+    def assertLen(self, obj, length):
+        self.assertEqual(len(obj), length, msg=f"{obj} has length {len(obj)}.")
 
     def test_copy(self):
-        """Tests copying a data class works as expected"""
+        """Tests copying a data class works as expected."""
         union = ClassWithTwoUnions(
             opaque=Opaque(), boolean=True, non_union_field=10, seq_field=[1, 2, 3]
         )
@@ -204,25 +210,25 @@
         self.assertIsNone(empty_copy)
 
     def test_copy_values_list(self):
-        """Tests that CopyValuesList copies values"""
+        """Tests that CopyValuesList copies values."""
         data_list = ir_data_fields.CopyValuesList(ListCopyTestClass)
-        self.assertEqual(len(data_list), 0)
+        self.assertEmpty(data_list)
 
         list_test = ListCopyTestClass(non_union_field=2, seq_field=[5, 6, 7])
         list_tests = [ir_data_fields.copy(list_test) for _ in range(4)]
         data_list.extend(list_tests)
-        self.assertEqual(len(data_list), 4)
+        self.assertLen(data_list, 4)
         for i in data_list:
             self.assertEqual(i, list_test)
 
     def test_list_param_is_copied(self):
-        """Test that lists passed to constructors are converted to CopyValuesList"""
+        """Test that lists passed to constructors are converted to CopyValuesList."""
         seq_field = [5, 6, 7]
         list_test = ListCopyTestClass(non_union_field=2, seq_field=seq_field)
-        self.assertEqual(len(list_test.seq_field), len(seq_field))
+        self.assertLen(list_test.seq_field, len(seq_field))
         self.assertIsNot(list_test.seq_field, seq_field)
         self.assertEqual(list_test.seq_field, seq_field)
-        self.assertTrue(isinstance(list_test.seq_field, ir_data_fields.CopyValuesList))
+        self.assertIsInstance(list_test.seq_field, ir_data_fields.CopyValuesList)
 
     def test_copy_oneof(self):
         """Tests copying an IR data class that has oneof fields."""
diff --git a/compiler/util/ir_data_utils.py b/compiler/util/ir_data_utils.py
index 2d38eac..f880231 100644
--- a/compiler/util/ir_data_utils.py
+++ b/compiler/util/ir_data_utils.py
@@ -91,7 +91,7 @@
 
 
 class IrDataSerializer:
-    """Provides methods for serializing IR data objects"""
+    """Provides methods for serializing IR data objects."""
 
     def __init__(self, ir: MessageT):
         assert ir is not None
@@ -102,6 +102,7 @@
         ir: MessageT,
         field_func: Callable[[MessageT], list[Tuple[ir_data_fields.FieldSpec, Any]]],
     ) -> MutableMapping[str, Any]:
+        """Translates the IR to a standard Python `dict`."""
         assert ir is not None
         values: MutableMapping[str, Any] = {}
         for spec, value in field_func(ir):
@@ -117,12 +118,12 @@
         """Converts the IR data class to a dictionary."""
 
         def non_empty(ir):
-            return fields_and_values(
+            return _fields_and_values(
                 ir, lambda v: v is not None and (not isinstance(v, list) or len(v))
             )
 
         def all_fields(ir):
-            return fields_and_values(ir)
+            return _fields_and_values(ir)
 
         # It's tempting to use `dataclasses.asdict` here, but that does a deep
         # copy which is overkill for the current usage; mainly as an intermediary
@@ -130,17 +131,17 @@
         return self._to_dict(self.ir, non_empty if exclude_none else all_fields)
 
     def to_json(self, *args, **kwargs):
-        """Converts the IR data class to a JSON string"""
+        """Converts the IR data class to a JSON string."""
         return json.dumps(self.to_dict(exclude_none=True), *args, **kwargs)
 
     @staticmethod
     def from_json(data_cls, data):
-        """Constructs an IR data class from the given JSON string"""
+        """Constructs an IR data class from the given JSON string."""
         as_dict = json.loads(data)
         return IrDataSerializer.from_dict(data_cls, as_dict)
 
     def copy_from_dict(self, data):
-        """Deserializes the data and overwrites the IR data class with it"""
+        """Deserializes the data and overwrites the IR data class with it."""
         cls = type(self.ir)
         data_copy = IrDataSerializer.from_dict(cls, data)
         for k in field_specs(cls):
@@ -148,6 +149,7 @@
 
     @staticmethod
     def _enum_type_converter(enum_cls: type[enum.Enum], val: Any) -> enum.Enum:
+        """Converts `val` to an instance of `enum_cls`."""
         if isinstance(val, str):
             return getattr(enum_cls, val)
         return enum_cls(val)
@@ -158,6 +160,7 @@
 
     @staticmethod
     def _from_dict(data_cls: type[MessageT], data):
+        """Translates the given `data` dict to an instance of `data_cls`."""
         class_fields: MutableMapping[str, Any] = {}
         for name, spec in ir_data_fields.field_specs(data_cls).items():
             if (value := data.get(name)) is not None:
@@ -188,12 +191,12 @@
 
     @staticmethod
     def from_dict(data_cls: type[MessageT], data):
-        """Creates a new IR data instance from a serialized dict"""
+        """Creates a new IR data instance from a serialized dict."""
         return IrDataSerializer._from_dict(data_cls, data)
 
 
 class _IrDataSequenceBuilder(MutableSequence[MessageT]):
-    """Wrapper for a list of IR elements
+    """Wrapper for a list of IR elements.
 
     Simply wraps the returned values during indexed access and iteration with
     IrDataBuilders.
@@ -236,7 +239,7 @@
 
 
 class _IrDataBuilder(Generic[MessageT]):
-    """Wrapper for an IR element"""
+    """Wrapper for an IR element."""
 
     def __init__(self, ir: MessageT) -> None:
         assert ir is not None
@@ -254,10 +257,15 @@
     def __getattribute__(self, name: str) -> Any:
         """Hook for `getattr` that handles adding missing fields.
 
-        If the field is missing inserts it, and then returns either the raw value
-        for basic types
-        or a new IrBuilder wrapping the field to handle the next field access in a
-        longer chain.
+        If the field is missing inserts it, and then returns either the raw
+        value for basic types or a new IrBuilder wrapping the field to handle
+        the next field access in a longer chain.
+
+        Arguments:
+            name: the name of the attribute to set/retrieve
+
+        Returns:
+            The value of the attribute `name`.
         """
 
         # Check if getting one of the builder attributes
@@ -294,12 +302,12 @@
         return obj
 
     def CopyFrom(self, template: MessageT):  # pylint:disable=invalid-name
-        """Updates the fields of this class with values set in the template"""
+        """Updates the fields of this class with values set in the template."""
         update(cast(type[MessageT], self), template)
 
 
 def builder(target: MessageT) -> MessageT:
-    """Create a wrapper around the target to help build an IR Data structure"""
+    """Create a wrapper around the target to help build an IR Data structure."""
     # Check if the target is already a builder.
     if isinstance(target, (_IrDataBuilder, _IrDataSequenceBuilder)):
         return target
@@ -314,7 +322,7 @@
 
 
 def _field_checker_from_spec(spec: ir_data_fields.FieldSpec):
-    """Helper that builds an FieldChecker that pretends to be an IR class"""
+    """Helper that builds an FieldChecker that pretends to be an IR class."""
     if spec.is_sequence:
         return []
     if spec.is_dataclass:
@@ -322,14 +330,15 @@
     return ir_data_fields.build_default(spec)
 
 
-def _field_type(ir_or_spec: Union[MessageT, ir_data_fields.FieldSpec]) -> type:
+def _field_type(ir_or_spec: Union[MessageT, ir_data_fields.FieldSpec]) -> type[Any]:
+    """Returns the Python type of the given field."""
     if isinstance(ir_or_spec, ir_data_fields.FieldSpec):
         return ir_or_spec.data_type
     return type(ir_or_spec)
 
 
 class _ReadOnlyFieldChecker:
-    """Class used the chain calls to fields that aren't set"""
+    """Class used to chain calls to fields that aren't set."""
 
     def __init__(self, ir_or_spec: Union[MessageT, ir_data_fields.FieldSpec]) -> None:
         self.ir_or_spec = ir_or_spec
@@ -382,8 +391,7 @@
 
 
 def reader(obj: Union[MessageT, _ReadOnlyFieldChecker]) -> MessageT:
-    """Builds a read-only wrapper that can be used to check chains of possibly
-    unset fields.
+    """Builds a wrapper that can be used to read chains of possibly unset fields.
 
     This wrapper explicitly does not alter the wrapped object and is only
     intended for reading contents.
@@ -391,18 +399,36 @@
     For example, a `reader` lets you do:
     ```
     def get_function_name_end_column(function: ir_data.Function):
-      return reader(function).function_name.source_location.end.column
+        return reader(function).function_name.source_location.end.column
     ```
 
     Instead of:
     ```
     def get_function_name_end_column(function: ir_data.Function):
-      if function.function_name:
-        if function.function_name.source_location:
-          if function.function_name.source_location.end:
-            return function.function_name.source_location.end.column
-      return 0
+        if function.function_name:
+            if function.function_name.source_location:
+                if function.function_name.source_location.end:
+                    return function.function_name.source_location.end.column
+        return 0
     ```
+
+    Arguments:
+        obj: The IR node to wrap.
+
+    Returns:
+        An object whose attributes return either:
+
+        The value of `obj.attr` if `attr` is an atomic type and is set on
+        `obj`.
+
+        A default value for `obj.attr` if `obj.attr` is not set, but is of an
+        atomic type.
+
+        A read-only wrapper around `obj.attr` if `obj.attr` is set and is an IR
+        node type.
+
+        A read-only wrapper around an empty IR node object if `obj.attr` is not
+        set, and is of an IR node type.
     """
     # Create a read-only wrapper if it's not already one.
     if not isinstance(obj, _ReadOnlyFieldChecker):
@@ -426,15 +452,19 @@
     return cast(ir_data_fields.IrDataclassInstance, ir_or_wrapper)
 
 
-def fields_and_values(
+def _fields_and_values(
     ir_wrapper: Union[MessageT, _ReadOnlyFieldChecker],
     value_filt: Optional[Callable[[Any], bool]] = None,
 ) -> list[Tuple[ir_data_fields.FieldSpec, Any]]:
     """Retrieves the fields and their values for a given IR data class.
 
     Args:
-      ir: The IR data class or a read-only wrapper of an IR data class.
-      value_filt: Optional filter used to exclude values.
+        ir: The IR data class or a read-only wrapper of an IR data class.
+        value_filt: Optional filter used to exclude values.
+
+    Returns:
+        Fields and their values for the IR held by `ir_wrapper`, optionally
+        filtered by `value_filt`.
     """
     if (ir := _extract_ir(ir_wrapper)) is None:
         return []
@@ -443,15 +473,22 @@
 
 
 def get_set_fields(ir: MessageT):
-    """Retrieves the field spec and value of fields that are set in the given IR data class.
+    """Retrieves the field specs and values of fields that are set in `ir`.
 
     A value is considered "set" if it is not None.
+
+    Arguments:
+        ir: The IR node to operate on.
+
+    Returns:
+        The field specs and values of fields that are set in the given IR data
+        class.
     """
-    return fields_and_values(ir, lambda v: v is not None)
+    return _fields_and_values(ir, lambda v: v is not None)
 
 
 def copy(ir_wrapper: Optional[MessageT]) -> Optional[MessageT]:
-    """Creates a copy of the given IR data class"""
+    """Creates a copy of the given IR data class."""
     if (ir := _extract_ir(ir_wrapper)) is None:
         return None
     ir_copy = ir_data_fields.copy(ir)
diff --git a/compiler/util/ir_data_utils_test.py b/compiler/util/ir_data_utils_test.py
index 82baac6..954fc33 100644
--- a/compiler/util/ir_data_utils_test.py
+++ b/compiler/util/ir_data_utils_test.py
@@ -35,12 +35,12 @@
 
 @dataclasses.dataclass
 class Opaque(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
 
 @dataclasses.dataclass
 class ClassWithUnion(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
     opaque: Optional[Opaque] = ir_data_fields.oneof_field("type")
     integer: Optional[int] = ir_data_fields.oneof_field("type")
@@ -51,7 +51,7 @@
 
 @dataclasses.dataclass
 class ClassWithTwoUnions(ir_data.Message):
-    """Used for testing data field helpers"""
+    """Used for testing data field helpers."""
 
     opaque: Optional[Opaque] = ir_data_fields.oneof_field("type_1")
     integer: Optional[int] = ir_data_fields.oneof_field("type_1")
@@ -65,7 +65,7 @@
     """Tests for the miscellaneous utility functions in ir_data_utils.py."""
 
     def test_field_specs(self):
-        """Tests the `field_specs` method"""
+        """Tests the `field_specs` method."""
         fields = ir_data_utils.field_specs(ir_data.TypeDefinition)
         self.assertIsNotNone(fields)
         expected_fields = (
@@ -132,7 +132,7 @@
         self.assertEqual(fields["base_type"], expected_field)
 
     def test_is_sequence(self):
-        """Tests for the `FieldSpec.is_sequence` helper"""
+        """Tests for the `FieldSpec.is_sequence` helper."""
         type_def = ir_data.TypeDefinition(
             attribute=[
                 ir_data.Attribute(
@@ -151,7 +151,7 @@
         self.assertFalse(fields["is_default"].is_sequence)
 
     def test_is_dataclass(self):
-        """Tests FieldSpec.is_dataclass against ir_data"""
+        """Tests FieldSpec.is_dataclass against ir_data."""
         type_def = ir_data.TypeDefinition(
             attribute=[
                 ir_data.Attribute(
@@ -173,7 +173,7 @@
         self.assertFalse(fields["fields_in_dependency_order"].is_dataclass)
 
     def test_get_set_fields(self):
-        """Tests that get set fields works"""
+        """Tests that get set fields works."""
         type_def = ir_data.TypeDefinition(
             attribute=[
                 ir_data.Attribute(
@@ -196,7 +196,7 @@
         self.assertSetEqual(found_fields, expected_fields)
 
     def test_copy(self):
-        """Tests the `copy` helper"""
+        """Tests the `copy` helper."""
         attribute = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -219,7 +219,7 @@
         self.assertIsNot(type_def.attribute, type_def_copy.attribute)
 
     def test_update(self):
-        """Tests the `update` helper"""
+        """Tests the `update` helper."""
         attribute_template = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -236,10 +236,16 @@
 
 
 class IrDataBuilderTest(unittest.TestCase):
-    """Tests for IrDataBuilder"""
+    """Tests for IrDataBuilder."""
+
+    def assertEmpty(self, obj):
+        self.assertEqual(len(obj), 0, msg=f"{obj} is not empty.")
+
+    def assertLen(self, obj, length):
+        self.assertEqual(len(obj), length, msg=f"{obj} has length {len(obj)}.")
 
     def test_ir_data_builder(self):
-        """Tests that basic builder chains work"""
+        """Tests that basic builder chains work."""
         # We start with an empty type
         type_def = ir_data.TypeDefinition()
         self.assertFalse(type_def.HasField("name"))
@@ -258,7 +264,7 @@
         self.assertEqual(type_def.name.name.text, "phil")
 
     def test_ir_data_builder_bad_field(self):
-        """Tests accessing an undefined field name fails"""
+        """Tests accessing an undefined field name fails."""
         type_def = ir_data.TypeDefinition()
         builder = ir_data_utils.builder(type_def)
         self.assertRaises(AttributeError, lambda: builder.foo)
@@ -266,11 +272,11 @@
         self.assertRaises(AttributeError, getattr, type_def, "foo")
 
     def test_ir_data_builder_sequence(self):
-        """Tests that sequences are properly wrapped"""
+        """Tests that sequences are properly wrapped."""
         # We start with an empty type
         type_def = ir_data.TypeDefinition()
         self.assertTrue(type_def.HasField("attribute"))
-        self.assertEqual(len(type_def.attribute), 0)
+        self.assertEmpty(type_def.attribute)
 
         # Now setup a builder
         builder = ir_data_utils.builder(type_def)
@@ -284,12 +290,12 @@
         builder.attribute.append(attribute)
         self.assertEqual(builder.attribute, [attribute])
         self.assertTrue(type_def.HasField("attribute"))
-        self.assertEqual(len(type_def.attribute), 1)
+        self.assertLen(type_def.attribute, 1)
         self.assertEqual(type_def.attribute[0], attribute)
 
         # Lets make it longer and then try iterating
         builder.attribute.append(attribute)
-        self.assertEqual(len(type_def.attribute), 2)
+        self.assertLen(type_def.attribute, 2)
         for attr in builder.attribute:
             # Modify the attributes
             attr.name.text = "bob"
@@ -305,7 +311,7 @@
             name=ir_data.Word(text="bob"),
         )
 
-        self.assertEqual(len(type_def.attribute), 3)
+        self.assertLen(type_def.attribute, 3)
         for attr in type_def.attribute:
             self.assertEqual(attr, new_attribute)
 
@@ -368,7 +374,7 @@
         )
 
     def test_ir_data_builder_sequence_scalar(self):
-        """Tests that sequences of scalars function properly"""
+        """Tests that sequences of scalars function properly."""
         # We start with an empty type
         structure = ir_data.Structure()
 
@@ -380,7 +386,7 @@
         builder.fields_in_dependency_order.append(11)
 
         self.assertTrue(structure.HasField("fields_in_dependency_order"))
-        self.assertEqual(len(structure.fields_in_dependency_order), 2)
+        self.assertLen(structure.fields_in_dependency_order, 2)
         self.assertEqual(structure.fields_in_dependency_order[0], 12)
         self.assertEqual(structure.fields_in_dependency_order[1], 11)
         self.assertEqual(builder.fields_in_dependency_order, [12, 11])
@@ -404,10 +410,10 @@
 
 
 class IrDataSerializerTest(unittest.TestCase):
-    """Tests for IrDataSerializer"""
+    """Tests for IrDataSerializer."""
 
     def test_ir_data_serializer_to_dict(self):
-        """Tests serialization with `IrDataSerializer.to_dict` with default settings"""
+        """Tests serialization with `IrDataSerializer.to_dict` with default settings."""
         attribute = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -438,7 +444,7 @@
         self.assertDictEqual(raw_dict, expected)
 
     def test_ir_data_serializer_to_dict_exclude_none(self):
-        """Tests serialization with `IrDataSerializer.to_dict` when excluding None values"""
+        """.Tests serialization with `IrDataSerializer.to_dict` when excluding None values"""
         attribute = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -449,7 +455,7 @@
         self.assertDictEqual(raw_dict, expected)
 
     def test_ir_data_serializer_to_dict_enum(self):
-        """Tests that serialization of `enum.Enum` values works properly"""
+        """Tests that serialization of `enum.Enum` values works properly."""
         type_def = ir_data.TypeDefinition(addressable_unit=ir_data.AddressableUnit.BYTE)
         serializer = ir_data_utils.IrDataSerializer(type_def)
         raw_dict = serializer.to_dict(exclude_none=True)
@@ -457,7 +463,7 @@
         self.assertDictEqual(raw_dict, expected)
 
     def test_ir_data_serializer_from_dict(self):
-        """Tests deserializing IR data from a serialized dict"""
+        """Tests deserializing IR data from a serialized dict."""
         attribute = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -468,7 +474,7 @@
         self.assertEqual(attribute, new_attribute)
 
     def test_ir_data_serializer_from_dict_enum(self):
-        """Tests that deserializing `enum.Enum` values works properly"""
+        """Tests that deserializing `enum.Enum` values works properly."""
         type_def = ir_data.TypeDefinition(addressable_unit=ir_data.AddressableUnit.BYTE)
 
         serializer = ir_data_utils.IrDataSerializer(type_def)
@@ -477,7 +483,7 @@
         self.assertEqual(type_def, new_type_def)
 
     def test_ir_data_serializer_from_dict_enum_is_str(self):
-        """Tests that deserializing `enum.Enum` values works properly when string constant is used"""
+        """Tests that deserializing `enum.Enum` values works properly when string constant is used."""
         type_def = ir_data.TypeDefinition(addressable_unit=ir_data.AddressableUnit.BYTE)
         raw_dict = {"addressable_unit": "BYTE"}
         serializer = ir_data_utils.IrDataSerializer(type_def)
@@ -485,7 +491,7 @@
         self.assertEqual(type_def, new_type_def)
 
     def test_ir_data_serializer_from_dict_exclude_none(self):
-        """Tests that deserializing from a dict that excluded None values works properly"""
+        """Tests that deserializing from a dict that excluded None values works properly."""
         attribute = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -552,7 +558,7 @@
         self.assertIsNotNone(func)
 
     def test_ir_data_serializer_copy_from_dict(self):
-        """Tests that updating an IR data struct from a dict works properly"""
+        """Tests that updating an IR data struct from a dict works properly."""
         attribute = ir_data.Attribute(
             value=ir_data.AttributeValue(expression=ir_data.Expression()),
             name=ir_data.Word(text="phil"),
@@ -567,10 +573,10 @@
 
 
 class ReadOnlyFieldCheckerTest(unittest.TestCase):
-    """Tests the ReadOnlyFieldChecker"""
+    """Tests the ReadOnlyFieldChecker."""
 
     def test_basic_wrapper(self):
-        """Tests basic field checker actions"""
+        """Tests basic field checker actions."""
         union = ClassWithTwoUnions(opaque=Opaque(), boolean=True, non_union_field=10)
         field_checker = ir_data_utils.reader(union)
 
@@ -591,7 +597,7 @@
         self.assertTrue(field_checker.HasField("non_union_field"))
 
     def test_construct_from_field_checker(self):
-        """Tests that constructing from another field checker works"""
+        """Tests that constructing from another field checker works."""
         union = ClassWithTwoUnions(opaque=Opaque(), boolean=True, non_union_field=10)
         field_checker_orig = ir_data_utils.reader(union)
         field_checker = ir_data_utils.reader(field_checker_orig)
@@ -615,7 +621,7 @@
         self.assertTrue(field_checker.HasField("non_union_field"))
 
     def test_read_only(self) -> None:
-        """Tests that the read only wrapper really is read only"""
+        """Tests that the read only wrapper really is read only."""
         union = ClassWithTwoUnions(opaque=Opaque(), boolean=True, non_union_field=10)
         field_checker = ir_data_utils.reader(union)
 
diff --git a/compiler/util/name_conversion.py b/compiler/util/name_conversion.py
index b13d667..b4303fb 100644
--- a/compiler/util/name_conversion.py
+++ b/compiler/util/name_conversion.py
@@ -63,10 +63,19 @@
 def convert_case(case_from, case_to, value):
     """Converts cases based on runtime case values.
 
-    Note: Cases can be strings or enum values."""
+    Note: Cases can be strings or enum values.
+
+    Arguments:
+        case_from: the name of the original case
+        case_to: the name of the desired case
+        value: the value to convert
+
+    Returns:
+        `value` converted from `case_from` to `case_to`.
+    """
     return _case_conversions[case_from, case_to](value)
 
 
 def is_case_conversion_supported(case_from, case_to):
-    """Determines if a case conversion would be supported"""
+    """Determines if a case conversion would be supported."""
     return (case_from, case_to) in _case_conversions
diff --git a/runtime/cpp/emboss_prelude.h b/runtime/cpp/emboss_prelude.h
index 8b5fa28..ad302cd 100644
--- a/runtime/cpp/emboss_prelude.h
+++ b/runtime/cpp/emboss_prelude.h
@@ -267,7 +267,7 @@
            static_cast</**/ ::std::uint64_t>(value) <=
                ((static_cast<ValueType>(1) << (Parameters::kBits - 1)) << 1) -
                    1 &&
-           Parameters::ValueIsOk(value);
+           Parameters::ValueIsOk(static_cast<ValueType>(value));
   }
   void UncheckedWrite(ValueType value) const {
     buffer_.UncheckedWriteUInt(value);
@@ -429,7 +429,8 @@
                     : ((static_cast<ValueType>(1) << (Parameters::kBits - 2)) -
                        1) * 2 +
                           1) &&
-           Parameters::ValueIsOk(value);
+           Parameters::ValueIsOk(static_cast<ValueType>(value));
+
   }
 
   void UncheckedWrite(ValueType value) const {