reduce redundant zero initialization for LC data objects (#5479)

Directly initialize `ForkedLightClientObj` instead of separately first
 setting the `kind` (initializing everything to zero) and then assigning
the forky data after that.

beacon_chain/beacon_chain_db_light_client.nim

@@ -504,10 +504,8 @@ proc getBestUpdate*(
       withAll(LightClientDataFork):
         when lcDataFork > LightClientDataFork.None:
           if update[0] == ord(lcDataFork).int64:
-            var obj = ForkedLightClientUpdate(kind: lcDataFork)
+            return ForkedLightClientUpdate.init(SSZ.decode(
-            obj.forky(lcDataFork) = SSZ.decode(
+              update[1], lcDataFork.LightClientUpdate))
-              update[1], lcDataFork.LightClientUpdate)
-            return obj
       warn "Unsupported LC data store kind", store = "bestUpdates",
         period, kind = update[0]
       return default(ForkedLightClientUpdate)

beacon_chain/beacon_node_light_client.nim

@@ -175,8 +175,8 @@ proc updateLightClientFromDag*(node: BeaconNode) =
   withBlck(bdata):
     const lcDataFork = lcDataForkAtConsensusFork(consensusFork)
     when lcDataFork > LightClientDataFork.None:
-      header = ForkedLightClientHeader(kind: lcDataFork)
+      header = ForkedLightClientHeader.init(
-      header.forky(lcDataFork) = forkyBlck.toLightClientHeader(lcDataFork)
+        forkyBlck.toLightClientHeader(lcDataFork))
     else: raiseAssert "Unreachable"
   let current_sync_committee = block:
     let tmpState = assignClone(node.dag.headState)

beacon_chain/consensus_object_pools/blockchain_dag_light_client.nim

@@ -367,15 +367,16 @@ proc initLightClientUpdateForPeriod(
     withStateAndBlck(updatedState, bdata):
       when consensusFork >= ConsensusFork.Altair:
         const lcDataFork = lcDataForkAtConsensusFork(consensusFork)
-        update = ForkedLightClientUpdate(kind: lcDataFork)
+        update = ForkedLightClientUpdate.init(lcDataFork.LightClientUpdate(
-        template forkyUpdate: untyped = update.forky(lcDataFork)
+          attested_header: forkyBlck.toLightClientHeader(lcDataFork),
-        forkyUpdate.attested_header = forkyBlck.toLightClientHeader(lcDataFork)
+          next_sync_committee: forkyState.data.next_sync_committee,
-        forkyUpdate.next_sync_committee = forkyState.data.next_sync_committee
+          next_sync_committee_branch:
-        forkyUpdate.next_sync_committee_branch =
+            forkyState.data.build_proof(altair.NEXT_SYNC_COMMITTEE_INDEX).get,
-          forkyState.data.build_proof(altair.NEXT_SYNC_COMMITTEE_INDEX).get
+          finality_branch:
             if finalizedBid.slot != FAR_FUTURE_SLOT:
-          forkyUpdate.finality_branch =
               forkyState.data.build_proof(altair.FINALIZED_ROOT_INDEX).get
+            else:
+              default(FinalityBranch)))
       else: raiseAssert "Unreachable"
   do:
     dag.handleUnexpectedLightClientError(attestedBid.slot)
@@ -974,18 +975,16 @@ proc getLightClientBootstrap(
 
   # Construct `LightClientBootstrap` from cached data
   const lcDataFork = typeof(header).kind
-  var bootstrap = ForkedLightClientBootstrap(kind: lcDataFork)
+  ForkedLightClientBootstrap.init(lcDataFork.LightClientBootstrap(
-  template forkyBootstrap: untyped = bootstrap.forky(lcDataFork)
+    header: header,
-  forkyBootstrap.header = header
+    current_sync_committee: (block:
-  forkyBootstrap.current_sync_committee =
       dag.lcDataStore.db.getSyncCommittee(period).valueOr:
         debug "LC bootstrap unavailable: Sync committee not cached", period
-      return default(ForkedLightClientBootstrap)
+        return default(ForkedLightClientBootstrap)),
-  forkyBootstrap.current_sync_committee_branch =
+    current_sync_committee_branch: (block:
       dag.lcDataStore.db.getCurrentSyncCommitteeBranch(slot).valueOr:
-      debug "LC bootstrap unavailable: Sync committee branch not cached", slot
+        debug "LC bootstrap unavailable: Committee branch not cached", slot
-      return default(ForkedLightClientBootstrap)
+        return default(ForkedLightClientBootstrap))))
-  bootstrap
 
 proc getLightClientBootstrap*(
     dag: ChainDAGRef,

beacon_chain/gossip_processing/light_client_processor.nim

@@ -230,8 +230,7 @@ proc processObject(
               if initRes.isErr:
                 err(initRes.error)
               else:
-                self.store[] = ForkedLightClientStore(kind: lcDataFork)
+                self.store[] = ForkedLightClientStore.init(initRes.get)
-                self.store[].forky(lcDataFork) = initRes.get
                 ok()
         elif forkyObject is SomeForkyLightClientUpdate:
           if self.store[].kind == LightClientDataFork.None:
@@ -306,16 +305,12 @@ template withReportedProgress(
     var
       oldFinalized = withForkyStore(self.store[]):
         when lcDataFork > LightClientDataFork.None:
-          var header = ForkedLightClientHeader(kind: lcDataFork)
+          ForkedLightClientHeader.init(forkyStore.finalized_header)
-          header.forky(lcDataFork) = forkyStore.finalized_header
-          header
         else:
           default(ForkedLightClientHeader)
       oldOptimistic = withForkyStore(self.store[]):
         when lcDataFork > LightClientDataFork.None:
-          var header = ForkedLightClientHeader(kind: lcDataFork)
+          ForkedLightClientHeader.init(forkyStore.optimistic_header)
-          header.forky(lcDataFork) = forkyStore.optimistic_header
-          header
         else:
           default(ForkedLightClientHeader)
 
@@ -424,12 +419,11 @@ proc resetToFinalizedHeader*(
   discard withReportedProgress:
     withForkyHeader(header):
       when lcDataFork > LightClientDataFork.None:
-        self.store[] = ForkedLightClientStore(kind: lcDataFork)
+        self.store[] = ForkedLightClientStore.init(lcDataFork.LightClientStore(
-        template forkyStore: untyped = self.store[].forky(lcDataFork)
-        forkyStore = lcDataFork.LightClientStore(
           finalized_header: forkyHeader,
           current_sync_committee: current_sync_committee,
-          optimistic_header: forkyHeader)
+          optimistic_header: forkyHeader))
+        template forkyStore: untyped = self.store[].forky(lcDataFork)
         debug "LC reset to finalized header",
           finalizedSlot = forkyStore.finalized_header.beacon.slot,
           optimisticSlot = forkyStore.optimistic_header.beacon.slot

beacon_chain/light_client.nim

@@ -56,9 +56,7 @@ func finalizedHeader*(
     lightClient: LightClient): ForkedLightClientHeader =
   withForkyStore(lightClient.store[]):
     when lcDataFork > LightClientDataFork.None:
-      var header = ForkedLightClientHeader(kind: lcDataFork)
+      ForkedLightClientHeader.init(forkyStore.finalized_header)
-      header.forky(lcDataFork) = forkyStore.finalized_header
-      header
     else:
       default(ForkedLightClientHeader)
 
@@ -66,9 +64,7 @@ func optimisticHeader*(
     lightClient: LightClient): ForkedLightClientHeader =
   withForkyStore(lightClient.store[]):
     when lcDataFork > LightClientDataFork.None:
-      var header = ForkedLightClientHeader(kind: lcDataFork)
+      ForkedLightClientHeader.init(forkyStore.optimistic_header)
-      header.forky(lcDataFork) = forkyStore.optimistic_header
-      header
     else:
       default(ForkedLightClientHeader)
 
@@ -294,9 +290,7 @@ proc installMessageValidators*(
         (ValidationResult.Reject, cstring "Invalid context fork"))
       return ValidationResult.Reject
 
-    const lcDataFork = T.kind
+    let obj = T.Forked.init(msg)
-    var obj = T.Forked(kind: lcDataFork)
-    obj.forky(lcDataFork) = msg
 
     var
       ignoreErrors {.noinit.}: array[2, ValidationError]

beacon_chain/light_client_db.nim

@@ -152,10 +152,8 @@ proc getLatestFinalizedHeader*(
       withAll(LightClientDataFork):
         when lcDataFork > LightClientDataFork.None:
           if header[0] == ord(lcDataFork).int64:
-            var obj = ForkedLightClientHeader(kind: lcDataFork)
+            return ForkedLightClientHeader.init(SSZ.decode(
-            obj.forky(lcDataFork) = SSZ.decode(
+              header[1], lcDataFork.LightClientHeader))
-              header[1], lcDataFork.LightClientHeader)
-            return obj
       warn "Unsupported LC store kind", store = "headers",
         key, kind = header[0]
       return default(ForkedLightClientHeader)

beacon_chain/spec/eth2_apis/eth2_rest_serialization.nim

@@ -2108,13 +2108,12 @@ proc readValue*[T: SomeForkedLightClientObject](
 
   withLcDataFork(lcDataForkAtConsensusFork(version.get)):
     when lcDataFork > LightClientDataFork.None:
-      value = T(kind: lcDataFork)
       try:
-        value.forky(lcDataFork) = RestJson.decode(
+        value = T.init(RestJson.decode(
           string(data.get()),
           T.Forky(lcDataFork),
           requireAllFields = true,
-          allowUnknownFields = true)
+          allowUnknownFields = true))
       except SerializationError:
         reader.raiseUnexpectedValue("Incorrect format (" & $lcDataFork & ")")
     else:

beacon_chain/spec/eth2_apis/rest_light_client_calls.nim

@@ -46,8 +46,7 @@ func decodeSszLightClientObject[T: SomeForkedLightClientObject](
   try:
     withLcDataFork(lcDataForkAtConsensusFork(consensusFork)):
       when lcDataFork > LightClientDataFork.None:
-        var obj = T(kind: lcDataFork)
+        var obj = T.init(SSZ.decode(data, T.Forky(lcDataFork)))
-        obj.forky(lcDataFork) = SSZ.decode(data, T.Forky(lcDataFork))
         obj.checkForkConsistency(cfg, consensusFork)
         obj
       else:
@@ -136,10 +135,9 @@ proc decodeSszLightClientObjects[S: seq[SomeForkedLightClientObject]](
       withLcDataFork(lcDataForkAtConsensusFork(consensusFork)):
         when lcDataFork > LightClientDataFork.None:
           type T = typeof(res[0])
-          var obj = T(kind: lcDataFork)
+          var obj = T.init(SSZ.decode(
-          obj.forky(lcDataFork) = SSZ.decode(
             data.toOpenArray(begin + contextLen, after - 1),
-            T.Forky(lcDataFork))
+            T.Forky(lcDataFork)))
           obj.checkForkConsistency(cfg, consensusFork)
           res.add obj
         else:

beacon_chain/spec/forks_light_client.nim

@@ -461,6 +461,42 @@ template withForkyStore*(
     const lcDataFork {.inject, used.} = LightClientDataFork.None
     body
 
+func init*(
+    x: typedesc[
+      ForkedLightClientHeader |
+      SomeForkedLightClientObject |
+      ForkedLightClientStore],
+    forkyData:
+      ForkyLightClientHeader |
+      SomeForkyLightClientObject |
+      ForkyLightClientStore): auto =
+  type ResultType = typeof(forkyData).Forked
+  static: doAssert ResultType is x
+  const kind = typeof(forkyData).kind
+  when kind == LightClientDataFork.Deneb:
+    ResultType(kind: kind, denebData: forkyData)
+  elif kind == LightClientDataFork.Capella:
+    ResultType(kind: kind, capellaData: forkyData)
+  elif kind == LightClientDataFork.Altair:
+    ResultType(kind: kind, altairData: forkyData)
+  else:
+    static: raiseAssert "Unreachable"
+
+template forky*(
+    x:
+      ForkedLightClientHeader |
+      SomeForkedLightClientObject |
+      ForkedLightClientStore,
+    kind: static LightClientDataFork): untyped =
+  when kind == LightClientDataFork.Deneb:
+    x.denebData
+  elif kind == LightClientDataFork.Capella:
+    x.capellaData
+  elif kind == LightClientDataFork.Altair:
+    x.altairData
+  else:
+    static: raiseAssert "Unreachable"
+
 func toFull*(
     update: SomeForkyLightClientUpdate): auto =
   type ResultType = typeof(update).kind.LightClientUpdate
@@ -486,10 +522,7 @@ func toFull*(
   else:
     withForkyObject(update):
       when lcDataFork > LightClientDataFork.None:
-        var res = ForkedLightClientUpdate(kind: lcDataFork)
+        ForkedLightClientUpdate.init(forkyObject.toFull())
-        template forkyRes: untyped = res.forky(lcDataFork)
-        forkyRes = forkyObject.toFull()
-        res
       else:
         default(ForkedLightClientUpdate)
 
@@ -518,10 +551,7 @@ func toFinality*(
   else:
     withForkyObject(update):
       when lcDataFork > LightClientDataFork.None:
-        var res = ForkedLightClientFinalityUpdate(kind: lcDataFork)
+        ForkedLightClientFinalityUpdate.init(forkyObject.toFinality())
-        template forkyRes: untyped = res.forky(lcDataFork)
-        forkyRes = forkyObject.toFinality()
-        res
       else:
         default(ForkedLightClientFinalityUpdate)
 
@@ -543,10 +573,7 @@ func toOptimistic*(
   else:
     withForkyObject(update):
       when lcDataFork > LightClientDataFork.None:
-        var res = ForkedLightClientOptimisticUpdate(kind: lcDataFork)
+        ForkedLightClientOptimisticUpdate.init(forkyObject.toOptimistic())
-        template forkyRes: untyped = res.forky(lcDataFork)
-        forkyRes = forkyObject.toOptimistic()
-        res
       else:
         default(ForkedLightClientOptimisticUpdate)
 
@@ -581,21 +608,6 @@ func matches*[A, B: SomeForkedLightClientUpdate](a: A, b: B): bool =
     else:
       true
 
-template forky*(
-    x:
-      ForkedLightClientHeader |
-      SomeForkedLightClientObject |
-      ForkedLightClientStore,
-    kind: static LightClientDataFork): untyped =
-  when kind == LightClientDataFork.Deneb:
-    x.denebData
-  elif kind == LightClientDataFork.Capella:
-    x.capellaData
-  elif kind == LightClientDataFork.Altair:
-    x.altairData
-  else:
-    static: raiseAssert "Unreachable"
-
 func migrateToDataFork*(
     x: var ForkedLightClientHeader,
     newKind: static LightClientDataFork) =

beacon_chain/sync/sync_protocol.nim

@@ -153,9 +153,7 @@ proc readChunkPayload*(
         if contextFork !=
             peer.network.cfg.consensusForkAtEpoch(res.get.contextEpoch):
           return neterr InvalidContextBytes
-        var obj = ok MsgType(kind: lcDataFork)
+        return ok MsgType.init(res.get)
-        obj.get.forky(lcDataFork) = res.get
-        return obj
       else:
         return err(res.error)
     else:

beacon_chain/trusted_node_sync.nim

@@ -220,8 +220,7 @@ proc doTrustedNodeSync*(
           quit 1
         bootstrap.migrateToDataFork(lcDataFork)
 
-        var storeRes =
+        var storeRes = initialize_light_client_store(
-          initialize_light_client_store(
           trustedBlockRoot, bootstrap.forky(lcDataFork), cfg)
         if storeRes.isErr:
           error "`initialize_light_client_store` failed", err = storeRes.error

tests/consensus_spec/test_fixture_light_client_sync.nim

@@ -94,10 +94,9 @@ proc loadSteps(path: string, fork_digests: ForkDigests): seq[TestStep] =
       var update {.noinit.}: ForkedLightClientUpdate
       withLcDataFork(lcDataForkAtConsensusFork(update_consensus_fork)):
         when lcDataFork > LightClientDataFork.None:
-          update = ForkedLightClientUpdate(kind: lcDataFork)
+          update = ForkedLightClientUpdate.init(parseTest(
-          update.forky(lcDataFork) = parseTest(
             path/update_filename & ".ssz_snappy", SSZ,
-            lcDataFork.LightClientUpdate)
+            lcDataFork.LightClientUpdate))
         else: raiseAssert "Unreachable update fork " & $update_fork_digest
 
       result.add TestStep(
@@ -177,10 +176,9 @@ proc runTest(suiteName, path: string) =
       var bootstrap {.noinit.}: ForkedLightClientBootstrap
       withLcDataFork(lcDataForkAtConsensusFork(bootstrap_consensus_fork)):
         when lcDataFork > LightClientDataFork.None:
-          bootstrap = ForkedLightClientBootstrap(kind: lcDataFork)
+          bootstrap = ForkedLightClientBootstrap.init(parseTest(
-          bootstrap.forky(lcDataFork) = parseTest(
             path/"bootstrap.ssz_snappy", SSZ,
-            lcDataFork.LightClientBootstrap)
+            lcDataFork.LightClientBootstrap))
         else:
           raiseAssert "Unknown bootstrap fork " & $meta.bootstrap_fork_digest
       bootstrap
@@ -194,10 +192,9 @@ proc runTest(suiteName, path: string) =
       var store {.noinit.}: ForkedLightClientStore
       withLcDataFork(lcDataForkAtConsensusFork(store_consensus_fork)):
         when lcDataFork > LightClientDataFork.None:
-          store = ForkedLightClientStore(kind: lcDataFork)
           bootstrap[].migrateToDataFork(lcDataFork)
-          store.forky(lcDataFork) = initialize_light_client_store(
+          store = ForkedLightClientStore.init(initialize_light_client_store(
-            meta.trusted_block_root, bootstrap[].forky(lcDataFork), cfg).get
+            meta.trusted_block_root, bootstrap[].forky(lcDataFork), cfg).get)
         else: raiseAssert "Unreachable store fork " & $meta.store_fork_digest
       store
 

tests/test_light_client.nim

@@ -148,8 +148,7 @@ suite "Light client" & preset():
         var storeRes = newClone(initialize_light_client_store(
           trusted_block_root, forkyBootstrap, cfg))
         check storeRes[].isOk
-        store = (ref ForkedLightClientStore)(kind: lcDataFork)[]
+        store = newClone(ForkedLightClientStore.init(storeRes[].get))[]
-        store.forky(lcDataFork) = storeRes[].get
 
     # Sync to latest sync committee period
     var numIterations = 0

tests/test_light_client_processor.nim

@@ -284,8 +284,8 @@ suite "Light client processor" & preset():
       var oldFinalized {.noinit.}: ForkedLightClientHeader
       withForkyStore(store[]):
         when lcDataFork > LightClientDataFork.None:
-          oldFinalized = ForkedLightClientHeader(kind: lcDataFork)
+          oldFinalized = ForkedLightClientHeader.init(
-          oldFinalized.forky(lcDataFork) = forkyStore.finalized_header
+            forkyStore.finalized_header)
         else: raiseAssert "Unreachable"
       let finalityUpdate = dag.getLightClientFinalityUpdate()
       check finalityUpdate.kind > LightClientDataFork.None