Generate already lint code from procedural generation (#5060)

scripts/generate/templates/SlotDerivation.t.js

@@ -14,31 +14,31 @@ const array = `\
 bytes[] private _array;
 
 function symbolicDeriveArray(uint256 length, uint256 offset) public {
-  vm.assume(length > 0);
-  vm.assume(offset < length);
-  _assertDeriveArray(length, offset);
+    vm.assume(length > 0);
+    vm.assume(offset < length);
+    _assertDeriveArray(length, offset);
 }
 
 function testDeriveArray(uint256 length, uint256 offset) public {
-  length = bound(length, 1, type(uint256).max);
-  offset = bound(offset, 0, length - 1);
-  _assertDeriveArray(length, offset);
+    length = bound(length, 1, type(uint256).max);
+    offset = bound(offset, 0, length - 1);
+    _assertDeriveArray(length, offset);
 }
 
 function _assertDeriveArray(uint256 length, uint256 offset) public {
-  bytes32 baseSlot;
-  assembly {
-    baseSlot := _array.slot
-    sstore(baseSlot, length) // store length so solidity access does not revert
-  }
+    bytes32 baseSlot;
+    assembly {
+        baseSlot := _array.slot
+        sstore(baseSlot, length) // store length so solidity access does not revert
+    }
 
-  bytes storage derived = _array[offset];
-  bytes32 derivedSlot;
-  assembly {
-    derivedSlot := derived.slot
-  }
+    bytes storage derived = _array[offset];
+    bytes32 derivedSlot;
+    assembly {
+        derivedSlot := derived.slot
+    }
 
-  assertEq(baseSlot.deriveArray().offset(offset), derivedSlot);
+    assertEq(baseSlot.deriveArray().offset(offset), derivedSlot);
 }
 `;
 
@@ -46,18 +46,18 @@ const mapping = ({ type, name }) => `\
 mapping(${type} => bytes) private _${type}Mapping;
 
 function testSymbolicDeriveMapping${name}(${type} key) public {
-  bytes32 baseSlot;
-  assembly {
-    baseSlot := _${type}Mapping.slot
-  }
+    bytes32 baseSlot;
+    assembly {
+        baseSlot := _${type}Mapping.slot
+    }
 
-  bytes storage derived = _${type}Mapping[key];
-  bytes32 derivedSlot;
-  assembly {
-    derivedSlot := derived.slot
-  }
+    bytes storage derived = _${type}Mapping[key];
+    bytes32 derivedSlot;
+    assembly {
+        derivedSlot := derived.slot
+    }
 
-  assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    assertEq(baseSlot.deriveMapping(key), derivedSlot);
 }
 `;
 
@@ -65,45 +65,49 @@ const boundedMapping = ({ type, name }) => `\
 mapping(${type} => bytes) private _${type}Mapping;
 
 function testDeriveMapping${name}(${type} memory key) public {
-  _assertDeriveMapping${name}(key);
+    _assertDeriveMapping${name}(key);
 }
 
 function symbolicDeriveMapping${name}() public {
-  _assertDeriveMapping${name}(svm.create${name}(256, "DeriveMapping${name}Input"));
+    _assertDeriveMapping${name}(svm.create${name}(256, "DeriveMapping${name}Input"));
 }
 
 function _assertDeriveMapping${name}(${type} memory key) internal {
-  bytes32 baseSlot;
-  assembly {
-      baseSlot := _${type}Mapping.slot
-  }
+    bytes32 baseSlot;
+    assembly {
+        baseSlot := _${type}Mapping.slot
+    }
 
-  bytes storage derived = _${type}Mapping[key];
-  bytes32 derivedSlot;
-  assembly {
-      derivedSlot := derived.slot
-  }
+    bytes storage derived = _${type}Mapping[key];
+    bytes32 derivedSlot;
+    assembly {
+        derivedSlot := derived.slot
+    }
 
-  assertEq(baseSlot.deriveMapping(key), derivedSlot);
+    assertEq(baseSlot.deriveMapping(key), derivedSlot);
 }
 `;
 
 // GENERATE
 module.exports = format(
-  header.trimEnd(),
+  header,
   'contract SlotDerivationTest is Test, SymTest {',
-  'using SlotDerivation for bytes32;',
-  '',
-  array,
-  TYPES.flatMap(type =>
+  format(
     [].concat(
-      type,
-      (type.variants ?? []).map(variant => ({
-        type: variant,
-        name: capitalize(variant),
-        isValueType: type.isValueType,
-      })),
+      'using SlotDerivation for bytes32;',
+      '',
+      array,
+      TYPES.flatMap(type =>
+        [].concat(
+          type,
+          (type.variants ?? []).map(variant => ({
+            type: variant,
+            name: capitalize(variant),
+            isValueType: type.isValueType,
+          })),
+        ),
+      ).map(type => (type.isValueType ? mapping(type) : boundedMapping(type))),
     ),
-  ).map(type => (type.isValueType ? mapping(type) : boundedMapping(type))),
+  ).trimEnd(),
   '}',
 );