fixup! Update docs

Author: matheusaaguiar

docs/assembly.rst

@@ -383,7 +383,7 @@ of Solidity, you can use a special comment to annotate an assembly block as memo
 
 .. warning::
     The ``memory-safe-assembly`` special comment is deprecated and scheduled for removal.
-    For new code targeting recent compilers, specify the assembly block annotation.
+    In new code targeting recent compilers, use the assembly block annotation.
 
 Advanced Safe Use of Memory
 ---------------------------

docs/cheatsheet.rst

@@ -53,19 +53,8 @@ Members of ``address``
 - ``<address>.staticcall(bytes memory) returns (bool, bytes memory)``: issue low-level ``STATICCALL`` with the given payload,
   returns success condition and return data
 - ``<address payable>.send(uint256 amount) returns (bool)``: send given amount of Wei to :ref:`address`,
-  returns ``false`` on failure
-- ``<address payable>.transfer(uint256 amount)``: send given amount of Wei to :ref:`address`, throws on failure
-
-.. warning::
-    `send()` and `transfer()` are deprecated and scheduled for removal.
-    Simple ether transfers can still be performed using the [`call()`](...) function with empty payload, i.e., `call{value: <amount>}("")`.
-    By default this forwards all the remaining gas, subject to additional limits imposed by some EVM versions
-    (such as the [63/64th rule](https://eips.ethereum.org/EIPS/eip-150) introduced by `tangerineWhistle`).
-    As with any external call, the `gas` call option can be used to set a lower limit.
-
-    While it is possible to recreate the functionality by explicitly setting the limit to the value of the stipend (2300 gas),
-    this value no longer holds its original meaning due to changing opcode costs.
-    It is recommended to use different means to protect against reentrancy.
+  returns ``false`` on failure (deprecated)
+- ``<address payable>.transfer(uint256 amount)``: send given amount of Wei to :ref:`address`, throws on failure (deprecated)
 
 .. index:: blockhash, blobhash, block, block;basefee, block;blobbasefee, block;chainid, block;coinbase, block;difficulty, block;gaslimit, block;number, block;prevrandao, block;timestamp
 .. index:: gasleft, msg;data, msg;sender, msg;sig, msg;value, tx;gasprice, tx;origin

docs/contracts/functions.rst

@@ -311,11 +311,8 @@ will consume more gas than the 2300 gas stipend:
 - Sending Ether
 
 .. warning::
-    `send()` and `transfer()` are deprecated and scheduled for removal.
-    Simple ether transfers can still be performed using the [`call()`](...) function with empty payload, i.e., `call{value: <amount>}("")`.
-    By default this forwards all the remaining gas, subject to additional limits imposed by some EVM versions
-    (such as the [63/64th rule](https://eips.ethereum.org/EIPS/eip-150) introduced by `tangerineWhistle`).
-    As with any external call, the `gas` call option can be used to set a lower limit.
+    ``send()`` and ``transfer()`` are deprecated and scheduled for removal.
+    See the section on :ref:`address` for more information.
 
     While it is possible to recreate the functionality by explicitly setting the limit to the value of the stipend (2300 gas),
     this value no longer holds its original meaning due to changing opcode costs.

docs/contracts/inheritance.rst

@@ -428,7 +428,7 @@ explicitly:
     }
 
 .. warning::
-    ``virtual`` modifiers are deprecated and scheduled.
+    ``virtual`` modifiers are deprecated and scheduled for removal.
 
 
 .. index:: ! constructor

docs/examples/blind-auction.rst

@@ -118,7 +118,7 @@ to receive their Ether - contracts cannot activate themselves.
             if (amount > 0) {
                 // It is important to set this to zero because the recipient
                 // can call this function again as part of the receiving call
-                // before `send` returns.
+                // before `call` returns.
                 pendingReturns[msg.sender] = 0;
 
                 // msg.sender is not of type `address payable` and must be
@@ -322,7 +322,7 @@ invalid bids.
             if (amount > 0) {
                 // It is important to set this to zero because the recipient
                 // can call this function again as part of the receiving call
-                // before `transfer` returns (see the remark above about
+                // before `call` returns (see the remark above about
                 // conditions -> effects -> interaction).
                 pendingReturns[msg.sender] = 0;
 

docs/examples/safe-remote.rst

@@ -93,7 +93,7 @@ you can use state machine-like constructs inside a contract.
         {
             emit Aborted();
             state = State.Inactive;
-            // We use transfer here directly. It is
+            // We use call here directly. It is
             // reentrancy-safe, because it is the
             // last call in this function and we
             // already changed the state.
@@ -125,7 +125,7 @@ you can use state machine-like constructs inside a contract.
         {
             emit ItemReceived();
             // It is important to change the state first because
-            // otherwise, the contracts called using `send` below
+            // otherwise, the contracts called using `call` below
             // can call in again here.
             state = State.Release;
 
@@ -142,7 +142,7 @@ you can use state machine-like constructs inside a contract.
         {
             emit SellerRefunded();
             // It is important to change the state first because
-            // otherwise, the contracts called using `send` below
+            // otherwise, the contracts called using `call` below
             // can call in again here.
             state = State.Inactive;
 

docs/security-considerations.rst

@@ -77,7 +77,7 @@ Ether transfer can always include code execution,
 so the recipient could be a contract that calls back into ``withdraw``.
 This would let it get multiple refunds and, basically, retrieve all the Ether in the contract.
 In particular, the following contract will allow an attacker to refund multiple times
-as it uses ``call`` which forwards 63/64 of the remaining gas by default:
+as it uses ``call`` which does not limit the amount of gas that is forwarded by default:
 
 .. code-block:: solidity
 
@@ -161,8 +161,8 @@ Sending and Receiving Ether
 
 - There is a way to forward more gas to the receiving contract using ``addr.call{value: x}("")``.
   This is essentially the same as ``addr.transfer(x)``, only that it forwards all remaining gas,
-  subject to additional limits imposed by some EVM versions (such as the [63/64th rule](https://eips.ethereum.org/EIPS/eip-150)
-  introduced by `tangerineWhistle`), and opens up the ability for the recipient to perform more expensive actions
+  subject to additional limits imposed by some EVM versions (such as the `63/64th rule <https://eips.ethereum.org/EIPS/eip-150>`__
+  introduced by ``tangerineWhistle``), and opens up the ability for the recipient to perform more expensive actions
   (and it returns a failure code instead of automatically propagating the error).
   This might include calling back into the sending contract or other state changes you might not have thought of.
   So it allows for great flexibility for honest users but also for malicious actors.

docs/types/value-types.rst

@@ -263,10 +263,11 @@ For a quick reference of all members of address, see :ref:`address_related`.
 
     .. warning::
         ``transfer`` is deprecated and scheduled for removal.
-        Use the :ref:`call function <address_call_functions>` with an optionally provided maximum amount of
-        gas and an empty calldata parameter, e.g., ``call{value: amount}("")``.
-        By default forwards all remaining gas, subject to additional limits imposed by some EVM versions (such as the [63/64th rule](https://eips.ethereum.org/EIPS/eip-150) introduced by `tangerineWhistle`).
-        As with any external call, the `gas` call option can be used to set a lower limit.
+        Simple ether transfers can still be performed using the :ref:`call function <address_call_functions>`
+        with with an optionally provided maximum amount of gas and empty payload, i.e., ``call{value: <amount>}("")``.
+        By default this forwards all the remaining gas, subject to additional limits imposed by some EVM versions
+        (such as the `63/64th rule <https://eips.ethereum.org/EIPS/eip-150>`__ introduced by ``tangerineWhistle``).
+        As with any external call, the ``gas`` call option can be used to set a lower limit.
 
 * ``send``
 
@@ -280,10 +281,11 @@ For a quick reference of all members of address, see :ref:`address_related`.
 
     .. warning::
         ``send`` is deprecated and scheduled for removal.
-        Use the :ref:`call function <address_call_functions>` with an optionally provided maximum amount of
-        gas and an empty calldata parameter, e.g., ``call{value: amount}("")``.
-        By default forwards all remaining gas, subject to additional limits imposed by some EVM versions (such as the [63/64th rule](https://eips.ethereum.org/EIPS/eip-150) introduced by `tangerineWhistle`).
-        As with any external call, the `gas` call option can be used to set a lower limit.
+        Simple ether transfers can still be performed using the :ref:`call function <address_call_functions>`
+        with with an optionally provided maximum amount of gas and empty payload, i.e., ``call{value: <amount>}("")``.
+        By default this forwards all the remaining gas, subject to additional limits imposed by some EVM versions
+        (such as the `63/64th rule <https://eips.ethereum.org/EIPS/eip-150>`__ introduced by ``tangerineWhistle``).
+        As with any external call, the ``gas`` call option can be used to set a lower limit.
 
 .. _address_call_functions:
 

docs/units-and-global-variables.rst

@@ -269,13 +269,8 @@ Members of Address Types
     send given amount of Wei to :ref:`address`, returns ``false`` on failure, forwards 2300 gas stipend, not adjustable
 
 .. warning::
-    `send()` and `transfer()` are deprecated and scheduled for removal.
-    Simple ether transfers can still be performed using the [`call()`](...) function with empty payload, i.e., `call{value: <amount>}("")`.
-    By default this forwards all the remaining gas, subject to additional limits imposed by some EVM versions (such as the [63/64th rule](https://eips.ethereum.org/EIPS/eip-150) introduced by `tangerineWhistle`).
-    As with any external call, the `gas` call option can be used to set a lower limit.
-
-    While it is possible to recreate the functionality by explicitly setting the limit to the value of the stipend (2300 gas), this value no longer holds its original meaning due to changing opcode costs.
-    It is recommended to use different means to protect against reentrancy.
+    ``send()`` and ``transfer()`` are deprecated and scheduled for removal.
+    See the section on :ref:`address` for more information.
 
 ``<address>.call(bytes memory) returns (bool, bytes memory)``
     issue low-level ``CALL`` with the given payload, returns success condition and return data,