all: clean up some dead_code annotations (#6103)

* graph: Move 'struct PoI' into tests module

Otherwise, we get warnings about unused code

* runtime: Remove unused enum AscSubgraphEntityOp

* store: Remove unused struct CopyVid

* graph: remove unused UnresolvedDataSource.resolve

* all: remove unnecessary dead_code annotation in a few places

* store: Remove unused deployment::features

Author: lutter

graph/src/components/subgraph/proof_of_indexing/mod.rs

@@ -81,6 +81,7 @@ impl SharedProofOfIndexing {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
     use crate::{
         data::store::Id,
         prelude::{BlockPtr, DeploymentHash, Value},
@@ -97,6 +98,33 @@ mod tests {
     use std::convert::TryInto;
     use web3::types::{Address, H256};
 
+    /// The PoI is the StableHash of this struct. This reference implementation is
+    /// mostly here just to make sure that the online implementation is
+    /// well-implemented (without conflicting sequence numbers, or other oddities).
+    /// It's just way easier to check that this works, and serves as a kind of
+    /// documentation as a side-benefit.
+    pub struct PoI<'a> {
+        pub causality_regions: HashMap<String, PoICausalityRegion<'a>>,
+        pub subgraph_id: DeploymentHash,
+        pub block_hash: H256,
+        pub indexer: Option<Address>,
+    }
+
+    fn h256_as_bytes(val: &H256) -> AsBytes<&[u8]> {
+        AsBytes(val.as_bytes())
+    }
+
+    fn indexer_opt_as_bytes(val: &Option<Address>) -> Option<AsBytes<&[u8]>> {
+        val.as_ref().map(|v| AsBytes(v.as_bytes()))
+    }
+
+    impl_stable_hash!(PoI<'_> {
+        causality_regions,
+        subgraph_id,
+        block_hash: h256_as_bytes,
+        indexer: indexer_opt_as_bytes
+    });
+
     /// Verify that the stable hash of a reference and online implementation match
     fn check(case: Case, cache: &mut HashMap<String, &str>) {
         let logger = Logger::root(Discard, o!());

graph/src/components/subgraph/proof_of_indexing/reference.rs

@@ -1,38 +1,5 @@
 use super::ProofOfIndexingEvent;
-use crate::prelude::DeploymentHash;
-use crate::util::stable_hash_glue::{impl_stable_hash, AsBytes};
-use std::collections::HashMap;
-use web3::types::{Address, H256};
-
-/// The PoI is the StableHash of this struct. This reference implementation is
-/// mostly here just to make sure that the online implementation is
-/// well-implemented (without conflicting sequence numbers, or other oddities).
-/// It's just way easier to check that this works, and serves as a kind of
-/// documentation as a side-benefit.
-#[allow(dead_code)]
-pub struct PoI<'a> {
-    pub causality_regions: HashMap<String, PoICausalityRegion<'a>>,
-    pub subgraph_id: DeploymentHash,
-    pub block_hash: H256,
-    pub indexer: Option<Address>,
-}
-
-#[allow(dead_code)]
-fn h256_as_bytes(val: &H256) -> AsBytes<&[u8]> {
-    AsBytes(val.as_bytes())
-}
-
-#[allow(dead_code)]
-fn indexer_opt_as_bytes(val: &Option<Address>) -> Option<AsBytes<&[u8]>> {
-    val.as_ref().map(|v| AsBytes(v.as_bytes()))
-}
-
-impl_stable_hash!(PoI<'_> {
-    causality_regions,
-    subgraph_id,
-    block_hash: h256_as_bytes,
-    indexer: indexer_opt_as_bytes
-});
+use crate::util::stable_hash_glue::impl_stable_hash;
 
 pub struct PoICausalityRegion<'a> {
     pub blocks: Vec<Block<'a>>,

graph/src/data_source/offchain.rs

@@ -374,39 +374,6 @@ pub struct UnresolvedMapping {
     pub entities: Vec<String>,
 }
 
-impl UnresolvedDataSource {
-    #[allow(dead_code)]
-    pub(super) async fn resolve(
-        self,
-        resolver: &Arc<dyn LinkResolver>,
-        logger: &Logger,
-        manifest_idx: u32,
-        causality_region: CausalityRegion,
-        schema: &InputSchema,
-    ) -> Result<DataSource, Error> {
-        info!(logger, "Resolve offchain data source";
-            "name" => &self.name,
-            "kind" => &self.kind,
-            "source" => format_args!("{:?}", &self.source),
-        );
-
-        let kind = OffchainDataSourceKind::from_str(self.kind.as_str())?;
-        let source = kind.try_parse_source(Bytes::from(self.source.file.link.as_bytes()))?;
-
-        Ok(DataSource {
-            manifest_idx,
-            kind,
-            name: self.name,
-            source,
-            mapping: self.mapping.resolve(resolver, schema, logger).await?,
-            context: Arc::new(None),
-            creation_block: None,
-            done_at: Arc::new(AtomicI32::new(NOT_DONE_VALUE)),
-            causality_region,
-        })
-    }
-}
-
 impl UnresolvedMapping {
     pub async fn resolve(
         self,

graph/src/data_source/subgraph.rs

@@ -344,7 +344,6 @@ impl UnresolvedDataSource {
         Ok(())
     }
 
-    #[allow(dead_code)]
     pub(super) async fn resolve<C: Blockchain>(
         self,
         resolver: &Arc<dyn LinkResolver>,

graph/src/schema/input/mod.rs

@@ -1702,7 +1702,6 @@ mod validations {
 
     /// Helper struct for validations
     struct Schema<'a> {
-        #[allow(dead_code)]
         spec_version: &'a Version,
         schema: &'a BaseSchema,
         subgraph_schema_type: Option<&'a s::ObjectType>,

graphql/src/store/resolver.rs

@@ -24,7 +24,6 @@ use crate::query::ext::BlockConstraint;
 /// A resolver that fetches entities from a `Store`.
 #[derive(Clone, CheapClone)]
 pub struct StoreResolver {
-    #[allow(dead_code)]
     logger: Logger,
     pub(crate) store: Arc<dyn QueryStore>,
     pub(crate) block_ptr: Option<BlockPtr>,

runtime/wasm/src/error.rs

@@ -9,7 +9,6 @@ pub enum DeterminismLevel {
     Deterministic,
 
     /// This error is known to be non-deterministic. For example, an intermittent http failure.
-    #[allow(dead_code)]
     NonDeterministic,
 
     /// The runtime is processing a given block, but there is an indication that the blockchain client

runtime/wasm/src/to_from/external.rs

@@ -10,7 +10,6 @@ use graph::runtime::{
 use graph::{data::store, runtime::DeterministicHostError};
 use graph::{prelude::serde_json, runtime::FromAscObj};
 use graph::{prelude::web3::types as web3, runtime::AscHeap};
-use graph_runtime_derive::AscType;
 
 use crate::asc_abi::class::*;
 
@@ -465,14 +464,6 @@ where
     }
 }
 
-#[derive(Debug, Clone, Eq, PartialEq, AscType)]
-#[allow(dead_code)]
-pub enum AscSubgraphEntityOp {
-    Create,
-    Modify,
-    Delete,
-}
-
 impl ToAscObj<AscEnum<YamlValueKind>> for serde_yaml::Value {
     fn to_asc_obj<H: AscHeap + ?Sized>(
         &self,

server/index-node/src/resolver.rs

@@ -98,7 +98,6 @@ pub struct IndexNodeResolver<S: Store> {
     logger: Logger,
     blockchain_map: Arc<BlockchainMap>,
     store: Arc<S>,
-    #[allow(dead_code)]
     link_resolver: Arc<dyn LinkResolver>,
     bearer_token: Option<String>,
 }

store/postgres/src/chain_head_listener.rs

@@ -40,7 +40,6 @@ impl Watcher {
         }
     }
 
-    #[allow(dead_code)]
     fn send(&self) {
         // Unwrap: `self` holds a receiver.
         self.sender.send(()).unwrap()