Add type cache to Fuel ABI.

Author: tritao

forc-pkg/src/pkg.rs

@@ -1811,6 +1811,8 @@ pub fn compile(
                         abi_with_callpaths: true,
                         type_ids_to_full_type_str: HashMap::<String, String>::new(),
                         unique_names: HashMap::new(),
+                        metadata_declaration_cache: HashMap::new(),
+                        concrete_declaration_cache: HashMap::new(),
                         experimental,
                     },
                     engines,

sway-core/src/abi_generation/fuel_abi.rs

@@ -46,6 +46,8 @@ pub struct AbiContext<'a> {
     pub abi_with_callpaths: bool,
     pub type_ids_to_full_type_str: HashMap<String, String>,
     pub unique_names: HashMap<String, AbiNameDiagnosticSpan>,
+    pub metadata_declaration_cache: HashMap<TypeCacheKey, program_abi::TypeMetadataDeclaration>,
+    pub concrete_declaration_cache: HashMap<TypeCacheKey, program_abi::TypeConcreteDeclaration>,
     pub experimental: ExperimentalFeatures,
 }
 
@@ -61,6 +63,41 @@ impl AbiContext<'_> {
     }
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct TypeCacheKey(u64);
+
+impl TypeCacheKey {
+    fn from_type_id(engines: &Engines, abi_type_aliases_enabled: bool, type_id: TypeId) -> Self {
+        let type_engine = engines.te();
+        let type_info = &*type_engine.get(type_id);
+        Self::from_type_info(type_info, engines, abi_type_aliases_enabled)
+    }
+
+    fn from_type_info(
+        type_info: &TypeInfo,
+        engines: &Engines,
+        abi_type_aliases_enabled: bool,
+    ) -> Self {
+        if abi_type_aliases_enabled {
+            if let TypeInfo::Alias { name, ty } = type_info {
+                let mut hasher = DefaultHasher::new();
+                name.hash(&mut hasher);
+
+                let target_type_id = engines.te().get_unaliased_type_id(ty.type_id);
+                let target_key =
+                    TypeCacheKey::from_type_id(engines, abi_type_aliases_enabled, target_type_id);
+                target_key.0.hash(&mut hasher);
+
+                return TypeCacheKey(hasher.finish());
+            }
+        }
+
+        let mut hasher = DefaultHasher::new();
+        type_info.hash(&mut hasher, engines);
+        TypeCacheKey(hasher.finish())
+    }
+}
+
 pub fn extract_abi_name_inner(span: &Span) -> Option<Span> {
     let text = &span.src().text;
     let full_attr = span.as_str();
@@ -619,6 +656,12 @@ fn generate_concrete_type_declaration(
     type_id: TypeId,
     resolved_type_id: TypeId,
 ) -> Result<ConcreteTypeId, ErrorEmitted> {
+    let cache_key =
+        TypeCacheKey::from_type_id(engines, ctx.experimental.abi_type_aliases, resolved_type_id);
+    if let Some(cached_decl) = ctx.concrete_declaration_cache.get(&cache_key) {
+        return Ok(cached_decl.concrete_type_id.clone());
+    }
+
     let mut metadata_types_to_add = Vec::<program_abi::TypeMetadataDeclaration>::new();
 
     let type_metadata_decl = generate_type_metadata_declaration(
@@ -670,6 +713,8 @@ fn generate_concrete_type_declaration(
         alias_of: None,
     };
 
+    ctx.concrete_declaration_cache
+        .insert(cache_key, concrete_type_decl.clone());
     concrete_types.push(concrete_type_decl);
 
     Ok(concrete_type_id)
@@ -686,6 +731,12 @@ fn generate_type_metadata_declaration(
     resolved_type_id: TypeId,
     metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
 ) -> Result<program_abi::TypeMetadataDeclaration, ErrorEmitted> {
+    let cache_key =
+        TypeCacheKey::from_type_id(engines, ctx.experimental.abi_type_aliases, resolved_type_id);
+    if let Some(cached_decl) = ctx.metadata_declaration_cache.get(&cache_key) {
+        return Ok(cached_decl.clone());
+    }
+
     let mut alias_metadata_types_to_add = Vec::<program_abi::TypeMetadataDeclaration>::new();
 
     let type_engine = engines.te();
@@ -747,6 +798,8 @@ fn generate_type_metadata_declaration(
         alias_of,
     };
 
+    ctx.metadata_declaration_cache
+        .insert(cache_key, type_metadata_decl.clone());
     metadata_types_to_add.push(type_metadata_decl.clone());
     metadata_types_to_add.extend(new_metadata_types_to_add);
     metadata_types_to_add.extend(alias_metadata_types_to_add);
@@ -1748,6 +1801,16 @@ impl GenericTypeParameter {
         metadata_types_to_add: &mut Vec<program_abi::TypeMetadataDeclaration>,
     ) -> Result<MetadataTypeId, ErrorEmitted> {
         let type_id = MetadataTypeId(self.initial_type_id.index());
+        let cache_key = TypeCacheKey::from_type_id(
+            engines,
+            ctx.experimental.abi_type_aliases,
+            self.initial_type_id,
+        );
+
+        if let Some(cached) = ctx.metadata_declaration_cache.get(&cache_key) {
+            return Ok(cached.metadata_type_id.clone());
+        }
+
         let type_field = self.initial_type_id.get_abi_type_str(
             handler,
             &ctx.to_str_context(),
@@ -1771,6 +1834,8 @@ impl GenericTypeParameter {
             type_parameters: None,
             alias_of: None,
         };
+        ctx.metadata_declaration_cache
+            .insert(cache_key, type_parameter.clone());
         metadata_types_to_add.push(type_parameter);
         Ok(type_id)
     }