Restore previous behavior of initializer during construction

contracts/mocks/InitializableMock.sol

@@ -60,6 +60,18 @@ contract ConstructorInitializableMock is Initializable {
     }
 }
 
+contract ChildConstructorInitializableMock is ConstructorInitializableMock {
+    bool public childInitializerRan;
+
+    constructor() initializer {
+        childInitialize();
+    }
+
+    function childInitialize() public initializer {
+        childInitializerRan = true;
+    }
+}
+
 contract ReinitializerMock is Initializable {
     uint256 public counter;
 

contracts/proxy/utils/Initializable.sol

@@ -134,16 +134,21 @@ abstract contract Initializable {
         // If the contract is initializing we ignore whether _initialized is set in order to support multiple
         // inheritance patterns, but we only do this in the context of a constructor, and for the lowest level
         // of initializers, because in other contexts the contract may have been reentered.
-        if (_initializing) {
-            require(
-                version == 1 && !Address.isContract(address(this)),
-                "Initializable: contract is already initialized"
-            );
-            return false;
-        } else {
-            require(_initialized < version, "Initializable: contract is already initialized");
+
+        bool isTopLevelCall = !_initializing; // cache sload
+        uint8 currentVersion = _initialized; // cache sload
+
+        require(
+            (isTopLevelCall && version > currentVersion) || // not nested with increasing version or
+                (!isTopLevelCall && version == currentVersion) || // nested with same version or
+                (!Address.isContract(address(this)) && version == 1), // contract being constructed
+            "Initializable: contract is already initialized"
+        );
+
+        if (isTopLevelCall) {
             _initialized = version;
-            return true;
         }
+
+        return isTopLevelCall;
     }
 }

test/proxy/utils/Initializable.test.js

@@ -3,6 +3,7 @@ const { expect } = require('chai');
 
 const InitializableMock = artifacts.require('InitializableMock');
 const ConstructorInitializableMock = artifacts.require('ConstructorInitializableMock');
+const ChildConstructorInitializableMock = artifacts.require('ChildConstructorInitializableMock');
 const ReinitializerMock = artifacts.require('ReinitializerMock');
 const SampleChild = artifacts.require('SampleChild');
 
@@ -33,8 +34,8 @@ contract('Initializable', function (accounts) {
     });
 
     describe('nested under an initializer', function () {
-      it('initializer modifier reverts', async function () {
-        await expectRevert(this.contract.initializerNested(), 'Initializable: contract is already initialized');
+      it('initializer modifier can be nested', async function () {
+        await this.contract.initializerNested();
       });
 
       it('onlyInitializing modifier succeeds', async function () {
@@ -54,6 +55,13 @@ contract('Initializable', function (accounts) {
     expect(await contract2.onlyInitializingRan()).to.equal(true);
   });
 
+  it('multiple constructor levels can be initializers', async function () {
+    const contract2 = await ChildConstructorInitializableMock.new();
+    expect(await contract2.initializerRan()).to.equal(true);
+    expect(await contract2.childInitializerRan()).to.equal(true);
+    expect(await contract2.onlyInitializingRan()).to.equal(true);
+  });
+
   describe('reinitialization', function () {
     beforeEach('deploying', async function () {
       this.contract = await ReinitializerMock.new();
@@ -77,7 +85,13 @@ contract('Initializable', function (accounts) {
       expect(await this.contract.counter()).to.be.bignumber.equal('2');
     });
 
-    it('cannot nest reinitializers', async function () {
+    it('can nest reinitializers with same version', async function () {
+      expect(await this.contract.counter()).to.be.bignumber.equal('0');
+      await this.contract.nestedReinitialize(2, 2);
+      expect(await this.contract.counter()).to.be.bignumber.equal('1');
+    });
+
+    it('cannot nest reinitializers with different versions', async function () {
       expect(await this.contract.counter()).to.be.bignumber.equal('0');
       await expectRevert(this.contract.nestedReinitialize(2, 3), 'Initializable: contract is already initialized');
       await expectRevert(this.contract.nestedReinitialize(3, 2), 'Initializable: contract is already initialized');