Function get_render_choices

partial_rendering.py:217–297

(
    plain_module: PlainModule,
    plain_module_render_state: PlainModuleRenderState,
    force_render: bool = False,
)

def get_render_choices(
    plain_module: PlainModule,
    plain_module_render_state: PlainModuleRenderState,
    force_render: bool = False,
) -> dict[str, RenderChoice]:
    render_choices = list[RenderChoice]()
    module_start_points = list[str]()

    # Decide whether the detected change actually requires a decision. A spec change that only
    # adds work *after* the last-rendered functionality (e.g. a new functionality appended to
    # the end of the last module) does not affect anything already rendered, so it is treated
    # like a normal "continue" rather than a change that requires choosing where to restart.
    partial_start = None
    treat_as_continue = plain_module_render_state.change is None
    if plain_module_render_state.change is not None and plain_module_render_state.change_type == "spec_change":
        partial_start = determine_partial_render_start(plain_module)
        if change_is_only_future_work(plain_module, plain_module_render_state, partial_start):
            treat_as_continue = True

    if treat_as_continue:
        # Continue / resume from the last-rendered position. The change-driven blocks below decide
        # the start otherwise — once a change touches already-rendered work, resuming from the old
        # position would build on stale code.
        render_choices.append(_resume_render_choice(plain_module, plain_module_render_state, force_render))

    else:
        # change is set here (otherwise treat_as_continue would be True), so change_type is always
        # "spec_change" or "code_change" and get_all_affected_modules_from_change is well-defined.
        all_affected_modules = get_all_affected_modules_from_change(plain_module, plain_module_render_state)

        if plain_module_render_state.change_type == "spec_change" and partial_start is not None:
            # Optimized partial render: render from the changed functionality, keeping the
            # module's earlier (unchanged) functionalities.
            render_range = plain_spec.get_render_range_from(partial_start.frid, partial_start.module.plain_source)
            render_choices.append(
                RenderChoice(
                    module=partial_start.module,
                    render_range=render_range,
                    choice_type="render_from_change",
                    wipe_later_modules=len(all_affected_modules) > 1,
                    is_destructive=True,
                )
            )

        # Full re-render of the affected module(s) from scratch. For a code change this is always
        # the action; for a spec change with no partial start (non-FR sections changed, or only
        # trailing FR removals) it is the only safe option, and when a partial start does exist it
        # is offered alongside it as the "rebuild this module cleanly" alternative. The "re-render
        # from first module" choice below remains the full-chain reset.
        if len(all_affected_modules) > 0 and all_affected_modules[0].module_name not in module_start_points:
            render_choices.append(
                RenderChoice(
                    module=all_affected_modules[0],
                    render_range=None,
                    choice_type="rerender_affected",
                    wipe_later_modules=True,
                    is_destructive=True,
                )