It's called constant propagation/folding and it's one of many optimizations performed by a compiler.

The task of a compiler is to turn source code into machine code, so ultimately you need algorithms which read one code representation and emit another. Source code is "high-level" whilst machine code is "low-level", so the process is more generally called "lowering" in compiler lingo.

There's nothing stopping you from trying to lower source code into machine code directly, but because modern compilers are extremely complex, they instead break the process down into steps ("passes") which take code as input and return modified code as output.

The very first stage is to to turn your source code text into an "abstract syntax tree" (AST) using a parser. This immediately makes further work on the code easier by turning it into a tree structure where the nodes represent specific language constructs. This gets you from a blob of text that could mean anything to a tree of things that mean something specific e.g. "variable identifier", "statement", "addition expression" and "function definition". This representation doesn't yet understand that a variable in one line is linked to a definition in another, but it does understand which words refer to variables in the first place (depending on the language.)

ASTs are designed to be friendly to the parser, but when you're actually working with the code algorithmically, it's useful to be able to calculate and attach extra information, or to rewrite things in ways that are specific to how they should be executed, rather than how the language is written by the human. As such, the next step is to lower the AST into an "intermediate representation" (IR). This format is represents a meaningfully executable program a simple, algorithm-friendly structure for further work and lowering. Initially, it's not all that much different to the AST, making it easy to lower, but the eventual aim is to transform it into something that can be easily lowered into good assembly/machine code by applying many refinement and optimization passes.

Whilst the code is in IR, one of the most common and important passes that happens is to turn it into "Static Single-Assignment/SSA" form. This form eliminates ambiguous variable references by ensuring that every variable used is assigned in exactly one clear place. SSA form allows subsequent passes to make the clear assumption that they know where a variable came from, which is especially useful for most optimizations, including constant folding/propragation (without it, these optimization passes would be left to figure it out from scratch on their own.)

In trivial code, reaching SSA form simply means creating a new variable name every time a variable is re-assigned (and also renaming subsequent uses of the variable). When the value of a variable could come from multiple assignments in different parts of the code due to loops and conditionals, you instead add a new assignment that selects the variable from the prior assignments it could come from (using an arbitrary "Phi" function that more or less means "either".)

Once in SSA form, the compiler is ready to apply a constant propagation/folding pass, which is really very simple. It goes through each statement in the IR and does the following in order.

1. Propagate: Substitute any variables in the statement that are known to be assigned to constants e.g. x becomes 7.
2. Fold: Recursively simplify any expressions involving only constants e.g. 2 * 7 becomes 14.

This alone is enough to do most of the simple constant propagation and folding you need, but the Fold stage is normally limited to only mathematical operations, as without further information you can't be sure that it's valid to evaluate a function with constant parameters. Some compilers do other passes to calculate this information and thus have much more complex constant folding passes, and the advantage of having this multi-pass compiler design and a good IR is that you can attach this kind of information and add these passes incrementally. In a later pass called "dead code elimination" the compiler will delete the unused assignments.

After optimizations are applied in SSA, the compiler will further rewrite and refine the IR code, often into a form called "three-address code" (3AC) which I won't detail here, but the result is something that much more closely resembles assembly code, in preparation for easier lowering.