tmp workspace

.gitignore

@@ -1,3 +1,7 @@
 .DS_Store
-
-node_modules
+cache/
+node_modules
+dist/
+out/
+coverage/
+*.log

.prettierrc.js

@@ -0,0 +1,28 @@
+/**
+ * @file Prettier configuration for Conformance
+ * @version 1.1.0
+ * @summary base config adapted from AirBNB to maximize performance
+ * @schema http://json.schemastore.org/prettierrc
+ */
+
+'use strict';
+
+module.exports = {
+  arrowParens: 'always',
+  bracketSameLine: true,
+  bracketSpacing: false,
+  embeddedLanguageFormatting: 'auto',
+  htmlWhitespaceSensitivity: 'strict',
+  insertPragma: false,
+  jsxSingleQuote: false,
+  printWidth: 110,
+  proseWrap: 'always',
+  quoteProps: 'consistent',
+  requirePragma: false,
+  semi: true,
+  singleQuote: true,
+  tabWidth: 2,
+  trailingComma: 'all',
+  useTabs: false,
+  vueIndentScriptAndStyle: false
+};

contracts/correct_large_integers.sol

@@ -0,0 +1,6 @@
+function _getSwapAmount(uint256 userIn, uint256 reserveIn) internal pure returns (uint256) {
+        return
+            (Babylonian.sqrt(reserveIn * (userIn * 3_988_000 + reserveIn * 3_988_009)) -
+                reserveIn *
+                1_997) / 1_994;
+    }

contracts/fail-constructor.sol

@@ -0,0 +1,10 @@
+contract A is B, C, D {
+    uint x;
+
+    constructor(uint param1, uint param2, uint param3, uint param4, uint param5)
+    B(param1)
+    C(param2, param3)
+    D(param4) {
+        x = param5;
+    }
+}

contracts/fail-function-order.sol

@@ -0,0 +1,7 @@
+function balance(uint256 from) public override view returns (uint256)  {
+    return balanceOf[from];
+}
+
+function shutdown() onlyOwner public {
+    selfdestruct(owner);
+}

contracts/fail-whitespace.sol

@@ -0,0 +1,7 @@
+receive () external payable {
+//
+}
+
+fallback () external {
+//
+}

contracts/fmt_large_int.sol

@@ -0,0 +1,13 @@
+function _getSwapAmount(uint256 userIn, uint256 reserveIn)
+    internal
+    pure
+    returns (uint256)
+{
+    return
+        (
+            Babylonian.sqrt(reserveIn * (userIn * 3988000 + reserveIn * 3988009))
+                - reserveIn
+                * 1997
+        )
+        / 1994;
+}

contracts/no_control_statement.yul

@@ -0,0 +1,55 @@
+object "test"
+{
+    code
+    {
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384_orig(x1, x2, y1, y2) - > out1, out2, carry
+        {
+            // limb 1
+            out1: = add(x1, y1)
+            carry: = lt(out1, x1)
+
+            // limb 2
+            x2: = add(x2, carry)
+            carry: = lt(x2, carry)
+            out2: = add(x2, y2)
+            carry: = or(carry, lt(out2, x2))
+        }
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384(x1, x2, y1, y2) - > out1, out2, carry
+        {
+            // limb 1
+            out1: = add(x1, y1)
+            let carry1: = lt(out1, x1)
+
+            // limb 2
+            let t: = add(x2, y2)
+            let carry2: = lt(t, x2)
+
+            out2: = add(t, carry1)
+            carry: = lt(out2, t)
+
+            carry: = or(carry2, carry)
+        }
+
+        let x1: = calldataload(0)
+        let x2: = calldataload(32)
+        let y1: = calldataload(64)
+        let y2: = calldataload(96)
+
+        let a: = 0
+        let b: = 0
+        let c: = 0
+        a, b, c: = add_with_carry_384_orig(x1, x2, y1, y2)
+
+        mstore(0, a)
+        mstore(32, b)
+        mstore(64, c)
+
+        // orig: 600035604035810181811080602035019250606035830182600052806020528381108285101760405250505050
+        // new:  6000356020356040358201606035820183821081018260005280602052818110848310176040525050505050
+
+    }
+}

contracts/pass-constructor.sol

@@ -0,0 +1,12 @@
+contract A is B, C, D {
+    uint x;
+
+    constructor(uint param1, uint param2, uint param3, uint param4, uint param5)
+        B(param1)
+        C(param2, param3)
+        D(param4)
+    {
+        // do something with param5
+        x = param5;
+    }
+}

contracts/pass-function-order.sol

@@ -0,0 +1,7 @@
+function balance(uint256 from) public view override returns (uint256)  {
+    return balanceOf[from];
+}
+
+function shutdown() public onlyOwner {
+    selfdestruct(owner);
+}

contracts/pass-whitespace.sol

@@ -0,0 +1,7 @@
+receive() external payable {
+//
+}
+
+fallback() external {
+// 
+}

contracts/wrong_large_integers.sol

@@ -0,0 +1,6 @@
+    function _getSwapAmount(uint256 userIn, uint256 reserveIn) internal pure returns (uint256) {
+        return
+            (Babylonian.sqrt(reserveIn * (userIn * 3988000 + reserveIn * 3988009)) -
+                reserveIn *
+                1997) / 1994;
+}

contracts/yes_control_statement_braces.yul

@@ -0,0 +1,51 @@
+object "test" {
+    code {
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384_orig(x1, x2, y1, y2) - > out1, out2, carry {
+            // limb 1
+            out1: = add(x1, y1)
+            carry: = lt(out1, x1)
+
+            // limb 2
+            x2: = add(x2, carry)
+            carry: = lt(x2, carry)
+            out2: = add(x2, y2)
+            carry: = or(carry, lt(out2, x2))
+        }
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384(x1, x2, y1, y2) - > out1, out2, carry {
+            // limb 1
+            out1: = add(x1, y1)
+            let carry1: = lt(out1, x1)
+
+            // limb 2
+            let t: = add(x2, y2)
+            let carry2: = lt(t, x2)
+
+            out2: = add(t, carry1)
+            carry: = lt(out2, t)
+
+            carry: = or(carry2, carry)
+        }
+
+        let x1: = calldataload(0)
+        let x2: = calldataload(32)
+        let y1: = calldataload(64)
+        let y2: = calldataload(96)
+
+        let a: = 0
+        let b: = 0
+        let c: = 0
+        a, b, c: = add_with_carry_384_orig(x1, x2, y1, y2)
+
+        mstore(0, a)
+        mstore(32, b)
+        mstore(64, c)
+
+        // orig: 600035604035810181811080602035019250606035830182600052806020528381108285101760405250505050
+        // new:  6000356020356040358201606035820183821081018260005280602052818110848310176040525050505050
+
+    }
+}

contracts/yes_obj_fmt.yul

@@ -0,0 +1,55 @@
+object "test"
+{
+    code
+    {
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384_orig(x1, x2, y1, y2) - > out1, out2, carry
+        {
+            // limb 1
+            out1: = add(x1, y1)
+            carry: = lt(out1, x1)
+
+            // limb 2
+            x2: = add(x2, carry)
+            carry: = lt(x2, carry)
+            out2: = add(x2, y2)
+            carry: = or(carry, lt(out2, x2))
+        }
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384(x1, x2, y1, y2) - > out1, out2, carry
+        {
+            // limb 1
+            out1: = add(x1, y1)
+            let carry1: = lt(out1, x1)
+
+            // limb 2
+            let t: = add(x2, y2)
+            let carry2: = lt(t, x2)
+
+            out2: = add(t, carry1)
+            carry: = lt(out2, t)
+
+            carry: = or(carry2, carry)
+        }
+
+        let x1: = calldataload(0)
+        let x2: = calldataload(32)
+        let y1: = calldataload(64)
+        let y2: = calldataload(96)
+
+        let a: = 0
+        let b: = 0
+        let c: = 0
+        a, b, c: = add_with_carry_384_orig(x1, x2, y1, y2)
+
+        mstore(0, a)
+        mstore(32, b)
+        mstore(64, c)
+
+        // orig: 600035604035810181811080602035019250606035830182600052806020528381108285101760405250505050
+        // new:  6000356020356040358201606035820183821081018260005280602052818110848310176040525050505050
+
+    }
+}

contracts/yes_own_line_braces.yul

@@ -0,0 +1,51 @@
+object "test" {
+    code {
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384_orig(x1, x2, y1, y2) - > out1, out2, carry {
+            // limb 1
+            out1: = add(x1, y1)
+            carry: = lt(out1, x1)
+
+            // limb 2
+            x2: = add(x2, carry)
+            carry: = lt(x2, carry)
+            out2: = add(x2, y2)
+            carry: = or(carry, lt(out2, x2))
+        }
+
+        // This assumes each limb is 256-bit and the half of the second limb is not dirty.
+        function add_with_carry_384(x1, x2, y1, y2) - > out1, out2, carry {
+            // limb 1
+            out1: = add(x1, y1)
+            let carry1: = lt(out1, x1)
+
+            // limb 2
+            let t: = add(x2, y2)
+            let carry2: = lt(t, x2)
+
+            out2: = add(t, carry1)
+            carry: = lt(out2, t)
+
+            carry: = or(carry2, carry)
+        }
+
+        let x1: = calldataload(0)
+        let x2: = calldataload(32)
+        let y1: = calldataload(64)
+        let y2: = calldataload(96)
+
+        let a: = 0
+        let b: = 0
+        let c: = 0
+        a, b, c: = add_with_carry_384_orig(x1, x2, y1, y2)
+
+        mstore(0, a)
+        mstore(32, b)
+        mstore(64, c)
+
+        // orig: 600035604035810181811080602035019250606035830182600052806020528381108285101760405250505050
+        // new:  6000356020356040358201606035820183821081018260005280602052818110848310176040525050505050
+
+    }
+}