Rename traits to remove T suffix (#1535)

* Rename traits to renmove T suffix

* Fix doc links

* Fix straggler doc links

core/src/constants/address.rs

@@ -12,7 +12,7 @@ use derive_where::derive_where;
 
 /// This represents a constant address. Anything implementing this trait
 /// can be used to fetch constants.
-pub trait AddressT {
+pub trait Address {
     /// The target type of the value that lives at this address.
     type Target: DecodeWithMetadata;
 
@@ -32,18 +32,20 @@ pub trait AddressT {
 
 /// This represents the address of a constant.
 #[derive_where(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
-pub struct Address<ReturnTy> {
+pub struct DefaultAddress<ReturnTy> {
     pallet_name: Cow<'static, str>,
     constant_name: Cow<'static, str>,
     constant_hash: Option<[u8; 32]>,
     _marker: core::marker::PhantomData<ReturnTy>,
 }
 
+/// The type of address used by our static codegen.
+pub type StaticAddress<ReturnTy> = DefaultAddress<ReturnTy>;
 /// The type of address typically used to return dynamic constant values.
-pub type DynamicAddress = Address<DecodedValueThunk>;
+pub type DynamicAddress = DefaultAddress<DecodedValueThunk>;
 
-impl<ReturnTy> Address<ReturnTy> {
-    /// Create a new [`Address`] to use to look up a constant.
+impl<ReturnTy> DefaultAddress<ReturnTy> {
+    /// Create a new [`DefaultAddress`] to use to look up a constant.
     pub fn new(pallet_name: impl Into<String>, constant_name: impl Into<String>) -> Self {
         Self {
             pallet_name: Cow::Owned(pallet_name.into()),
@@ -53,7 +55,7 @@ impl<ReturnTy> Address<ReturnTy> {
         }
     }
 
-    /// Create a new [`Address`] that will be validated
+    /// Create a new [`DefaultAddress`] that will be validated
     /// against node metadata using the hash given.
     #[doc(hidden)]
     pub fn new_static(
@@ -80,7 +82,7 @@ impl<ReturnTy> Address<ReturnTy> {
     }
 }
 
-impl<ReturnTy: DecodeWithMetadata> AddressT for Address<ReturnTy> {
+impl<ReturnTy: DecodeWithMetadata> Address for DefaultAddress<ReturnTy> {
     type Target = ReturnTy;
 
     fn pallet_name(&self) -> &str {

core/src/constants/mod.rs

@@ -40,7 +40,7 @@
 
 pub mod address;
 
-use address::AddressT;
+use address::Address;
 use alloc::borrow::ToOwned;
 
 use crate::{error::MetadataError, metadata::DecodeWithMetadata, Error, Metadata};
@@ -50,7 +50,7 @@ use crate::{error::MetadataError, metadata::DecodeWithMetadata, Error, Metadata}
 ///
 /// When the provided `address` is dynamic (and thus does not come with any expectation of the
 /// shape of the constant value), this just returns `Ok(())`
-pub fn validate<Address: AddressT>(address: &Address, metadata: &Metadata) -> Result<(), Error> {
+pub fn validate<Addr: Address>(address: &Addr, metadata: &Metadata) -> Result<(), Error> {
     if let Some(actual_hash) = address.validation_hash() {
         let expected_hash = metadata
             .pallet_by_name_err(address.pallet_name())?
@@ -67,10 +67,7 @@ pub fn validate<Address: AddressT>(address: &Address, metadata: &Metadata) -> Re
 
 /// Fetch a constant out of the metadata given a constant address. If the `address` has been
 /// statically generated, this will validate that the constant shape is as expected, too.
-pub fn get<Address: AddressT>(
-    address: &Address,
-    metadata: &Metadata,
-) -> Result<Address::Target, Error> {
+pub fn get<Addr: Address>(address: &Addr, metadata: &Metadata) -> Result<Addr::Target, Error> {
     // 1. Validate constant shape if hash given:
     validate(address, metadata)?;
 
@@ -79,7 +76,7 @@ pub fn get<Address: AddressT>(
         .pallet_by_name_err(address.pallet_name())?
         .constant_by_name(address.constant_name())
         .ok_or_else(|| MetadataError::ConstantNameNotFound(address.constant_name().to_owned()))?;
-    let value = <Address::Target as DecodeWithMetadata>::decode_with_metadata(
+    let value = <Addr::Target as DecodeWithMetadata>::decode_with_metadata(
         &mut constant.value(),
         constant.ty(),
         metadata,