Replace statement -> expression when relevant (#13621)

lib/elixir/lib/macro.ex

@@ -779,7 +779,7 @@ defmodule Macro do
   ## Options
 
     * `:unquote` - when true, this function leaves `unquote/1` and
-      `unquote_splicing/1` statements unescaped, effectively unquoting
+      `unquote_splicing/1` expressions unescaped, effectively unquoting
       the contents on escape. This option is useful only when escaping
       ASTs which may have quoted fragments in them. Defaults to false.
 

lib/elixir/pages/anti-patterns/code-anti-patterns.md

@@ -50,11 +50,11 @@ Elixir makes a clear distinction between **documentation** and code comments. Th
 
 #### Problem
 
-This anti-pattern refers to `with` statements that flatten all its error clauses into a single complex `else` block. This situation is harmful to the code readability and maintainability because it's difficult to know from which clause the error value came.
+This anti-pattern refers to `with` expressions that flatten all its error clauses into a single complex `else` block. This situation is harmful to the code readability and maintainability because it's difficult to know from which clause the error value came.
 
 #### Example
 
-An example of this anti-pattern, as shown below, is a function `open_decoded_file/1` that reads a Base64-encoded string content from a file and returns a decoded binary string. This function uses a `with` statement that needs to handle two possible errors, all of which are concentrated in a single complex `else` block.
+An example of this anti-pattern, as shown below, is a function `open_decoded_file/1` that reads a Base64-encoded string content from a file and returns a decoded binary string. This function uses a `with` expression that needs to handle two possible errors, all of which are concentrated in a single complex `else` block.
 
 ```elixir
 def open_decoded_file(path) do

lib/elixir/src/elixir_rewrite.erl

@@ -228,7 +228,7 @@ inner_inline(_, _, _, _) -> false.
 %%
 %% Rewrite rules are more complex than regular inlining code
 %% as they may change the number of arguments. However, they
-%% don't add new code (such as case statements), at best they
+%% don't add new code (such as case expressions), at best they
 %% perform dead code removal.
 rewrite(?string_chars, DotMeta, to_string, Meta, [Arg]) ->
   case is_always_string(Arg) of