Why does code after return never run?

If this is C#, the function stops when it executes return: control goes back to the caller, and later statements on that path are not reached [S1][S2]. Indentation is a visual aid; the important question is whether the statements are inside the same function and what the control flow does.

For example:

void Run()
{
    Console.WriteLine("Starting");
    return;
    Console.WriteLine("Finished");
}

Here, Finished follows an unconditional return, so it cannot run during this call. The return does not mean “skip this line”; it exits Run. The cited rule is for C#, so check the documentation for your language if your code is not C#.

It depends on whether that condition is true. An early return inside an if exits the function when that branch runs; when the condition is false, execution can continue after the block. Microsoft’s C# example describes this distinction: the later statement is skipped when the early-return condition is true [S1].

int GetValue(bool stopEarly)
{
    if (stopEarly)
    {
        return 0;
    }

    Console.WriteLine("Continuing");
    return 1;
}

With stopEarly set to true, Continuing is skipped. With it set to false, execution reaches that print and then returns 1. In other words, trace each possible branch rather than assuming that one return blocks every route through the function.

Yes, the layout can be misleading when you are scanning the code. In C#, the statements’ placement in the function and its control-flow blocks matters; indentation alone does not decide whether a statement executes [S2]. Match each opening brace { with its closing brace }, then identify which function contains the return and which statements follow it inside that function.

Try this quick trace:

1. Find the function’s opening and closing braces.
2. Mark every return and the condition or branch that leads to it.
3. Follow one input path at a time, stopping when that path reaches a return.
4. Check whether the supposedly skipped line is inside or outside the relevant block.

A line outside the function is not simply “the next line after return” in that function; check which function or block it belongs to.

If the intention is to print both messages, remove the unconditional early return. If you want to keep an early exit for one case, put it only on the branch that should stop:

void Run(bool stopEarly)
{
    Console.WriteLine("Starting");

    if (stopEarly)
    {
        return;
    }

    Console.WriteLine("Finished");
}

Assuming stopEarly is false, both messages print; if it is true, the function exits before Finished. To inspect your own code, write down the path for the input that reproduces the issue, then mark the first return that path encounters. Any later statement on that same path is not reached.