Removed traits HasSubprograms and HasUserDefinedTypes

ngeor · ngeor · commit c7afa735c20f · 2026-02-24T20:17:22.000+01:00
diff --git a/rusty_basic/src/instruction_generator/main.rs b/rusty_basic/src/instruction_generator/main.rs
@@ -12,9 +12,7 @@ use crate::instruction_generator::subprogram_info::{
 };
 
 pub fn unwrap_linter_context(linter_context: Context) -> (Names, UserDefinedTypes) {
-    let (pre_linter_result, linter_names) = linter_context.into();
-    let user_defined_types = pre_linter_result.into();
-    (linter_names, user_defined_types)
+    (linter_context.names, linter_context.user_defined_types)
 }
 
 /// Generates instructions for the given program.
diff --git a/rusty_basic/src/interpreter/interpreter_trait.rs b/rusty_basic/src/interpreter/interpreter_trait.rs
@@ -1,6 +1,5 @@
 use std::collections::VecDeque;
 
-use rusty_linter::HasUserDefinedTypes;
 use rusty_variant::Variant;
 
 use crate::RuntimeErrorPos;
@@ -12,7 +11,7 @@ use crate::interpreter::io::{FileManager, Input, Printer};
 use crate::interpreter::registers::{RegisterStack, Registers};
 use crate::interpreter::screen::Screen;
 
-pub trait InterpreterTrait: HasUserDefinedTypes {
+pub trait InterpreterTrait {
     type TStdlib: Stdlib;
     type TStdIn: Input;
     type TStdOut: Printer;
diff --git a/rusty_basic/src/interpreter/main.rs b/rusty_basic/src/interpreter/main.rs
@@ -1,7 +1,7 @@
 use std::collections::VecDeque;
 
 use rusty_common::*;
-use rusty_linter::{HasUserDefinedTypes, QBNumberCast};
+use rusty_linter::QBNumberCast;
 use rusty_parser::UserDefinedTypes;
 use rusty_variant::Variant;
 
@@ -83,14 +83,6 @@ pub struct Interpreter<TStdlib: Stdlib, TStdIn: Input, TStdOut: Printer, TLpt1:
     def_seg: Option<usize>,
 }
 
-impl<TStdlib: Stdlib, TStdIn: Input, TStdOut: Printer, TLpt1: Printer> HasUserDefinedTypes
-    for Interpreter<TStdlib, TStdIn, TStdOut, TLpt1>
-{
-    fn user_defined_types(&self) -> &UserDefinedTypes {
-        &self.user_defined_types
-    }
-}
-
 impl<TStdlib: Stdlib, TStdIn: Input, TStdOut: Printer, TLpt1: Printer> InterpreterTrait
     for Interpreter<TStdlib, TStdIn, TStdOut, TLpt1>
 {
@@ -504,13 +496,13 @@ impl<TStdlib: Stdlib, TStdIn: Input, TStdOut: Printer, TLpt1: Printer>
                     .map(|res| res.map_err(RuntimeError::from))
                     .collect();
                 let args = r_args.with_err_at(&pos)?;
-                let v = allocate_array(args, element_type, self.user_defined_types())
+                let v = allocate_array(args, element_type, &self.user_defined_types)
                     .with_err_at(&pos)?;
                 self.registers_mut().set_a(v);
             }
             Instruction::AllocateUserDefined(user_defined_type_name) => {
                 let v =
-                    allocate_user_defined_type(user_defined_type_name, self.user_defined_types());
+                    allocate_user_defined_type(user_defined_type_name, &self.user_defined_types);
                 self.registers_mut().set_a(v);
             }
             Instruction::VarPathName(root_path) => {
diff --git a/rusty_linter/src/converter/common/context.rs b/rusty_linter/src/converter/common/context.rs
@@ -5,9 +5,10 @@ use crate::names::Names;
 use crate::pre_linter::PreLinterResult;
 
 pub struct Context {
-    pre_linter_result: PreLinterResult,
+    pub functions: SignatureMap,
+    pub subs: SignatureMap,
+    pub user_defined_types: UserDefinedTypes,
     pub resolver: TypeResolverImpl,
-    // TODO make this private
     pub names: Names,
 }
 
@@ -17,25 +18,12 @@ impl TypeResolver for Context {
     }
 }
 
-impl HasSubprograms for Context {
-    fn functions(&self) -> &SignatureMap {
-        self.pre_linter_result.functions()
-    }
-    fn subs(&self) -> &SignatureMap {
-        self.pre_linter_result.subs()
-    }
-}
-
-impl HasUserDefinedTypes for Context {
-    fn user_defined_types(&self) -> &UserDefinedTypes {
-        self.pre_linter_result.user_defined_types()
-    }
-}
-
 impl Context {
     pub fn new(pre_linter_result: PreLinterResult) -> Self {
         Self {
-            pre_linter_result,
+            functions: pre_linter_result.functions,
+            subs: pre_linter_result.subs,
+            user_defined_types: pre_linter_result.user_defined_types,
             resolver: TypeResolverImpl::new(),
             names: Names::new(),
         }
@@ -48,14 +36,8 @@ impl Context {
     /// Gets the function qualifier of the function identified by the given bare name.
     /// If no such function exists, returns `None`.
     pub fn function_qualifier(&self, bare_name: &BareName) -> Option<TypeQualifier> {
-        self.functions()
+        self.functions
             .get(bare_name)
             .and_then(|function_signature_pos| function_signature_pos.element.qualifier())
     }
 }
-
-impl From<Context> for (PreLinterResult, Names) {
-    fn from(value: Context) -> Self {
-        (value.pre_linter_result, value.names)
-    }
-}
diff --git a/rusty_linter/src/converter/dim_rules/validation.rs b/rusty_linter/src/converter/dim_rules/validation.rs
@@ -2,9 +2,7 @@ use rusty_common::{AtPos, Position, Positioned};
 use rusty_parser::{AsBareName, DimVar, Parameter, TypedName, VarType};
 
 use crate::converter::common::Context;
-use crate::core::{
-    ConstLookup, HasSubprograms, HasUserDefinedTypes, IntoTypeQualifier, LintError, LintErrorPos
-};
+use crate::core::{ConstLookup, IntoTypeQualifier, LintError, LintErrorPos};
 
 pub fn validate<T>(
     var_name: &TypedName<T>,
@@ -21,12 +19,12 @@ where
     cannot_clash_with_local_constants(var_name, ctx, pos)
 }
 
-fn cannot_clash_with_subs<T: VarType, C: HasSubprograms>(
+fn cannot_clash_with_subs<T: VarType>(
     var_name: &TypedName<T>,
-    ctx: &C,
+    ctx: &Context,
     pos: Position,
 ) -> Result<(), LintErrorPos> {
-    if ctx.subs().contains_key(var_name.as_bare_name()) {
+    if ctx.subs.contains_key(var_name.as_bare_name()) {
         Err(LintError::DuplicateDefinition.at_pos(pos))
     } else {
         Ok(())
@@ -55,7 +53,7 @@ impl CannotClashWithFunctions for DimVar {
         ctx: &Context,
         pos: Position,
     ) -> Result<(), LintErrorPos> {
-        if ctx.functions().contains_key(self.as_bare_name()) {
+        if ctx.functions.contains_key(self.as_bare_name()) {
             Err(LintError::DuplicateDefinition.at_pos(pos))
         } else {
             Ok(())
@@ -102,7 +100,7 @@ where
             element: type_name,
             pos,
         }) => {
-            if ctx.user_defined_types().contains_key(type_name) {
+            if ctx.user_defined_types.contains_key(type_name) {
                 Ok(())
             } else {
                 Err(LintError::TypeNotDefined.at(pos))
diff --git a/rusty_linter/src/converter/expr_rules/property.rs b/rusty_linter/src/converter/expr_rules/property.rs
@@ -7,7 +7,7 @@ use crate::converter::common::{Context, ConvertibleIn, ExprContext, ExprContextP
 use crate::converter::expr_rules::variable::{
     AssignToFunction, ExistingConst, ExistingVar, VarAsUserDefinedFunctionCall, VarResolve, add_as_new_implicit_var
 };
-use crate::core::{HasUserDefinedTypes, LintError, LintErrorPos};
+use crate::core::{LintError, LintErrorPos};
 
 pub fn convert(
     ctx: &mut Context,
@@ -145,7 +145,7 @@ fn existing_property_user_defined_type_name(
     property_name: Name,
     pos: Position,
 ) -> Result<Expression, LintErrorPos> {
-    match ctx.user_defined_types().get(user_defined_type_name) {
+    match ctx.user_defined_types.get(user_defined_type_name) {
         Some(user_defined_type) => existing_property_user_defined_type(
             resolved_left_side,
             user_defined_type,
diff --git a/rusty_linter/src/converter/expr_rules/variable.rs b/rusty_linter/src/converter/expr_rules/variable.rs
@@ -7,7 +7,7 @@ use rusty_variant::Variant;
 use crate::converter::common::{Context, ExprContext, ExprContextPos};
 use crate::converter::expr_rules::qualify_name::*;
 use crate::core::{
-    ConstLookup, HasSubprograms, IntoQualified, IntoTypeQualifier, LintError, LintErrorPos, LintResult, qualifier_of_const_variant
+    ConstLookup, IntoQualified, IntoTypeQualifier, LintError, LintErrorPos, LintResult, qualifier_of_const_variant
 };
 
 pub fn convert(
@@ -47,7 +47,7 @@ pub fn convert(
 }
 
 fn validate(ctx: &Context, name: &Name, pos: Position) -> Result<(), LintErrorPos> {
-    if ctx.subs().contains_key(name.as_bare_name()) {
+    if ctx.subs.contains_key(name.as_bare_name()) {
         return Err(LintError::DuplicateDefinition.at_pos(pos));
     }
 
diff --git a/rusty_linter/src/converter/statement/const_rules.rs b/rusty_linter/src/converter/statement/const_rules.rs
@@ -3,7 +3,7 @@ use rusty_parser::*;
 
 use crate::converter::common::Context;
 use crate::core::{
-    CastVariant, ConstEvaluator, HasSubprograms, LintError, LintErrorPos, LintResult, qualifier_of_const_variant
+    CastVariant, ConstEvaluator, LintError, LintErrorPos, LintResult, qualifier_of_const_variant
 };
 
 pub fn on_const(ctx: &mut Context, c: Constant) -> Result<Statement, LintErrorPos> {
@@ -23,8 +23,8 @@ fn const_cannot_clash_with_existing_names(
     if ctx
         .names
         .contains_any_locally_or_contains_extended_recursively(const_name.as_bare_name())
-        || ctx.subs().contains_key(const_name.as_bare_name())
-        || ctx.functions().contains_key(const_name.as_bare_name())
+        || ctx.subs.contains_key(const_name.as_bare_name())
+        || ctx.functions.contains_key(const_name.as_bare_name())
     {
         Err(LintError::DuplicateDefinition.at(const_name_pos))
     } else {
diff --git a/rusty_linter/src/core/traits.rs b/rusty_linter/src/core/traits.rs
@@ -1,17 +1,6 @@
-use rusty_parser::{
-    Expression, ExpressionPos, ExpressionType, HasExpressionType, TypeQualifier, UserDefinedTypes
-};
+use rusty_parser::{Expression, ExpressionPos, ExpressionType, HasExpressionType, TypeQualifier};
 
-use crate::core::{ResolvedParamType, SignatureMap};
-
-pub trait HasSubprograms {
-    fn functions(&self) -> &SignatureMap;
-    fn subs(&self) -> &SignatureMap;
-}
-
-pub trait HasUserDefinedTypes {
-    fn user_defined_types(&self) -> &UserDefinedTypes;
-}
+use crate::core::ResolvedParamType;
 
 /// Checks if a type can be cast into another type.
 pub trait CanCastTo<T> {
diff --git a/rusty_linter/src/lib.rs b/rusty_linter/src/lib.rs
@@ -10,9 +10,7 @@ mod tests;
 use rusty_parser::Program;
 
 pub use self::converter::Context;
-pub use self::core::{
-    CastVariant, HasUserDefinedTypes, LintError, QBNumberCast, ScopeName, qualifier_of_variant
-};
+pub use self::core::{CastVariant, LintError, QBNumberCast, ScopeName, qualifier_of_variant};
 pub use self::names::Names;
 use crate::converter::convert;
 use crate::core::LintErrorPos;
diff --git a/rusty_linter/src/post_linter/main.rs b/rusty_linter/src/post_linter/main.rs
@@ -1,27 +1,22 @@
 use rusty_parser::Program;
 
-use crate::core::{HasSubprograms, LintErrorPos, Visitor};
+use crate::Context;
+use crate::core::{LintErrorPos, Visitor};
 use crate::post_linter::expression_reducer::ExpressionReducer;
 use crate::post_linter::post_conversion_linter::PostConversionLinter;
 use crate::post_linter::{
     built_in_linter, condition_type_linter, dots_linter, for_next_counter_match_linter, label_linter, print_linter, select_case_linter, undefined_function_reducer, user_defined_function_linter, user_defined_sub_linter
 };
 
-pub fn post_linter(
-    result: Program,
-    linter_context: &impl HasSubprograms,
-) -> Result<Program, LintErrorPos> {
+pub fn post_linter(result: Program, linter_context: &Context) -> Result<Program, LintErrorPos> {
     // lint
     apply_linters(&result, linter_context)?;
     // reduce
     let mut reducer = undefined_function_reducer::UndefinedFunctionReducer { linter_context };
     reducer.visit_program(result)
 }
 
-fn apply_linters(
-    result: &Program,
-    linter_context: &impl HasSubprograms,
-) -> Result<(), LintErrorPos> {
+fn apply_linters(result: &Program, linter_context: &Context) -> Result<(), LintErrorPos> {
     let mut linter = for_next_counter_match_linter::ForNextCounterMatch::visitor();
     linter.visit(result)?;
 
diff --git a/rusty_linter/src/post_linter/undefined_function_reducer.rs b/rusty_linter/src/post_linter/undefined_function_reducer.rs
@@ -1,17 +1,15 @@
 use rusty_parser::{AsBareName, Expression};
 
 use super::expression_reducer::*;
-use crate::core::{HasSubprograms, LintErrorPos, binary_cast};
+use crate::Context;
+use crate::core::{LintErrorPos, binary_cast};
 
 /// Finds undefined functions and converts them to zeroes.
-pub struct UndefinedFunctionReducer<'a, R> {
-    pub linter_context: &'a R,
+pub struct UndefinedFunctionReducer<'a> {
+    pub linter_context: &'a Context,
 }
 
-impl<'a, R> ExpressionReducer for UndefinedFunctionReducer<'a, R>
-where
-    R: HasSubprograms,
-{
+impl<'a> ExpressionReducer for UndefinedFunctionReducer<'a> {
     fn visit_expression(&mut self, expression: Expression) -> Result<Expression, LintErrorPos> {
         match expression {
             Expression::BinaryExpression(op, left, right, _) => {
@@ -26,7 +24,7 @@ where
             Expression::FunctionCall(name, args) => {
                 if self
                     .linter_context
-                    .functions()
+                    .functions
                     .contains_key(name.as_bare_name())
                 {
                     Ok(Expression::FunctionCall(
diff --git a/rusty_linter/src/post_linter/user_defined_function_linter.rs b/rusty_linter/src/post_linter/user_defined_function_linter.rs
@@ -2,10 +2,11 @@ use rusty_common::*;
 use rusty_parser::*;
 
 use super::post_conversion_linter::PostConversionLinter;
+use crate::Context;
 use crate::core::*;
 
-pub struct UserDefinedFunctionLinter<'a, R> {
-    pub linter_context: &'a R,
+pub struct UserDefinedFunctionLinter<'a> {
+    pub linter_context: &'a Context,
 }
 
 pub fn lint_call_args(
@@ -150,10 +151,7 @@ fn has_at_least_one_arg(opt_args: Option<&Expressions>) -> bool {
     }
 }
 
-impl<'a, R> UserDefinedFunctionLinter<'a, R>
-where
-    R: HasSubprograms,
-{
+impl<'a> UserDefinedFunctionLinter<'a> {
     fn visit_function(
         &self,
         name: &Name,
@@ -162,7 +160,7 @@ where
     ) -> Result<(), LintErrorPos> {
         let qualifier = name.qualifier().expect("Unresolved function!");
         let bare_name = name.as_bare_name();
-        match self.linter_context.functions().get(bare_name) {
+        match self.linter_context.functions.get(bare_name) {
             Some(function_signature_pos) => {
                 if function_signature_pos.element != qualifier {
                     Err(LintError::TypeMismatch.at(function_signature_pos))
@@ -194,10 +192,7 @@ where
     }
 }
 
-impl<'a, R> PostConversionLinter for UserDefinedFunctionLinter<'a, R>
-where
-    R: HasSubprograms,
-{
+impl<'a> PostConversionLinter for UserDefinedFunctionLinter<'a> {
     fn visit_expression(&mut self, expr_pos: &ExpressionPos) -> Result<(), LintErrorPos> {
         let Positioned { element: e, pos } = expr_pos;
         match e {
diff --git a/rusty_linter/src/post_linter/user_defined_sub_linter.rs b/rusty_linter/src/post_linter/user_defined_sub_linter.rs
@@ -3,19 +3,17 @@ use rusty_parser::SubCall;
 
 use super::post_conversion_linter::PostConversionLinter;
 use super::user_defined_function_linter::lint_call_args;
-use crate::core::{HasSubprograms, LintError, LintErrorPos};
+use crate::Context;
+use crate::core::{LintError, LintErrorPos};
 
-pub struct UserDefinedSubLinter<'a, R> {
-    pub linter_context: &'a R,
+pub struct UserDefinedSubLinter<'a> {
+    pub linter_context: &'a Context,
 }
 
-impl<'a, R> PostConversionLinter for UserDefinedSubLinter<'a, R>
-where
-    R: HasSubprograms,
-{
+impl<'a> PostConversionLinter for UserDefinedSubLinter<'a> {
     fn visit_sub_call(&mut self, sub_call: &SubCall, pos: Position) -> Result<(), LintErrorPos> {
         let (name, args) = sub_call.into();
-        match self.linter_context.subs().get(name) {
+        match self.linter_context.subs.get(name) {
             Some(sub_signature_pos) => {
                 lint_call_args(args, sub_signature_pos.element.param_types(), pos)
             }
diff --git a/rusty_linter/src/pre_linter/main.rs b/rusty_linter/src/pre_linter/main.rs
diff --git a/rusty_linter/src/pre_linter/pre_linter_result.rs b/rusty_linter/src/pre_linter/pre_linter_result.rs
diff --git a/rusty_linter/src/tests/dim_assign_use_in_expr.rs b/rusty_linter/src/tests/dim_assign_use_in_expr.rs
diff --git a/rusty_linter/src/tests/test_utils.rs b/rusty_linter/src/tests/test_utils.rs

Original file line number	Diff line number	Diff line change
`@@ -12,9 +12,7 @@ use crate::instruction_generator::subprogram_info::{`
`12`	`12`	`};`
`13`	`13`
`14`	`14`	`pub fn unwrap_linter_context(linter_context: Context) -> (Names, UserDefinedTypes) {`
`15`		`- let (pre_linter_result, linter_names) = linter_context.into();`
`16`		`- let user_defined_types = pre_linter_result.into();`
`17`		`- (linter_names, user_defined_types)`
	`15`	`+ (linter_context.names, linter_context.user_defined_types)`
`18`	`16`	`}`
`19`	`17`
`20`	`18`	`/// Generates instructions for the given program.`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ use rusty_variant::Variant;`
`7`	`7`	`use crate::converter::common::{Context, ExprContext, ExprContextPos};`
`8`	`8`	`use crate::converter::expr_rules::qualify_name::*;`
`9`	`9`	`use crate::core::{`
`10`		`- ConstLookup, HasSubprograms, IntoQualified, IntoTypeQualifier, LintError, LintErrorPos, LintResult, qualifier_of_const_variant`
	`10`	`+ ConstLookup, IntoQualified, IntoTypeQualifier, LintError, LintErrorPos, LintResult, qualifier_of_const_variant`
`11`	`11`	`};`
`12`	`12`
`13`	`13`	`pub fn convert(`
`@@ -47,7 +47,7 @@ pub fn convert(`
`47`	`47`	`}`
`48`	`48`
`49`	`49`	`fn validate(ctx: &Context, name: &Name, pos: Position) -> Result<(), LintErrorPos> {`
`50`		`- if ctx.subs().contains_key(name.as_bare_name()) {`
	`50`	`+ if ctx.subs.contains_key(name.as_bare_name()) {`
`51`	`51`	`return Err(LintError::DuplicateDefinition.at_pos(pos));`
`52`	`52`	`}`
`53`	`53`