Delete the disconnected ShapedArray type representation

Summary:
Remove `ShapedArrayType` and `Type::ShapedArray` after retiring their construction and dispatch paths. Preserve `IntTuple` storage, normal class shape formatting, shared shape comparisons/conversions, and annotation-driven indexing.

mypy_primer: +0/-0 under both default and strict presets on the matched corpus for this diff (Sandcastle job 36028800104034918). No type-checking differences were observed, so there are no added/fixed errors to classify.

___

landed-with-radar-review

Differential Revision: D128206161

fbshipit-source-id: 3d1ee088db1410c316981ccfa67e225bc06306a2

Author: stroxler

crates/pyrefly_types/src/display.rs

@@ -42,7 +42,6 @@ use crate::quantified::QuantifiedIdentity;
 use crate::quantified::QuantifiedKind;
 use crate::shaped_array::IntTuple;
 use crate::shaped_array::IntTupleView;
-use crate::shaped_array::ShapedArrayType;
 use crate::shaped_array::is_tuple_carrier_shape_middle;
 use crate::stdlib::Stdlib;
 use crate::tuple::Tuple;
@@ -205,9 +204,6 @@ impl<'a> TypeDisplayContext<'a> {
 
     pub fn add(&mut self, t: &'a Type) {
         t.universe(&mut |t| {
-            if let Type::ShapedArray(shaped_array) = t {
-                self.add_qname(shaped_array.base_class.qname());
-            }
             if let Type::DataFrame(schema) = t {
                 self.add_qname(schema.underlying.qname());
             }
@@ -452,63 +448,6 @@ impl<'a> TypeDisplayContext<'a> {
         output.write_str("]")
     }
 
-    fn fmt_shaped_array(
-        &self,
-        shaped_array: &ShapedArrayType,
-        output: &mut impl TypeOutput,
-    ) -> fmt::Result {
-        let shape_idx = match shaped_array.tuple_carrier_shape_arg_index() {
-            Some(index) => index,
-            None => {
-                output.write_qname(shaped_array.base_class.qname())?;
-                let shape = shaped_array.shape();
-                if !shape.is_shapeless() {
-                    output.write_str("[")?;
-                    output.write_str(&shape.to_string())?;
-                    output.write_str("]")?;
-                }
-                return Ok(());
-            }
-        };
-        self.fmt_shaped_array_as_class(shaped_array, shape_idx, output)
-    }
-
-    fn fmt_shaped_array_as_class(
-        &self,
-        shaped_array: &ShapedArrayType,
-        shape_idx: usize,
-        output: &mut impl TypeOutput,
-    ) -> fmt::Result {
-        let targs = shaped_array.base_class.targs();
-        let args = targs.as_slice();
-        args.get(shape_idx)
-            .expect("shape argument index should point to a class type argument");
-
-        output.write_qname(shaped_array.base_class.qname())?;
-        let shape = shaped_array.shape();
-        let display_count = targs.display_count().max(if shape.is_shapeless() {
-            0
-        } else {
-            shape_idx + 1
-        });
-        if display_count == 0 {
-            return Ok(());
-        }
-
-        output.write_str("[")?;
-        for (i, (param, arg)) in targs.iter_paired().take(display_count).enumerate() {
-            if i > 0 {
-                output.write_str(", ")?;
-            }
-            if i == shape_idx {
-                self.fmt_shape_as_tuple_carrier(&shape, output)?;
-            } else {
-                self.fmt_targ(param, arg, output)?;
-            }
-        }
-        output.write_str("]")
-    }
-
     fn fmt_shape_as_tuple_carrier(
         &self,
         shape: &IntTuple,
@@ -1103,7 +1042,6 @@ impl<'a> TypeDisplayContext<'a> {
                 }
                 output.write_str("]")
             }
-            Type::ShapedArray(shaped_array) => self.fmt_shaped_array(shaped_array, output),
             Type::IntTuple(int_tuple) => {
                 if int_tuple.is_shapeless() {
                     output.write_str("IntTuple")

crates/pyrefly_types/src/heap.rs

@@ -40,7 +40,6 @@ use crate::param_spec::ParamSpec;
 use crate::quantified::Quantified;
 use crate::sentinel::Sentinel;
 use crate::shaped_array::IntTuple;
-use crate::shaped_array::ShapedArrayType;
 use crate::special_form::SpecialForm;
 use crate::tuple::Tuple;
 use crate::type_alias::TypeAliasData;
@@ -436,11 +435,6 @@ impl TypeHeap {
         Type::Int(symint)
     }
 
-    /// Create a `Type::ShapedArray` from a ShapedArrayType.
-    pub fn mk_shaped_array(&self, shaped_array: ShapedArrayType) -> Type {
-        Type::ShapedArray(Box::new(shaped_array))
-    }
-
     /// Create a `Type::IntTuple` from a IntTuple.
     pub fn mk_int_tuple(&self, int_tuple: IntTuple) -> Type {
         Type::IntTuple(Box::new(int_tuple))

crates/pyrefly_types/src/shaped_array.rs

@@ -13,7 +13,6 @@ use pyrefly_derive::Visit;
 use pyrefly_derive::VisitMut;
 use pyrefly_util::display::commas_iter;
 
-use crate::class::ClassType;
 use crate::dimension::Int;
 use crate::dimension::ShapeError;
 use crate::dimension::canonicalize;
@@ -28,140 +27,7 @@ use crate::tuple::Tuple;
 use crate::type_level_dsl::TypeShapeDslDomain;
 use crate::types::Type;
 
-// ============================================================================
-// Shaped Array Types
-// ============================================================================
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[derive(Visit, VisitMut, TypeEq)]
-enum ShapedArrayShapeStorage {
-    Inline(IntTuple),
-    TupleCarrier { index: usize },
-}
-
-/// A class instance with shape information.
-/// Example: Tensor[[2, 3]] represents a 2x3 tensor
-/// Example: Tensor (no brackets) represents a shapeless tensor (`IntTuple`)
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[derive(Visit, VisitMut, TypeEq)]
-pub struct ShapedArrayType {
-    /// Base shaped-array class (e.g., torch.Tensor)
-    pub base_class: ClassType,
-    shape: ShapedArrayShapeStorage,
-}
-
-impl ShapedArrayType {
-    /// Create a shaped-array type with shape information.
-    pub fn new(base_class: ClassType, shape: IntTuple) -> Self {
-        Self {
-            base_class,
-            shape: ShapedArrayShapeStorage::Inline(shape),
-        }
-    }
-
-    /// Create a shapeless shaped-array type (compatible with any shape).
-    pub fn shapeless(base_class: ClassType) -> Self {
-        Self {
-            base_class,
-            shape: ShapedArrayShapeStorage::Inline(IntTuple::shapeless()),
-        }
-    }
-
-    pub fn with_tuple_carrier_shape_arg(mut self, index: usize) -> Self {
-        self.shape = ShapedArrayShapeStorage::TupleCarrier { index };
-        self
-    }
-
-    pub fn to_type(self) -> Type {
-        Type::ShapedArray(Box::new(self))
-    }
-
-    pub fn tuple_carrier_shape_arg_index(&self) -> Option<usize> {
-        match self.shape {
-            ShapedArrayShapeStorage::Inline(_) => None,
-            ShapedArrayShapeStorage::TupleCarrier { index } => Some(index),
-        }
-    }
-
-    pub fn set_tuple_carrier_shape_arg(&mut self, index: usize) {
-        self.shape = ShapedArrayShapeStorage::TupleCarrier { index };
-    }
-
-    pub fn shape(&self) -> IntTuple {
-        match &self.shape {
-            ShapedArrayShapeStorage::Inline(shape) => shape.clone(),
-            ShapedArrayShapeStorage::TupleCarrier { index } => {
-                let shape_arg = self
-                    .base_class
-                    .targs()
-                    .as_slice()
-                    .get(*index)
-                    .expect("shape argument index should point to a class type argument");
-                IntTuple::from_shape_arg_or_tuple_carrier(shape_arg)
-                    .expect("registered shaped-array shape argument should project to IntTuple")
-            }
-        }
-    }
-
-    pub fn set_shape(&mut self, shape: IntTuple) {
-        match &mut self.shape {
-            ShapedArrayShapeStorage::Inline(stored_shape) => *stored_shape = shape,
-            ShapedArrayShapeStorage::TupleCarrier { index } => {
-                let shape_arg = self
-                    .base_class
-                    .targs_mut()
-                    .as_mut()
-                    .get_mut(*index)
-                    .expect("shape argument index should point to a class type argument");
-                *shape_arg = shape.to_shape_arg_type();
-            }
-        }
-    }
-
-    /// Returns rank if shape is concrete, None for variadic/shapeless
-    pub fn rank(&self) -> Option<usize> {
-        match self.shape().view() {
-            IntTupleView::Concrete(dims) => Some(dims.len()),
-            IntTupleView::Gradual | IntTupleView::Unpacked { .. } => None,
-        }
-    }
-
-    /// Returns true if the shaped array has no shape information.
-    /// (represented as a gradual `IntTuple`)
-    pub fn is_shapeless(&self) -> bool {
-        is_shapeless(&self.shape())
-    }
-
-    /// Materialize gradual dimensions of an inline shape (see `Int::materialize`).
-    /// `TupleCarrier` shapes store their dimensions as `Type` arguments on
-    /// `base_class`, so they are materialized by the generic `Type::materialize`
-    /// traversal instead.
-    pub fn materialize_inline_shape(&mut self) {
-        if let ShapedArrayShapeStorage::Inline(shape) = &mut self.shape {
-            shape.materialize();
-        }
-    }
-}
-
-impl Display for ShapedArrayType {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let shape = self.shape();
-        if is_shapeless(&shape) {
-            write!(f, "{}", self.base_class.name())
-        } else if self.tuple_carrier_shape_arg_index().is_some() {
-            write!(
-                f,
-                "{}[{}]",
-                self.base_class.name(),
-                fmt_tuple_carrier(&shape)
-            )
-        } else {
-            write!(f, "{}[{}]", self.base_class.name(), shape)
-        }
-    }
-}
-
-/// Shape of a shaped array.
+/// An integer tuple describing an array shape.
 ///
 /// The storage is deliberately not a `Tuple`: fixed dimensions are always
 /// canonical `Int`s, while variadic middles carry the original tuple/type
@@ -729,32 +595,6 @@ fn fmt_unpacked_middle(middle: &Type) -> String {
     }
 }
 
-fn fmt_tuple_carrier(shape: &IntTuple) -> String {
-    match shape.view() {
-        IntTupleView::Concrete(dims) => {
-            format!("[{}]", commas_iter(|| dims.iter()))
-        }
-        IntTupleView::Gradual => {
-            // No unbounded shape reaches here: the only caller (`Display`) handles
-            // the shapeless `IntTuple` case before calling this.
-            unreachable!("shapeless IntTuple is handled before fmt_tuple_carrier")
-        }
-        IntTupleView::Unpacked {
-            prefix,
-            middle,
-            suffix,
-        } => {
-            if prefix.is_empty() && suffix.is_empty() && is_tuple_carrier_shape_middle(middle) {
-                return middle.to_string();
-            }
-            let mut parts: Vec<String> = prefix.iter().map(|d| d.to_string()).collect();
-            parts.push(format!("*{}", fmt_unpacked_middle(middle)));
-            parts.extend(suffix.iter().map(|d| d.to_string()));
-            format!("[{}]", parts.join(", "))
-        }
-    }
-}
-
 // ============================================================================
 // Tuple-carrier conversion
 // ============================================================================

crates/pyrefly_types/src/types.rs

@@ -62,7 +62,6 @@ use crate::quantified::Quantified;
 use crate::sentinel::Sentinel;
 use crate::series::SeriesSchema;
 use crate::shaped_array::IntTuple;
-use crate::shaped_array::ShapedArrayType;
 use crate::simplify::unions;
 use crate::special_form::SpecialForm;
 use crate::stdlib::Stdlib;
@@ -902,9 +901,6 @@ pub enum Type {
     /// For a TypedDict type `C`, `Partial[C]` represents an object with any subset of read-write
     /// keys from `C`, where each present key has the same value type as in `C`.
     PartialTypedDict(TypedDict),
-    /// Shaped-array type with shape information.
-    /// Example: Tensor[2, 3] represents a 2x3 tensor
-    ShapedArray(Box<ShapedArrayType>),
     /// First-class tensor shape tuple.
     IntTuple(Box<IntTuple>),
     /// Named integer values captured by the experimental shape extensions.
@@ -1031,7 +1027,6 @@ impl Visit for Type {
             Type::ClassType(x) => x.visit(f),
             Type::TypedDict(x) => x.visit(f),
             Type::PartialTypedDict(x) => x.visit(f),
-            Type::ShapedArray(x) => x.visit(f),
             Type::IntTuple(x) => x.visit(f),
             Type::NamedInts(x) => x.visit(f),
             Type::DataFrame(x) => x.visit(f),
@@ -1095,7 +1090,6 @@ impl VisitMut for Type {
             Type::ClassType(x) => x.visit_mut(f),
             Type::TypedDict(x) => x.visit_mut(f),
             Type::PartialTypedDict(x) => x.visit_mut(f),
-            Type::ShapedArray(x) => x.visit_mut(f),
             Type::IntTuple(x) => x.visit_mut(f),
             Type::NamedInts(x) => x.visit_mut(f),
             Type::DataFrame(x) => x.visit_mut(f),
@@ -2465,7 +2459,6 @@ impl Type {
             | Type::ClassType(_)
             | Type::TypedDict(_)
             | Type::PartialTypedDict(_)
-            | Type::ShapedArray(_)
             | Type::IntTuple(_)
             | Type::NamedInts(_)
             | Type::DataFrame(_)
@@ -2551,7 +2544,6 @@ impl Type {
         match self {
             Type::Int(dim) => dim.materialize(),
             Type::IntTuple(tuple) => tuple.materialize(),
-            Type::ShapedArray(shaped) => shaped.materialize_inline_shape(),
             _ => {}
         }
         self.transform_toplevel_callable_signatures(|callable: &mut Callable, _| {

pyrefly/lib/alt/attr.rs

@@ -2656,7 +2656,6 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                     value_ty,
                 )))
             }
-            Type::ShapedArray(tensor) => acc.push(AttributeBase1::ClassInstance(tensor.base_class)),
             Type::DataFrame(schema) => self.as_attribute_base1(schema.underlying_type(), acc),
             Type::Series(schema) => self.as_attribute_base1(schema.underlying_type(), acc),
             Type::Int(_) => {

pyrefly/lib/alt/class/class_metadata.rs

@@ -1757,15 +1757,6 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
                 }
                 match self.untype_opt(ty.clone(), x.range(), &errors) {
                     None => BaseClassParseResult::InvalidType(ty, x.range()),
-                    Some(Type::ShapedArray(array))
-                        if self
-                            .bindings()
-                            .shape_declarations
-                            .commented_bases
-                            .contains_key(&x.range()) =>
-                    {
-                        parse_base_class_type(self.heap.mk_class_type(array.base_class))
-                    }
                     Some(ty) => parse_base_class_type(ty),
                 }
             }