Add lint for correct usage of split

Author: VonTum

src/flattening/mod.rs

@@ -620,6 +620,16 @@ impl DeclarationKind {
             DeclarationKind::RegularGenerative | DeclarationKind::TemplateParameter(..) => true,
         }
     }
+    pub fn num_splits(&self) -> usize {
+        match self {
+            DeclarationKind::RegularWire { num_splits, .. } => *num_splits,
+            DeclarationKind::StructField(_)
+            | DeclarationKind::Port { .. }
+            | DeclarationKind::ConditionalBinding { .. }
+            | DeclarationKind::RegularGenerative
+            | DeclarationKind::TemplateParameter(_) => 0,
+        }
+    }
     pub fn is_state(&self) -> bool {
         match self {
             DeclarationKind::RegularWire { is_state, .. }

src/flattening/typecheck/lints.rs

@@ -29,6 +29,7 @@ pub fn perform_lints(pass: &mut LinkerPass, errors: &ErrorCollector, linker_file
     ctx.no_duplicate_ports();
     ctx.check_unsynthesizeable_types();
     ctx.no_calling_local_actions();
+    ctx.splits_are_used_correctly();
 }
 
 struct LintContext<'l> {
@@ -607,4 +608,78 @@ impl LintContext<'_> {
             }
         }
     }
+
+    // ==== splits ====
+    fn check_splits_for_wire_ref(&self, wr: &WireReference) {
+        let mut path_iter = wr.path.iter();
+        let decl = match &wr.root {
+            WireReferenceRoot::LocalDecl(decl_id) => {
+                self.working_on.instructions[*decl_id].unwrap_declaration()
+            }
+            WireReferenceRoot::LocalSubmodule(_)
+            | WireReferenceRoot::LocalInterface(_)
+            | WireReferenceRoot::NamedConstant(_)
+            | WireReferenceRoot::NamedModule(_)
+            | WireReferenceRoot::Error => return,
+        };
+
+        let decl_name = &decl.name;
+        let num_splits = decl.decl_kind.num_splits();
+        for _ in 0..num_splits {
+            match path_iter.next() {
+                Some(WireReferencePathElement::FieldAccess { name_span, .. }) => {
+                    self.errors
+                        .error(*name_span, format!("All split dimensions must be indexed. {decl_name} has {num_splits} splits."))
+                        .info_obj(decl);
+                }
+                None => {
+                    self.errors
+                        .error(wr.root_span, format!("All split dimensions must be indexed. {decl_name} has {num_splits} splits."))
+                        .info_obj(decl);
+                }
+                Some(WireReferencePathElement::ArraySlice { bracket_span, .. })
+                | Some(WireReferencePathElement::ArrayPartSelect { bracket_span, .. }) => {
+                    self.errors
+                        .error(bracket_span.inner_span(), format!("Split dimensions cannot be sliced. {decl_name} has {num_splits} splits."))
+                        .info_obj(decl);
+                }
+                Some(WireReferencePathElement::ArrayAccess { idx, bracket_span }) => {
+                    let idx = self.working_on.instructions[*idx].unwrap_subexpression();
+                    if !idx.domain.is_generative() {
+                        self.errors
+                        .error(bracket_span.inner_span(), format!("Indexing a split dimension must be generative. {decl_name} has {num_splits} splits."))
+                        .info_obj(decl);
+                    }
+                }
+            }
+        }
+    }
+    fn splits_are_used_correctly(&self) {
+        for (_, instr) in &self.working_on.instructions {
+            match instr {
+                Instruction::Declaration(decl) => {
+                    if let Some(num_arrays) = decl.typ.rank.count() {
+                        let num_splits = decl.decl_kind.num_splits();
+                        if num_arrays < num_splits {
+                            self.errors.error(decl.decl_span, format!("`split` requires the declaration's type to have as many array levels as `split` keywords provided. Found {num_arrays} arrays, and {num_splits} splits."));
+                        }
+                    }
+                }
+                Instruction::Expression(expression) => {
+                    if let ExpressionSource::WireRef(wr) = &expression.source {
+                        self.check_splits_for_wire_ref(wr);
+                    }
+                    if let ExpressionOutput::MultiWrite(mr) = &expression.output {
+                        for w in mr {
+                            self.check_splits_for_wire_ref(&w.to);
+                        }
+                    }
+                }
+                Instruction::SubModule(_)
+                | Instruction::Interface(_)
+                | Instruction::IfStatement(_)
+                | Instruction::ForStatement(_) => {}
+            }
+        }
+    }
 }

src/instantiation/execute.rs

@@ -1151,7 +1151,7 @@ impl<'l> ExecutionContext<'l> {
     }
 
     fn alloc_array_dimensions_stack(&mut self, peano_type: &PeanoType) -> Vec<UniCell<Value>> {
-        vec![Value::UNKNOWN; peano_type.count()]
+        vec![Value::UNKNOWN; peano_type.count_unwrap()]
     }
     fn expression_to_real_wire(
         &mut self,
@@ -1367,7 +1367,7 @@ impl<'l> ExecutionContext<'l> {
             }
             ExpressionSource::UnaryOp { op, rank, right } => {
                 let right_val = self.generation_state.get_generation_value(*right)?;
-                duplicate_for_all_array_ranks(&[right_val], rank.count(), &mut |[v]| {
+                duplicate_for_all_array_ranks(&[right_val], rank.count_unwrap(), &mut |[v]| {
                     Ok(compute_unary_op(*op, v))
                 })
                 .unwrap()
@@ -1383,7 +1383,7 @@ impl<'l> ExecutionContext<'l> {
 
                 duplicate_for_all_array_ranks(
                     &[left_val, right_val],
-                    rank.count(),
+                    rank.count_unwrap(),
                     &mut |[l, r]| compute_binary_op(l, *op, r),
                 )
                 .map_err(|reason| (expr.span, reason))?

src/typing/abstract_type.rs

@@ -152,7 +152,7 @@ impl PeanoType {
     #[allow(clippy::declare_interior_mutable_const)]
     pub const UNKNOWN: UniCell<PeanoType> = UniCell::UNKNOWN;
 
-    pub fn count(&self) -> usize {
+    pub fn count_unwrap(&self) -> usize {
         let mut cur = self;
         let mut sum = 0;
 
@@ -174,6 +174,20 @@ impl PeanoType {
     }
 }
 
+impl UniCell<PeanoType> {
+    pub fn count(&self) -> Option<usize> {
+        let mut cur = self.get()?;
+        let mut sum = 0;
+
+        while let PeanoType::Succ(succ) = cur {
+            cur = succ.get()?;
+            sum += 1;
+        }
+
+        Some(sum)
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct AbstractGlobalReference<ID> {
     pub id: ID,
@@ -190,7 +204,7 @@ impl AbstractRankedType {
             AbstractInnerType::Template(id) => args[*id]
                 .unwrap_type()
                 .clone()
-                .rank_up_multi(self.rank.count()),
+                .rank_up_multi(self.rank.count_unwrap()),
             AbstractInnerType::Named(named_ref) => {
                 AbstractInnerType::Named(named_ref.substitute_template_args(args))
                     .with_rank(self.rank.unwrap().clone())

src/typing/value_unifier.rs

@@ -206,7 +206,7 @@ impl Value {
         abs_typ: &AbstractRankedType,
         template_args: &TVec<ConcreteTemplateArg>,
     ) -> Result<ConcreteType, String> {
-        let array_depth = abs_typ.rank.count();
+        let array_depth = abs_typ.rank.count_unwrap();
         let mut tensor_sizes = Vec::with_capacity(array_depth);
 
         let content_typ = match abs_typ.inner.unwrap() {

test.sus

@@ -1763,3 +1763,13 @@ module TestNextPow2 {
 	// Should error
 	nextPow2#(V: -1)
 }
+
+module TestSplits {
+	input bool y
+	split bool[5] x
+
+	x[0] = y
+	for int i in 1..5 {
+		reg x[i] = x[i-1]
+	}
+}