Automatic checking of storage compatibility of structs and enums

packages/core/contracts/test/ManifestMigrate.sol

@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.6.8;
+
+contract ManifestMigrateLayout {
+    struct T {
+        bool b;
+    }
+
+    struct S {
+        uint x;
+        string s;
+        T t;
+    }
+
+    enum E {
+        E1,
+        E2
+    }
+
+    uint x1;
+    T t1;
+    S s1;
+    string s2;
+    bool b1;
+    E e1;
+}
+
+contract ManifestMigrateUnique is ManifestMigrateLayout {
+    function useAll() external {
+        x1 = 5;
+        t1 = T({ b: true });
+        s1 = S({ x: 6, s: "ok", t: t1 });
+        s2 = "no";
+        b1 = false;
+        e1 = E.E2;
+    }
+}
+
+contract ManifestMigrateUnambiguous0 is ManifestMigrateLayout {
+    function useAll() external {
+        x1 = 10;
+        t1 = T({ b: false });
+        s1 = S({ x: 6, s: "string", t: t1 });
+        s2 = "ok";
+        b1 = false;
+        e1 = E.E1;
+    }
+}
+
+// These two are expected to have the same bytecode modulo metadata.
+contract ManifestMigrateUnambiguous1 is ManifestMigrateUnambiguous0 { }
+contract ManifestMigrateUnambiguous2 is ManifestMigrateUnambiguous0 { }
+
+// These two are expected to have the same bytecode modulo metadata and similar
+// layout, but different types (see struct D members);
+contract ManifestMigrateAmbiguous1 is ManifestMigrateUnique {
+    struct D {
+        uint w;
+    }
+    D d1;
+    function test() external {
+        d1.w += 1;
+    }
+}
+contract ManifestMigrateAmbiguous2 is ManifestMigrateUnique {
+    struct D {
+        uint z;
+    }
+    D d1;
+    function test() external {
+        d1.z += 1;
+    }
+}

packages/core/contracts/test/Storage.sol

@@ -128,3 +128,234 @@ contract StorageUpgrade_Delete_V1 {
 contract StorageUpgrade_Delete_V2 {
   address x2;
 }
+
+contract StorageUpgrade_Struct_V1 {
+    struct StructInner {
+        uint y;
+    }
+    struct Struct1 {
+        uint x;
+        string s1;
+        string s2;
+        StructInner inner;
+    }
+    Struct1 data1;
+    Struct1 data2;
+    mapping (uint => Struct1) m;
+    Struct1[10] a1;
+    Struct1[10] a2;
+    Struct1 data3;
+}
+
+contract StorageUpgrade_Struct_V2_Ok {
+    struct StructInner {
+        uint y;
+    }
+    struct Struct2 {
+        uint x;
+        string s1;
+        string s2;
+        StructInner inner;
+    }
+    struct Struct2Plus {
+        uint x;
+        string s1;
+        string s2;
+        StructInner inner;
+        uint z;
+    }
+    Struct2 data1;
+    Struct2 data2;
+    mapping (uint => Struct2Plus) m;
+    Struct2[10] a1;
+    Struct2[10] a2;
+    Struct2 data3;
+}
+
+contract StorageUpgrade_Struct_V2_Bad {
+    struct StructInner {
+        uint y;
+    }
+    struct StructInnerPlus {
+        uint y;
+        uint z;
+    }
+    struct Struct2Minus {
+        uint x;
+        string s2;
+        StructInner inner;
+    }
+    struct Struct2Plus {
+        uint x;
+        string s1;
+        string s2;
+        StructInner inner;
+        uint z;
+    }
+    struct Struct2Changed {
+        string x;
+        uint s1;
+        string s2;
+        StructInnerPlus inner;
+    }
+    Struct2Minus data1;
+    Struct2Plus data2;
+    mapping (uint => Struct2Minus) m;
+    Struct2Minus[10] a1;
+    Struct2Plus[10] a2;
+    Struct2Changed data3;
+}
+
+contract StorageUpgrade_Enum_V1 {
+    enum Enum1 {
+        A,
+        B
+    }
+    Enum1 data1;
+    Enum1 data2;
+    Enum1 data3;
+    Enum1 data4;
+}
+
+contract StorageUpgrade_Enum_V2_Ok {
+    enum Enum2 {
+        A,
+        B
+    }
+    enum Enum2Larger {
+        A,
+        B,
+        C
+    }
+    Enum2Larger data1;
+    Enum2 data2;
+    Enum2 data3;
+    Enum2 data4;
+}
+
+contract StorageUpgrade_Enum_V2_Bad {
+    enum Enum2Delete {
+        A
+    }
+    enum Enum2Replace {
+        A,
+        X
+    }
+    enum Enum2Insert {
+        X,
+        A,
+        B
+    }
+    Enum2Delete data1;
+    Enum2Replace data2;
+    Enum2Insert data3;
+
+    enum Enum2TooLarge {
+        A,
+        B,
+        V3, V4, V5, V6, V7, V8, V9, V10, V11, V12, V13, V14, V15, V16, V17, V18, V19, V20, V21, V22, V23, V24, V25, V26, V27, V28, V29, V30, V31, V32, V33, V34, V35, V36, V37, V38, V39, V40, V41, V42, V43, V44, V45, V46, V47, V48, V49, V50, V51, V52, V53, V54, V55, V56, V57, V58, V59, V60, V61, V62, V63, V64, V65, V66, V67, V68, V69, V70, V71, V72, V73, V74, V75, V76, V77, V78, V79, V80, V81, V82, V83, V84, V85, V86, V87, V88, V89, V90, V91, V92, V93, V94, V95, V96, V97, V98, V99, V100, V101, V102, V103, V104, V105, V106, V107, V108, V109, V110, V111, V112, V113, V114, V115, V116, V117, V118, V119, V120, V121, V122, V123, V124, V125, V126, V127, V128, V129, V130, V131, V132, V133, V134, V135, V136, V137, V138, V139, V140, V141, V142, V143, V144, V145, V146, V147, V148, V149, V150, V151, V152, V153, V154, V155, V156, V157, V158, V159, V160, V161, V162, V163, V164, V165, V166, V167, V168, V169, V170, V171, V172, V173, V174, V175, V176, V177, V178, V179, V180, V181, V182, V183, V184, V185, V186, V187, V188, V189, V190, V191, V192, V193, V194, V195, V196, V197, V198, V199, V200, V201, V202, V203, V204, V205, V206, V207, V208, V209, V210, V211, V212, V213, V214, V215, V216, V217, V218, V219, V220, V221, V222, V223, V224, V225, V226, V227, V228, V229, V230, V231, V232, V233, V234, V235, V236, V237, V238, V239, V240, V241, V242, V243, V244, V245, V246, V247, V248, V249, V250, V251, V252, V253, V254, V255, V256,
+        OneTooMany
+    }
+    Enum2TooLarge data4;
+}
+
+contract StorageUpgrade_Recursive_V1 {
+    struct Recursive {
+        mapping (uint => Recursive) s;
+    }
+    Recursive data;
+}
+
+contract StorageUpgrade_Recursive_V2 {
+    struct Recursive {
+        mapping (uint => Recursive) s;
+    }
+    Recursive data;
+}
+
+contract StorageUpgrade_Rename_V1 {
+    uint x1;
+    uint x2;
+    uint x3;
+}
+
+contract StorageUpgrade_Rename_V2 {
+    uint x1;
+    uint renamed;
+    uint x3;
+}
+
+contract StorageUpgrade_Replace_V1 {
+    uint x1;
+    uint x2;
+    uint x3;
+}
+
+contract StorageUpgrade_Replace_V2 {
+    uint x1;
+    string renamed;
+    uint x3;
+}
+
+contract StorageUpgrade_ObviousMismatch_V1 {
+    struct S {
+        uint m;
+    }
+
+    uint x1;
+    S s1;
+    uint[] a1;
+}
+
+contract StorageUpgrade_ObviousMismatch_V2_Bad {
+    string x1;
+    uint s1;
+    mapping (uint => uint) a1;
+}
+
+contract StorageUpgrade_Contract_V1 {
+    StorageUpgrade_Contract_V1 data;
+}
+
+contract StorageUpgrade_Contract_V2 {
+    StorageUpgrade_Contract_V2 data;
+}
+
+contract StorageUpgrade_Array_V1 {
+    uint[20] x1;
+    uint[20] x2;
+    uint[20] x3;
+    uint[] x4;
+    mapping (uint => uint[20]) m;
+}
+
+contract StorageUpgrade_Array_V2_Ok {
+    uint[20] x1;
+    uint[20] x2;
+    uint[20] x3;
+    uint[] x4;
+    mapping (uint => uint[25]) m;
+}
+
+contract StorageUpgrade_Array_V2_Bad {
+    uint[15] x1;
+    uint[25] x2;
+    uint[] x3;
+    uint[20] x4;
+    mapping (uint => uint[15]) m;
+}
+
+contract StorageUpgrade_Mapping_V1 {
+    mapping (uint => uint[10]) m1;
+    mapping (string => uint) m2;
+}
+
+contract StorageUpgrade_Mapping_V2_Ok {
+    mapping (uint => uint[10]) m1;
+    mapping (string => uint) m2;
+}
+
+contract StorageUpgrade_Mapping_V2_Bad {
+    mapping (uint => uint) m1;
+    mapping (bool => uint) m2;
+}

packages/core/contracts/test/Validations.sol

@@ -55,60 +55,6 @@ import './ValidationsImport.sol';
 contract ImportedParentHasStateVariableAssignment is ImportedHasStateVariableAssignment {
 }
 
-contract HasStruct {
-    struct Foo {
-        bool bar;
-    }
-
-    Foo foo;
-}
-
-contract HasEnum {
-    enum Foo { BAR }
-}
-
-contract ParentHasStruct is HasStruct {}
-contract ParentHasEnum is HasEnum {}
-
-library LibraryWithEnum {
-  enum Animal { DOG, CAT }
-
-  function isCat(Animal animal) internal pure returns (bool) {
-    return animal == Animal.CAT;
-  }
-}
-
-library LibraryWithStruct {
-  struct Animal {
-    string kind;
-    uint age;
-  }
-
-  function getAge(Animal memory animal) internal pure returns (uint) {
-    return animal.age;
-  }
-}
-
-contract UsesLibraryWithStruct {
-  using LibraryWithStruct for LibraryWithStruct.Animal;
-
-  LibraryWithStruct.Animal animal;
-
-  function getAge() public view returns (uint) {
-    return animal.getAge();
-  }
-}
-
-contract UsesLibraryWithEnum {
-  using LibraryWithEnum for LibraryWithEnum.Animal;
-
-  LibraryWithEnum.Animal animal;
-
-  function isCat() public view returns (bool) {
-    return animal.isCat();
-  }
-}
-
 // For each of 3 dimensions, libraries usage can be
 // 1. implicit or explicit (_use for_ directive or not)
 // 2. upgrade safe or unsafe

packages/core/package.json

@@ -20,7 +20,7 @@
     "prepare:contracts": "hardhat compile",
     "prepublishOnly": "bash scripts/copy-artifacts.sh",
     "test": "tsc -b && hardhat compile --force && ava",
-    "test:watch": "hardhat compile --force && fgbg 'ava --watch' 'tsc -b --watch'",
+    "test:watch": "hardhat compile --force && fgbg 'ava --watch' 'tsc -b --watch' --",
     "version": "node ../../scripts/bump-changelog.js"
   },
   "devDependencies": {
@@ -50,7 +50,8 @@
     "ethereumjs-util": "^7.0.3",
     "fp-ts": "^2.7.1",
     "io-ts": "^2.2.9",
+    "promise.allsettled": "^1.0.2",
     "proper-lockfile": "^4.1.1",
-    "solidity-ast": "^0.4.4"
+    "solidity-ast": "^0.4.15"
   }
 }