Typo, is_supertype, Term::Runtime.

zrho · zrho · commit b322c2e4a888 · 2025-06-16T18:04:11.000+01:00
diff --git a/hugr-core/src/export.rs b/hugr-core/src/export.rs
@@ -961,13 +961,12 @@ impl<'a> Context<'a> {
                 let types = self.make_term(table::Term::List(item_types));
                 self.make_term_apply(model::CORE_TUPLE_TYPE, &[types])
             }
-            Term::Type(ty) => self.export_type(ty),
+            Term::Runtime(ty) => self.export_type(ty),
             Term::BoundedNat(value) => self.make_term(model::Literal::Nat(*value).into()),
             Term::String(value) => self.make_term(model::Literal::Str(value.into()).into()),
             Term::Float(value) => self.make_term(model::Literal::Float(*value).into()),
             Term::Bytes(value) => self.make_term(model::Literal::Bytes(value.clone()).into()),
             Term::List(elems) => {
-                // For now we assume that the sequence is meant to be a list.
                 let parts = self.bump.alloc_slice_fill_iter(
                     elems
                         .iter()
diff --git a/hugr-core/src/extension/prelude.rs b/hugr-core/src/extension/prelude.rs
@@ -684,7 +684,7 @@ impl MakeExtensionOp for MakeTuple {
         let tys: Result<Vec<Type>, _> = elems
             .iter()
             .map(|a| match a {
-                TypeArg::Type(ty) => Ok(ty.clone()),
+                TypeArg::Runtime(ty) => Ok(ty.clone()),
                 _ => Err(SignatureError::InvalidTypeArgs),
             })
             .collect();
@@ -739,7 +739,7 @@ impl MakeExtensionOp for UnpackTuple {
         let tys: Result<Vec<Type>, _> = elems
             .iter()
             .map(|a| match a {
-                Term::Type(ty) => Ok(ty.clone()),
+                Term::Runtime(ty) => Ok(ty.clone()),
                 _ => Err(SignatureError::InvalidTypeArgs),
             })
             .collect();
@@ -851,7 +851,7 @@ impl MakeExtensionOp for Noop {
         Self: Sized,
     {
         let _def = NoopDef::from_def(ext_op.def())?;
-        let [TypeArg::Type(ty)] = ext_op.args() else {
+        let [TypeArg::Runtime(ty)] = ext_op.args() else {
             return Err(SignatureError::InvalidTypeArgs)?;
         };
         Ok(Self(ty.clone()))
@@ -963,7 +963,7 @@ impl MakeExtensionOp for Barrier {
         let tys: Result<Vec<Type>, _> = elems
             .iter()
             .map(|a| match a {
-                TypeArg::Type(ty) => Ok(ty.clone()),
+                TypeArg::Runtime(ty) => Ok(ty.clone()),
                 _ => Err(SignatureError::InvalidTypeArgs),
             })
             .collect();
diff --git a/hugr-core/src/extension/resolution/types.rs b/hugr-core/src/extension/resolution/types.rs
@@ -216,7 +216,7 @@ pub(super) fn collect_term_exts(
     missing_extensions: &mut ExtensionSet,
 ) {
     match term {
-        Term::Type(ty) => collect_type_exts(ty, used_extensions, missing_extensions),
+        Term::Runtime(ty) => collect_type_exts(ty, used_extensions, missing_extensions),
         Term::List(elems) => {
             for elem in elems.iter() {
                 collect_term_exts(elem, used_extensions, missing_extensions);
diff --git a/hugr-core/src/extension/resolution/types_mut.rs b/hugr-core/src/extension/resolution/types_mut.rs
@@ -221,7 +221,7 @@ pub(super) fn resolve_term_exts(
     used_extensions: &mut WeakExtensionRegistry,
 ) -> Result<(), ExtensionResolutionError> {
     match term {
-        Term::Type(ty) => resolve_type_exts(node, ty, extensions, used_extensions)?,
+        Term::Runtime(ty) => resolve_type_exts(node, ty, extensions, used_extensions)?,
         Term::List(elems) => {
             for elem in elems.iter_mut() {
                 resolve_term_exts(node, elem, extensions, used_extensions)?;
diff --git a/hugr-core/src/extension/type_def.rs b/hugr-core/src/extension/type_def.rs
@@ -147,7 +147,7 @@ impl TypeDef {
                 least_upper_bound(indices.iter().map(|i| {
                     let ta = args.get(*i);
                     match ta {
-                        Some(TypeArg::Type(s)) => s.least_upper_bound(),
+                        Some(TypeArg::Runtime(s)) => s.least_upper_bound(),
                         _ => panic!("TypeArg index does not refer to a type."),
                     }
                 }))
diff --git a/hugr-core/src/std_extensions/collections/array/array_clone.rs b/hugr-core/src/std_extensions/collections/array/array_clone.rs
@@ -180,7 +180,7 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayCloneDef<AK> {
 
     fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {
         match type_args {
-            [TypeArg::BoundedNat(n), TypeArg::Type(ty)] if ty.copyable() => {
+            [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] if ty.copyable() => {
                 Ok(GenericArrayClone::new(ty.clone(), *n).unwrap())
             }
             _ => Err(SignatureError::InvalidTypeArgs.into()),
diff --git a/hugr-core/src/std_extensions/collections/array/array_conversion.rs b/hugr-core/src/std_extensions/collections/array/array_conversion.rs
@@ -231,7 +231,7 @@ impl<AK: ArrayKind, const DIR: Direction, OtherAK: ArrayKind> HasConcrete
 
     fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {
         match type_args {
-            [TypeArg::BoundedNat(n), TypeArg::Type(ty)] => {
+            [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] => {
                 Ok(GenericArrayConvert::new(ty.clone(), *n))
             }
             _ => Err(SignatureError::InvalidTypeArgs.into()),
diff --git a/hugr-core/src/std_extensions/collections/array/array_discard.rs b/hugr-core/src/std_extensions/collections/array/array_discard.rs
@@ -164,7 +164,7 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayDiscardDef<AK> {
 
     fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {
         match type_args {
-            [TypeArg::BoundedNat(n), TypeArg::Type(ty)] if ty.copyable() => {
+            [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] if ty.copyable() => {
                 Ok(GenericArrayDiscard::new(ty.clone(), *n).unwrap())
             }
             _ => Err(SignatureError::InvalidTypeArgs.into()),
diff --git a/hugr-core/src/std_extensions/collections/array/array_op.rs b/hugr-core/src/std_extensions/collections/array/array_op.rs
@@ -322,8 +322,8 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayOpDef<AK> {
 
     fn instantiate(&self, type_args: &[Term]) -> Result<Self::Concrete, OpLoadError> {
         let (ty, size) = match (self, type_args) {
-            (GenericArrayOpDef::discard_empty, [Term::Type(ty)]) => (ty.clone(), 0),
-            (_, [Term::BoundedNat(n), Term::Type(ty)]) => (ty.clone(), *n),
+            (GenericArrayOpDef::discard_empty, [Term::Runtime(ty)]) => (ty.clone(), 0),
+            (_, [Term::BoundedNat(n), Term::Runtime(ty)]) => (ty.clone(), *n),
             _ => return Err(SignatureError::InvalidTypeArgs.into()),
         };
 
diff --git a/hugr-core/src/std_extensions/collections/array/array_repeat.rs b/hugr-core/src/std_extensions/collections/array/array_repeat.rs
@@ -170,7 +170,7 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayRepeatDef<AK> {
 
     fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {
         match type_args {
-            [TypeArg::BoundedNat(n), TypeArg::Type(ty)] => {
+            [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] => {
                 Ok(GenericArrayRepeat::new(ty.clone(), *n))
             }
             _ => Err(SignatureError::InvalidTypeArgs.into()),
diff --git a/hugr-core/src/std_extensions/collections/array/array_scan.rs b/hugr-core/src/std_extensions/collections/array/array_scan.rs
@@ -214,14 +214,14 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayScanDef<AK> {
         match type_args {
             [
                 TypeArg::BoundedNat(n),
-                TypeArg::Type(src_ty),
-                TypeArg::Type(tgt_ty),
+                TypeArg::Runtime(src_ty),
+                TypeArg::Runtime(tgt_ty),
                 TypeArg::List(acc_tys),
             ] => {
                 let acc_tys: Result<_, OpLoadError> = acc_tys
                     .iter()
                     .map(|acc_ty| match acc_ty {
-                        TypeArg::Type(ty) => Ok(ty.clone()),
+                        TypeArg::Runtime(ty) => Ok(ty.clone()),
                         _ => Err(SignatureError::InvalidTypeArgs.into()),
                     })
                     .collect();
diff --git a/hugr-core/src/std_extensions/collections/array/array_value.rs b/hugr-core/src/std_extensions/collections/array/array_value.rs
@@ -94,7 +94,9 @@ impl<AK: ArrayKind> GenericArrayValue<AK> {
 
         // constant can only hold classic type.
         let ty = match typ.args() {
-            [TypeArg::BoundedNat(n), TypeArg::Type(ty)] if *n as usize == self.values.len() => ty,
+            [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] if *n as usize == self.values.len() => {
+                ty
+            }
             _ => {
                 return Err(CustomCheckFailure::Message(format!(
                     "Invalid array type arguments: {:?}",
diff --git a/hugr-core/src/std_extensions/collections/list.rs b/hugr-core/src/std_extensions/collections/list.rs
@@ -112,7 +112,7 @@ impl CustomConst for ListValue {
             .map_err(|_| error())?;
 
         // constant can only hold classic type.
-        let [TypeArg::Type(ty)] = typ.args() else {
+        let [TypeArg::Runtime(ty)] = typ.args() else {
             return Err(error());
         };
 
@@ -351,7 +351,7 @@ impl MakeExtensionOp for ListOpInst {
     fn from_extension_op(
         ext_op: &ExtensionOp,
     ) -> Result<Self, crate::extension::simple_op::OpLoadError> {
-        let [Term::Type(ty)] = ext_op.args() else {
+        let [Term::Runtime(ty)] = ext_op.args() else {
             return Err(SignatureError::InvalidTypeArgs.into());
         };
         let name = ext_op.unqualified_id();
diff --git a/hugr-core/src/std_extensions/collections/static_array.rs b/hugr-core/src/std_extensions/collections/static_array.rs
@@ -309,7 +309,7 @@ impl HasConcrete for StaticArrayOpDef {
         match type_args {
             [arg] => {
                 let elem_ty = arg
-                    .as_type()
+                    .as_runtime()
                     .filter(|t| Copyable.contains(t.least_upper_bound()))
                     .ok_or(SignatureError::TypeArgMismatch(
                         TermTypeError::TypeMismatch {
diff --git a/hugr-core/src/std_extensions/ptr.rs b/hugr-core/src/std_extensions/ptr.rs
@@ -207,7 +207,7 @@ impl HasConcrete for PtrOpDef {
 
     fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {
         let ty = match type_args {
-            [TypeArg::Type(ty)] => ty.clone(),
+            [TypeArg::Runtime(ty)] => ty.clone(),
             _ => return Err(SignatureError::InvalidTypeArgs.into()),
         };
 
diff --git a/hugr-core/src/types.rs b/hugr-core/src/types.rs
@@ -492,7 +492,7 @@ impl<RV: MaybeRV> TypeBase<RV> {
 
     /// New use (occurrence) of the type variable with specified index.
     /// `bound` must be exactly that with which the variable was declared
-    /// (i.e. as a [`TypeParam::Type`]`(bound)`), which may be narrower
+    /// (i.e. as a [`Term::RuntimeType`]`(bound)`), which may be narrower
     /// than required for the use.
     #[must_use]
     pub const fn new_var_use(idx: usize, bound: TypeBound) -> Self {
@@ -577,7 +577,7 @@ impl<RV: MaybeRV> TypeBase<RV> {
             TypeEnum::RowVar(rv) => rv.substitute(t),
             TypeEnum::Alias(_) | TypeEnum::Sum(SumType::Unit { .. }) => vec![self.clone()],
             TypeEnum::Variable(idx, bound) => {
-                let TypeArg::Type(ty) = t.apply_var(*idx, &((*bound).into())) else {
+                let TypeArg::Runtime(ty) = t.apply_var(*idx, &((*bound).into())) else {
                     panic!("Variable was not a type - try validate() first")
                 };
                 vec![ty.into_()]
@@ -655,7 +655,7 @@ impl TypeRV {
 
     /// New use (occurrence) of the row variable with specified index.
     /// `bound` must match that with which the variable was declared
-    /// (i.e. as a [TypeParam::List]` of a `[TypeParam::Type]` of that bound).
+    /// (i.e. as a list of runtime types of that bound).
     /// For use in [OpDef], not [FuncDefn], type schemes only.
     ///
     /// [OpDef]: crate::extension::OpDef
@@ -757,7 +757,7 @@ impl<'a> Substitution<'a> {
                 .iter()
                 .map(|ta| {
                     match ta {
-                        Term::Type(ty) => return ty.clone().into(),
+                        Term::Runtime(ty) => return ty.clone().into(),
                         Term::Variable(v) => {
                             if let Some(b) = v.bound_if_row_var() {
                                 return TypeRV::new_row_var_use(v.index(), b);
@@ -768,7 +768,7 @@ impl<'a> Substitution<'a> {
                     panic!("Not a list of types - call validate() ?")
                 })
                 .collect(),
-            Term::Type(ty) if matches!(ty.0, TypeEnum::RowVar(_)) => {
+            Term::Runtime(ty) if matches!(ty.0, TypeEnum::RowVar(_)) => {
                 // Standalone "Type" can be used iff its actually a Row Variable not an actual (single) Type
                 vec![ty.clone().into()]
             }
@@ -783,7 +783,7 @@ impl<'a> Substitution<'a> {
 /// and applies to arbitrary extension types rather than type variables.
 pub trait TypeTransformer {
     /// Error returned when a [`CustomType`] cannot be transformed, or a type
-    /// containing it (e.g. if changing a [`TypeArg::Type`] from copyable to
+    /// containing it (e.g. if changing a runtime type from copyable to
     /// linear invalidates a parameterized type).
     type Err: std::error::Error + From<SignatureError>;
 
diff --git a/hugr-core/src/types/row_var.rs b/hugr-core/src/types/row_var.rs
@@ -6,7 +6,7 @@ use crate::extension::SignatureError;
 
 #[cfg(test)]
 use proptest::prelude::{BoxedStrategy, Strategy, any};
-/// Describes a row variable - a type variable bound with a [`TypeParam::List`] of [`TypeParam::Type`]
+/// Describes a row variable - a type variable bound with a list of runtime types
 /// of the specified bound (checked in validation)
 // The serde derives here are not used except as markers
 // so that other types containing this can also #derive-serde the same way.
diff --git a/hugr-core/src/types/serialize.rs b/hugr-core/src/types/serialize.rs
@@ -131,7 +131,7 @@ impl From<Term> for TermSer {
             Term::FloatType => TermSer::TypeParam(TypeParamSer::Float),
             Term::ListType(param) => TermSer::TypeParam(TypeParamSer::List { param }),
             Term::TupleType(params) => TermSer::TypeParam(TypeParamSer::Tuple { params }),
-            Term::Type(ty) => TermSer::TypeArg(TypeArgSer::Type { ty }),
+            Term::Runtime(ty) => TermSer::TypeArg(TypeArgSer::Type { ty }),
             Term::BoundedNat(n) => TermSer::TypeArg(TypeArgSer::BoundedNat { n }),
             Term::String(arg) => TermSer::TypeArg(TypeArgSer::String { arg }),
             Term::Bytes(value) => TermSer::TypeArg(TypeArgSer::Bytes { value }),
@@ -157,7 +157,7 @@ impl From<TermSer> for Term {
                 TypeParamSer::Tuple { params } => Term::TupleType(params),
             },
             TermSer::TypeArg(arg) => match arg {
-                TypeArgSer::Type { ty } => Term::Type(ty),
+                TypeArgSer::Type { ty } => Term::Runtime(ty),
                 TypeArgSer::BoundedNat { n } => Term::BoundedNat(n),
                 TypeArgSer::String { arg } => Term::String(arg),
                 TypeArgSer::Bytes { value } => Term::Bytes(value),
diff --git a/hugr-core/src/types/type_param.rs b/hugr-core/src/types/type_param.rs
diff --git a/hugr-llvm/src/extension/collections/array.rs b/hugr-llvm/src/extension/collections/array.rs
diff --git a/hugr-llvm/src/extension/collections/list.rs b/hugr-llvm/src/extension/collections/list.rs
diff --git a/hugr-llvm/src/extension/collections/stack_array.rs b/hugr-llvm/src/extension/collections/stack_array.rs
diff --git a/hugr-llvm/src/extension/collections/static_array.rs b/hugr-llvm/src/extension/collections/static_array.rs
diff --git a/hugr-passes/src/linearize_array.rs b/hugr-passes/src/linearize_array.rs
diff --git a/hugr-passes/src/monomorphize.rs b/hugr-passes/src/monomorphize.rs
diff --git a/hugr-passes/src/replace_types.rs b/hugr-passes/src/replace_types.rs
diff --git a/hugr-passes/src/replace_types/handlers.rs b/hugr-passes/src/replace_types/handlers.rs

Original file line number	Diff line number	Diff line change
`@@ -147,7 +147,7 @@ impl TypeDef {`
`147`	`147`	`least_upper_bound(indices.iter().map(\|i\| {`
`148`	`148`	`let ta = args.get(*i);`
`149`	`149`	`match ta {`
`150`		`- Some(TypeArg::Type(s)) => s.least_upper_bound(),`
	`150`	`+ Some(TypeArg::Runtime(s)) => s.least_upper_bound(),`
`151`	`151`	`_ => panic!("TypeArg index does not refer to a type."),`
`152`	`152`	`}`
`153`	`153`	`}))`
Original file line number	Diff line number	Diff line change
`@@ -180,7 +180,7 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayCloneDef<AK> {`
`180`	`180`
`181`	`181`	`fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {`
`182`	`182`	`match type_args {`
`183`		`- [TypeArg::BoundedNat(n), TypeArg::Type(ty)] if ty.copyable() => {`
	`183`	`+ [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] if ty.copyable() => {`
`184`	`184`	`Ok(GenericArrayClone::new(ty.clone(), *n).unwrap())`
`185`	`185`	`}`
`186`	`186`	`_ => Err(SignatureError::InvalidTypeArgs.into()),`
Original file line number	Diff line number	Diff line change
`@@ -231,7 +231,7 @@ impl<AK: ArrayKind, const DIR: Direction, OtherAK: ArrayKind> HasConcrete`
`231`	`231`
`232`	`232`	`fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {`
`233`	`233`	`match type_args {`
`234`		`- [TypeArg::BoundedNat(n), TypeArg::Type(ty)] => {`
	`234`	`+ [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] => {`
`235`	`235`	`Ok(GenericArrayConvert::new(ty.clone(), *n))`
`236`	`236`	`}`
`237`	`237`	`_ => Err(SignatureError::InvalidTypeArgs.into()),`
Original file line number	Diff line number	Diff line change
`@@ -164,7 +164,7 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayDiscardDef<AK> {`
`164`	`164`
`165`	`165`	`fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {`
`166`	`166`	`match type_args {`
`167`		`- [TypeArg::BoundedNat(n), TypeArg::Type(ty)] if ty.copyable() => {`
	`167`	`+ [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] if ty.copyable() => {`
`168`	`168`	`Ok(GenericArrayDiscard::new(ty.clone(), *n).unwrap())`
`169`	`169`	`}`
`170`	`170`	`_ => Err(SignatureError::InvalidTypeArgs.into()),`
Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ impl<AK: ArrayKind> HasConcrete for GenericArrayRepeatDef<AK> {`
`170`	`170`
`171`	`171`	`fn instantiate(&self, type_args: &[TypeArg]) -> Result<Self::Concrete, OpLoadError> {`
`172`	`172`	`match type_args {`
`173`		`- [TypeArg::BoundedNat(n), TypeArg::Type(ty)] => {`
	`173`	`+ [TypeArg::BoundedNat(n), TypeArg::Runtime(ty)] => {`
`174`	`174`	`Ok(GenericArrayRepeat::new(ty.clone(), *n))`
`175`	`175`	`}`
`176`	`176`	`_ => Err(SignatureError::InvalidTypeArgs.into()),`