Consistent formatting of generic args. (#7944)

Author: ilyalesokhin-starkware

crates/cairo-lang-semantic/src/expr/fmt.rs

@@ -21,3 +21,26 @@ impl Upcast<dyn DefsGroup + 'static> for ExprFormatter<'_> {
         self.db
     }
 }
+
+/// A wrapper around std::fmt::Formatter that counts the number of characters written so far.
+pub struct CountingWriter<'a, 'b> {
+    inner: &'a mut std::fmt::Formatter<'b>,
+    count: usize,
+}
+
+impl<'a, 'b> CountingWriter<'a, 'b> {
+    pub fn new(inner: &'a mut std::fmt::Formatter<'b>) -> Self {
+        Self { inner, count: 0 }
+    }
+
+    pub fn count(&self) -> usize {
+        self.count
+    }
+}
+
+impl<'a, 'b> std::fmt::Write for CountingWriter<'a, 'b> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.count += s.len();
+        self.inner.write_str(s)
+    }
+}

crates/cairo-lang-semantic/src/items/functions.rs

@@ -1,3 +1,4 @@
+use std::fmt::Write;
 use std::sync::Arc;
 
 use cairo_lang_debug::DebugWithDb;
@@ -31,6 +32,7 @@ use crate::corelib::{fn_traits, unit_ty};
 use crate::db::SemanticGroup;
 use crate::diagnostic::{SemanticDiagnosticKind, SemanticDiagnostics, SemanticDiagnosticsBuilder};
 use crate::expr::compute::Environment;
+use crate::expr::fmt::CountingWriter;
 use crate::resolve::{Resolver, ResolverData};
 use crate::substitution::GenericSubstitution;
 use crate::types::resolve_type;
@@ -589,6 +591,7 @@ impl DebugWithDb<dyn SemanticGroup> for ConcreteFunctionWithBody {
         f: &mut std::fmt::Formatter<'_>,
         db: &(dyn SemanticGroup + 'static),
     ) -> std::fmt::Result {
+        let f = &mut CountingWriter::new(f);
         write!(f, "{}", self.generic_function.full_path(db))?;
         fmt_generic_args(&self.generic_args, f, db)
     }
@@ -688,6 +691,7 @@ impl DebugWithDb<dyn SemanticGroup> for ConcreteFunction {
         f: &mut std::fmt::Formatter<'_>,
         db: &(dyn SemanticGroup + 'static),
     ) -> std::fmt::Result {
+        let f = &mut CountingWriter::new(f);
         write!(f, "{}", self.generic_function.format(db))?;
         fmt_generic_args(&self.generic_args, f, db)
     }

crates/cairo-lang-semantic/src/items/generics.rs

@@ -1,3 +1,4 @@
+use std::fmt::Write;
 use std::hash::Hash;
 use std::sync::Arc;
 
@@ -25,6 +26,7 @@ use crate::db::SemanticGroup;
 use crate::diagnostic::{
     NotFoundItemType, SemanticDiagnosticKind, SemanticDiagnostics, SemanticDiagnosticsBuilder,
 };
+use crate::expr::fmt::CountingWriter;
 use crate::expr::inference::InferenceId;
 use crate::expr::inference::canonic::ResultNoErrEx;
 use crate::lookup_item::LookupItemEx;
@@ -638,16 +640,24 @@ fn impl_generic_param_semantic(
 /// Formats a list of generic arguments.
 pub fn fmt_generic_args(
     generic_args: &[GenericArgumentId],
-    f: &mut std::fmt::Formatter<'_>,
+    f: &mut CountingWriter<'_, '_>,
     db: &(dyn SemanticGroup + 'static),
 ) -> std::fmt::Result {
-    if !generic_args.is_empty() {
+    let mut generic_args = generic_args.iter();
+    if let Some(first) = generic_args.next() {
+        // Soft limit for the number of chars in the formatted type.
+        const CHARS_BOUND: usize = 500;
         write!(f, "::<")?;
-        for (i, arg) in generic_args.iter().enumerate() {
-            if i > 0 {
-                write!(f, ", ")?;
+        write!(f, "{}", &first.format(db))?;
+
+        for arg in generic_args {
+            write!(f, ", ")?;
+            if f.count() > CHARS_BOUND {
+                // If the formatted type is becoming too long, add short version of arguments.
+                write!(f, "{}", &arg.short_name(db))?;
+            } else {
+                write!(f, "{}", &arg.format(db))?;
             }
-            write!(f, "{}", arg.format(db))?;
         }
         write!(f, ">")?;
     }

crates/cairo-lang-semantic/src/items/imp.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeSet;
+use std::fmt::Write;
 use std::hash::Hash;
 use std::sync::Arc;
 use std::{mem, panic, vec};
@@ -66,6 +67,7 @@ use crate::db::{SemanticGroup, get_resolver_data_options};
 use crate::diagnostic::SemanticDiagnosticKind::{self, *};
 use crate::diagnostic::{NotFoundItemType, SemanticDiagnostics, SemanticDiagnosticsBuilder};
 use crate::expr::compute::{ComputationContext, ContextFunction, Environment, compute_root_expr};
+use crate::expr::fmt::CountingWriter;
 use crate::expr::inference::canonic::ResultNoErrEx;
 use crate::expr::inference::conform::InferenceConform;
 use crate::expr::inference::infers::InferenceEmbeddings;
@@ -113,8 +115,9 @@ impl DebugWithDb<dyn SemanticGroup> for ConcreteImplLongId {
         f: &mut std::fmt::Formatter<'_>,
         db: &(dyn SemanticGroup + 'static),
     ) -> std::fmt::Result {
+        let mut f = CountingWriter::new(f);
         write!(f, "{}", self.impl_def_id.full_path(db))?;
-        fmt_generic_args(&self.generic_args, f, db)
+        fmt_generic_args(&self.generic_args, &mut f, db)
     }
 }
 impl ConcreteImplId {

crates/cairo-lang-semantic/src/items/trt.rs

@@ -1,3 +1,4 @@
+use std::fmt::Write;
 use std::sync::Arc;
 
 use cairo_lang_debug::DebugWithDb;
@@ -34,6 +35,7 @@ use crate::db::{SemanticGroup, get_resolver_data_options};
 use crate::diagnostic::SemanticDiagnosticKind::{self, *};
 use crate::diagnostic::{NotFoundItemType, SemanticDiagnostics, SemanticDiagnosticsBuilder};
 use crate::expr::compute::{ComputationContext, ContextFunction, Environment, compute_root_expr};
+use crate::expr::fmt::CountingWriter;
 use crate::expr::inference::InferenceId;
 use crate::expr::inference::canonic::ResultNoErrEx;
 use crate::items::feature_kind::HasFeatureKind;
@@ -60,8 +62,9 @@ impl DebugWithDb<dyn SemanticGroup> for ConcreteTraitLongId {
         f: &mut std::fmt::Formatter<'_>,
         db: &(dyn SemanticGroup + 'static),
     ) -> std::fmt::Result {
+        let mut f = CountingWriter::new(f);
         write!(f, "{}", self.trait_id.full_path(db))?;
-        fmt_generic_args(&self.generic_args, f, db)
+        fmt_generic_args(&self.generic_args, &mut f, db)
     }
 }
 

crates/cairo-lang-semantic/src/types.rs

@@ -1,3 +1,5 @@
+use std::fmt::Write;
+
 use cairo_lang_debug::DebugWithDb;
 use cairo_lang_defs::diagnostic_utils::StableLocation;
 use cairo_lang_defs::ids::{
@@ -27,10 +29,12 @@ use crate::diagnostic::{NotFoundItemType, SemanticDiagnostics, SemanticDiagnosti
 use crate::expr::compute::{
     ComputationContext, ContextFunction, Environment, compute_expr_semantic,
 };
+use crate::expr::fmt::CountingWriter;
 use crate::expr::inference::canonic::ResultNoErrEx;
 use crate::expr::inference::{InferenceData, InferenceError, InferenceId, TypeVar};
 use crate::items::attribute::SemanticQueryAttrs;
 use crate::items::constant::{ConstValue, ConstValueId, resolve_const_expr_and_evaluate};
+use crate::items::generics::fmt_generic_args;
 use crate::items::imp::{ImplId, ImplLookupContext};
 use crate::resolve::{ResolutionContext, ResolvedConcreteItem, Resolver};
 use crate::substitution::SemanticRewriter;
@@ -305,28 +309,7 @@ impl ConcreteTypeId {
         }
     }
     pub fn format(&self, db: &dyn SemanticGroup) -> String {
-        let generic_type_format = self.generic_type(db).format(db);
-        let mut generic_args = self.generic_args(db).into_iter();
-        if let Some(first) = generic_args.next() {
-            // Soft limit for the number of chars in the formatted type.
-            const CHARS_BOUND: usize = 500;
-            let mut f = generic_type_format;
-            f.push_str("::<");
-            f.push_str(&first.format(db));
-            for arg in generic_args {
-                f.push_str(", ");
-                if f.len() > CHARS_BOUND {
-                    // If the formatted type is becoming too long, add short version of arguments.
-                    f.push_str(&arg.short_name(db));
-                } else {
-                    f.push_str(&arg.format(db));
-                }
-            }
-            f.push('>');
-            f
-        } else {
-            generic_type_format
-        }
+        format!("{:?}", self.debug(db.elongate()))
     }
 
     /// Returns whether the type has the `#[must_use]` attribute.
@@ -354,7 +337,9 @@ impl DebugWithDb<dyn SemanticGroup> for ConcreteTypeId {
         f: &mut std::fmt::Formatter<'_>,
         db: &(dyn SemanticGroup + 'static),
     ) -> std::fmt::Result {
-        write!(f, "{}", self.format(db))
+        let f = &mut CountingWriter::new(f);
+        write!(f, "{}", self.generic_type(db).format(db))?;
+        fmt_generic_args(&self.generic_args(db), f, db)
     }
 }