up

Author: ernestognw

contracts/utils/Memory.sol

@@ -15,7 +15,7 @@ library Memory {
     type Pointer is bytes32;
 
     /// @dev Returns a `Pointer` to the current free `Pointer`.
-    function getFreePointer() internal pure returns (Pointer ptr) {
+    function getFreeMemoryPointer() internal pure returns (Pointer ptr) {
         assembly ("memory-safe") {
             ptr := mload(0x40)
         }
@@ -24,7 +24,7 @@ library Memory {
     /// @dev Sets the free `Pointer` to a specific value.
     ///
     /// WARNING: Everything after the pointer may be overwritten.
-    function setFreePointer(Pointer ptr) internal pure {
+    function setFreeMemoryPointer(Pointer ptr) internal pure {
         assembly ("memory-safe") {
             mstore(0x40, ptr)
         }

docs/modules/ROOT/pages/utilities.adoc

@@ -480,11 +480,11 @@ Note that each iteration allocates new memory for `tempData`, causing the memory
 [source,solidity]
 ----
 function processMultipleItems(uint256[] memory items) internal {
-  Memory.Pointer ptr = Memory.getFreePointer(); // Cache pointer
+  Memory.Pointer ptr = Memory.getFreeMemoryPointer(); // Cache pointer
   for (uint256 i = 0; i < items.length; i++) {
     bytes memory tempData = abi.encode(items[i], block.timestamp);
     // Process tempData...
-    Memory.setFreePointer(ptr); // Reset pointer for reuse
+    Memory.setFreeMemoryPointer(ptr); // Reset pointer for reuse
   }
 }
 ----

test/utils/Memory.t.sol

@@ -13,10 +13,10 @@ contract MemoryTest is Test {
     // - moving the free memory pointer to far causes OOG errors
     uint256 constant END_PTR = type(uint24).max;
 
-    function testGetSetFreePointer(uint256 seed) public pure {
+    function testGetsetFreeMemoryPointer(uint256 seed) public pure {
         bytes32 ptr = bytes32(bound(seed, START_PTR, END_PTR));
-        ptr.asPointer().setFreePointer();
-        assertEq(Memory.getFreePointer().asBytes32(), ptr);
+        ptr.asPointer().setFreeMemoryPointer();
+        assertEq(Memory.getFreeMemoryPointer().asBytes32(), ptr);
     }
 
     function testSymbolicContentPointer(uint256 seed) public pure {
@@ -25,9 +25,9 @@ contract MemoryTest is Test {
     }
 
     function testCopy(bytes memory data, uint256 destSeed) public pure {
-        uint256 minDestPtr = Memory.getFreePointer().asUint256();
+        uint256 minDestPtr = Memory.getFreeMemoryPointer().asUint256();
         Memory.Pointer destPtr = bytes32(bound(destSeed, minDestPtr, minDestPtr + END_PTR)).asPointer();
-        destPtr.addOffset(data.length + 32).setFreePointer();
+        destPtr.addOffset(data.length + 32).setFreeMemoryPointer();
         destPtr.copy(data.asPointer(), data.length + 32);
         bytes memory copiedData = destPtr.asBytes();
         assertEq(data.length, copiedData.length);

test/utils/Memory.test.js

@@ -16,23 +16,23 @@ describe('Memory', function () {
   describe('free pointer', function () {
     it('sets free memory pointer', async function () {
       const ptr = ethers.toBeHex(0xa0, 32);
-      await expect(this.mock.$setFreePointer(ptr)).to.not.be.reverted;
+      await expect(this.mock.$setFreeMemoryPointer(ptr)).to.not.be.reverted;
     });
 
     it('gets free memory pointer', async function () {
-      await expect(this.mock.$getFreePointer()).to.eventually.equal(
+      await expect(this.mock.$getFreeMemoryPointer()).to.eventually.equal(
         ethers.toBeHex(0x80, 32), // Default pointer
       );
     });
   });
 
   it('load extracts a word', async function () {
-    const ptr = await this.mock.$getFreePointer();
+    const ptr = await this.mock.$getFreeMemoryPointer();
     await expect(this.mock.$load(ptr)).to.eventually.equal(ethers.toBeHex(0, 32));
   });
 
   it('loadByte extracts a byte', async function () {
-    const ptr = await this.mock.$getFreePointer();
+    const ptr = await this.mock.$getFreeMemoryPointer();
     await expect(this.mock.$loadByte(ptr, 0)).to.eventually.equal(ethers.toBeHex(0, 1));
   });