Add display for TypeAliasRef with args

Summary:
Updates the display for `Type::TypeAlias` and `Type::UntypedAlias` to show targs stored with `TypeAliasRef`.

For #60.

Reviewed By: stroxler

Differential Revision: D92362543

fbshipit-source-id: 135f094b147d14cca100763e0ea606b20c10e8f0

Author: rchen152

crates/pyrefly_types/src/display.rs

@@ -29,6 +29,7 @@ use crate::literal::Lit;
 use crate::stdlib::Stdlib;
 use crate::tuple::Tuple;
 use crate::type_alias::TypeAliasData;
+use crate::type_alias::TypeAliasRef;
 use crate::type_output::DisplayOutput;
 use crate::type_output::OutputWithLocations;
 use crate::type_output::TypeOutput;
@@ -849,12 +850,19 @@ impl<'a> TypeDisplayContext<'a> {
                 AnyStyle::Explicit => self.maybe_fmt_with_module("typing", "Any", output),
                 AnyStyle::Implicit | AnyStyle::Error => output.write_str("Unknown"),
             },
-            Type::TypeAlias(ta) => {
-                if is_toplevel && let TypeAliasData::Value(ta) = &**ta {
+            Type::TypeAlias(ta) => match &**ta {
+                TypeAliasData::Value(ta) if is_toplevel => {
                     ta.fmt_with_type(output, &|t, o| self.fmt_helper_generic(t, false, o), None)
-                } else {
-                    write!(output, "type[{}]", ta.name())
                 }
+                TypeAliasData::Value(ta) => write!(output, "type[{}]", ta.name),
+                TypeAliasData::Ref(r) => {
+                    output.write_str("type[")?;
+                    self.fmt_helper_type_alias_ref(r, output)?;
+                    output.write_str("]")
+                }
+            },
+            Type::UntypedAlias(box TypeAliasData::Ref(r)) => {
+                self.fmt_helper_type_alias_ref(r, output)
             }
             Type::UntypedAlias(ta) => output.write_str(ta.name().as_str()),
             Type::SuperInstance(box (cls, obj)) => {
@@ -895,6 +903,31 @@ impl<'a> TypeDisplayContext<'a> {
         self.fmt_helper_generic(t, is_toplevel, output)
     }
 
+    fn fmt_helper_type_alias_ref(
+        &self,
+        r: &TypeAliasRef,
+        output: &mut impl TypeOutput,
+    ) -> fmt::Result {
+        match r {
+            TypeAliasRef {
+                name,
+                args: Some(args),
+                ..
+            } => {
+                output.write_str(name.as_str())?;
+                write!(output, "[")?;
+                for (i, t) in args.as_slice().iter().enumerate() {
+                    if i > 0 {
+                        output.write_str(", ")?;
+                    }
+                    output.write_type(t)?;
+                }
+                write!(output, "]")
+            }
+            _ => output.write_str(r.name.as_str()),
+        }
+    }
+
     /// This method wraps `fmt_helper_generic` with `OutputWithLocations` to track
     /// the source location (module and text range) of each type component in the output
     /// This is useful for IDE features like goto-type-definition
@@ -1013,6 +1046,7 @@ pub mod tests {
     use crate::tuple::Tuple;
     use crate::type_alias::TypeAlias;
     use crate::type_alias::TypeAliasData;
+    use crate::type_alias::TypeAliasIndex;
     use crate::type_alias::TypeAliasStyle;
     use crate::type_var::PreInferenceVariance;
     use crate::type_var::Restriction;
@@ -1528,6 +1562,34 @@ pub mod tests {
         assert_eq!(ctx.display(&wrapped).to_string(), "tuple[type[MyAlias]]");
     }
 
+    #[test]
+    fn test_display_specialized_untyped_alias() {
+        let uniques = UniqueFactory::new();
+
+        let tparams1 = fake_tparams(vec![fake_tparam(&uniques, "T", QuantifiedKind::TypeVar)]);
+        let alias1 = Type::UntypedAlias(Box::new(TypeAliasData::Ref(TypeAliasRef {
+            name: Name::new_static("X"),
+            args: Some(TArgs::new(tparams1, vec![Type::any_implicit()])),
+            module: ModuleName::from_str("test"),
+            index: TypeAliasIndex(0),
+        })));
+
+        let tparams2 = fake_tparams(vec![
+            fake_tparam(&uniques, "K", QuantifiedKind::TypeVar),
+            fake_tparam(&uniques, "V", QuantifiedKind::TypeVar),
+        ]);
+        let alias2 = Type::UntypedAlias(Box::new(TypeAliasData::Ref(TypeAliasRef {
+            name: Name::new_static("Y"),
+            args: Some(TArgs::new(tparams2, vec![Type::any_implicit(), Type::None])),
+            module: ModuleName::from_str("test"),
+            index: TypeAliasIndex(1),
+        })));
+
+        let ctx = TypeDisplayContext::new(&[&alias1, &alias2]);
+        assert_eq!(ctx.display(&alias1).to_string(), "X[Unknown]");
+        assert_eq!(ctx.display(&alias2).to_string(), "Y[Unknown, None]");
+    }
+
     #[test]
     fn test_display_optional_parameter() {
         let param1 = Param::PosOnly(