Rename SubprogramName to ScopeName, NameScope to ScopeKind

Author: ngeor

rusty_basic/src/instruction_generator/calls.rs

@@ -1,5 +1,5 @@
 use rusty_common::{AtPos, Position, Positioned};
-use rusty_linter::SubprogramName;
+use rusty_linter::ScopeName;
 use rusty_parser::*;
 
 use crate::instruction_generator::{AddressOrLabel, Instruction, InstructionGenerator};
@@ -42,18 +42,18 @@ impl InstructionGenerator {
     ) {
         let Positioned { element: name, pos } = function_name;
         let qualified_name = name.demand_qualified();
-        let subprogram_name = SubprogramName::Function(qualified_name.clone());
+        let scope_name = ScopeName::Function(qualified_name.clone());
         // cloning to fight the borrow checker
         let function_parameters: Vec<Parameter> = self
             .subprogram_info_repository
-            .get_subprogram_info(&subprogram_name)
+            .get_subprogram_info(&scope_name)
             .params
             .clone();
         self.generate_push_named_args_instructions(&function_parameters, &args, pos);
-        self.push_stack(subprogram_name.clone(), pos);
+        self.push_stack(scope_name.clone(), pos);
         let index = self.instructions.len();
         self.push(Instruction::PushRet(index + 2), pos);
-        self.jump_to_subprogram(&subprogram_name, pos);
+        self.jump_to_subprogram(&scope_name, pos);
         // TODO find different way for by ref args
         // stash by-ref variables
         self.generate_stash_by_ref_args(&args);
@@ -69,18 +69,18 @@ impl InstructionGenerator {
 
     pub fn generate_sub_call_instructions(&mut self, sub_call: SubCall, pos: Position) {
         let (name, args) = sub_call.into();
-        let subprogram_name = SubprogramName::Sub(name);
+        let scope_name = ScopeName::Sub(name);
         // cloning to fight the borrow checker
         let sub_impl_parameters: Vec<Parameter> = self
             .subprogram_info_repository
-            .get_subprogram_info(&subprogram_name)
+            .get_subprogram_info(&scope_name)
             .params
             .clone();
         self.generate_push_named_args_instructions(&sub_impl_parameters, &args, pos);
-        self.push_stack(subprogram_name.clone(), pos);
+        self.push_stack(scope_name.clone(), pos);
         let index = self.instructions.len();
         self.push(Instruction::PushRet(index + 2), pos); // points to "generate_stash_by_ref_args"
-        self.jump_to_subprogram(&subprogram_name, pos);
+        self.jump_to_subprogram(&scope_name, pos);
         self.generate_stash_by_ref_args(&args);
         self.push(Instruction::PopStack, pos);
         self.generate_un_stash_by_ref_args(&args);
@@ -148,20 +148,20 @@ impl InstructionGenerator {
         }
     }
 
-    fn push_stack(&mut self, subprogram_name: SubprogramName, pos: Position) {
+    fn push_stack(&mut self, scope_name: ScopeName, pos: Position) {
         if self
             .subprogram_info_repository
-            .get_subprogram_info(&subprogram_name)
+            .get_subprogram_info(&scope_name)
             .is_static
         {
-            self.push(Instruction::PushStaticStack(subprogram_name), pos);
+            self.push(Instruction::PushStaticStack(scope_name), pos);
         } else {
             self.push(Instruction::PushStack, pos);
         }
     }
 
-    fn jump_to_subprogram(&mut self, subprogram_name: &SubprogramName, pos: Position) {
-        let label: BareName = Self::format_subprogram_label(subprogram_name);
+    fn jump_to_subprogram(&mut self, scope_name: &ScopeName, pos: Position) {
+        let label: BareName = Self::format_subprogram_label(scope_name);
         self.push(Instruction::Jump(AddressOrLabel::Unresolved(label)), pos);
     }
 }

rusty_basic/src/instruction_generator/dim.rs

@@ -1,5 +1,5 @@
 use rusty_common::*;
-use rusty_linter::SubprogramName;
+use rusty_linter::ScopeName;
 use rusty_parser::*;
 use rusty_variant::Variant;
 
@@ -46,7 +46,7 @@ impl InstructionGenerator {
 
 impl InstructionGenerator {
     fn is_in_static_subprogram(&self) -> bool {
-        if self.current_subprogram == SubprogramName::Global {
+        if self.current_subprogram == ScopeName::Global {
             false
         } else {
             self.subprogram_info_repository

rusty_basic/src/instruction_generator/main.rs

@@ -1,5 +1,5 @@
 use rusty_common::{AtPos, CaseInsensitiveString, Position, Positioned};
-use rusty_linter::{Context, Names, SubprogramName};
+use rusty_linter::{Context, Names, ScopeName};
 use rusty_parser::{
     Assignment, BareName, BuiltInFunction, BuiltInSub, DimVar, Expression, ExpressionType, FileHandle, FunctionImplementation, GlobalStatement, HasExpressionType, Name, Parameter, Program, Statement, Statements, SubImplementation, TypeQualifier, UserDefinedTypes
 };
@@ -181,7 +181,7 @@ pub enum Instruction {
     PushUnnamedByRef,
 
     PushStack,
-    PushStaticStack(SubprogramName),
+    PushStaticStack(ScopeName),
     PopStack,
 
     EnqueueToReturnStack(usize),
@@ -264,7 +264,7 @@ pub struct InstructionGenerator {
     pub instructions: Vec<InstructionPos>,
     pub statement_addresses: Vec<usize>,
     pub subprogram_info_repository: SubprogramInfoRepository,
-    pub current_subprogram: SubprogramName,
+    pub current_subprogram: ScopeName,
     pub linter_names: Names,
 }
 
@@ -274,7 +274,7 @@ impl InstructionGenerator {
             instructions: vec![],
             statement_addresses: vec![],
             subprogram_info_repository,
-            current_subprogram: SubprogramName::Global,
+            current_subprogram: ScopeName::Global,
             linter_names,
         }
     }
@@ -375,7 +375,7 @@ impl InstructionGenerator {
         let qualifier = function_name
             .qualifier()
             .expect("Expected qualified function name");
-        self.mark_current_subprogram(SubprogramName::Function(function_name), pos);
+        self.mark_current_subprogram(ScopeName::Function(function_name), pos);
         // set default value
         self.push(Instruction::AllocateBuiltIn(qualifier), pos);
         self.subprogram_body(body, pos);
@@ -397,21 +397,21 @@ impl InstructionGenerator {
             body,
             ..
         } = sub_implementation;
-        self.mark_current_subprogram(SubprogramName::Sub(name), pos);
+        self.mark_current_subprogram(ScopeName::Sub(name), pos);
         self.subprogram_body(body, pos);
     }
 
-    fn mark_current_subprogram(&mut self, subprogram_name: SubprogramName, pos: Position) {
+    fn mark_current_subprogram(&mut self, scope_name: ScopeName, pos: Position) {
         debug_assert_ne!(
-            subprogram_name,
-            SubprogramName::Global,
+            scope_name,
+            ScopeName::Global,
             "should not mark global scope"
         );
         self.push(
-            Instruction::Label(Self::format_subprogram_label(&subprogram_name)),
+            Instruction::Label(Self::format_subprogram_label(&scope_name)),
             pos,
         );
-        self.current_subprogram = subprogram_name;
+        self.current_subprogram = scope_name;
     }
 
     fn subprogram_body(&mut self, block: Statements, pos: Position) {
@@ -474,21 +474,21 @@ impl InstructionGenerator {
         self.statement_addresses.push(self.instructions.len());
     }
 
-    pub fn format_subprogram_label(subprogram_name: &SubprogramName) -> BareName {
-        let s: String = match subprogram_name {
-            SubprogramName::Function(function_name) => {
+    pub fn format_subprogram_label(scope_name: &ScopeName) -> BareName {
+        let s: String = match scope_name {
+            ScopeName::Function(function_name) => {
                 let mut s: String = String::new();
                 s.push_str(":fun:");
                 s.push_str(&function_name.to_string());
                 s
             }
-            SubprogramName::Sub(sub_name) => {
+            ScopeName::Sub(sub_name) => {
                 let mut s: String = String::new();
                 s.push_str(":sub:");
                 s.push_str(sub_name.as_ref());
                 s
             }
-            SubprogramName::Global => {
+            ScopeName::Global => {
                 panic!("Should not generate label for global scope")
             }
         };

rusty_basic/src/instruction_generator/subprogram_info.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use rusty_common::Positioned;
-use rusty_linter::SubprogramName;
+use rusty_linter::ScopeName;
 use rusty_parser::*;
 
 /// Holds information about a subprogram that is needed at runtime.
@@ -27,7 +27,7 @@ impl SubprogramInfo {
 
 #[derive(Default)]
 pub struct SubprogramInfoCollector {
-    map: HashMap<SubprogramName, SubprogramInfo>,
+    map: HashMap<ScopeName, SubprogramInfo>,
 }
 
 impl SubprogramInfoCollector {
@@ -51,30 +51,28 @@ impl SubprogramInfoCollector {
 
     fn visit_function_implementation(&mut self, f: &FunctionImplementation) {
         let function_name = f.name.element.clone().demand_qualified();
-        let subprogram_name = SubprogramName::Function(function_name);
-        self.map.insert(subprogram_name, SubprogramInfo::new(f));
+        let scope_name = ScopeName::Function(function_name);
+        self.map.insert(scope_name, SubprogramInfo::new(f));
     }
 
     fn visit_sub_implementation(&mut self, s: &SubImplementation) {
         let sub_name = s.name.element.clone();
-        let subprogram_name = SubprogramName::Sub(sub_name);
-        self.map.insert(subprogram_name, SubprogramInfo::new(s));
+        let scope_name = ScopeName::Sub(sub_name);
+        self.map.insert(scope_name, SubprogramInfo::new(s));
     }
 }
 
 pub struct SubprogramInfoRepository {
-    map: HashMap<SubprogramName, SubprogramInfo>,
+    map: HashMap<ScopeName, SubprogramInfo>,
 }
 
 impl SubprogramInfoRepository {
-    pub fn new(map: HashMap<SubprogramName, SubprogramInfo>) -> Self {
+    pub fn new(map: HashMap<ScopeName, SubprogramInfo>) -> Self {
         Self { map }
     }
 
-    pub fn get_subprogram_info(&self, subprogram_name: &SubprogramName) -> &SubprogramInfo {
-        self.map
-            .get(subprogram_name)
-            .expect("Function/Sub not found")
+    pub fn get_subprogram_info(&self, scope_name: &ScopeName) -> &SubprogramInfo {
+        self.map.get(scope_name).expect("Function/Sub not found")
     }
 }
 

rusty_basic/src/interpreter/context.rs

@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 
 use rusty_common::CaseInsensitiveString;
-use rusty_linter::{QBNumberCast, SubprogramName};
+use rusty_linter::{QBNumberCast, ScopeName};
 use rusty_parser::{BareName, BuiltInFunction, TypeQualifier};
 use rusty_variant::{UserDefinedTypeValue, VArray, Variant, bytes_to_i32, i32_to_bytes};
 
@@ -19,7 +19,7 @@ pub struct Context {
     states: Vec<State>,
     memory_blocks: Vec<MemoryBlock>,
     // static memory blocks (for STATIC function/sub)
-    static_memory_blocks: HashMap<SubprogramName, usize>,
+    static_memory_blocks: HashMap<ScopeName, usize>,
 }
 
 impl Context {
@@ -49,11 +49,11 @@ impl Context {
         self.do_push_new(variables, false);
     }
 
-    pub fn stop_collecting_arguments_static(&mut self, subprogram_name: SubprogramName) {
+    pub fn stop_collecting_arguments_static(&mut self, scope_name: ScopeName) {
         // current state must be argument collecting state
         let arguments = self.do_pop().arguments.expect("Expected argument state");
         // ensure memory block for this subprogram
-        match self.static_memory_blocks.get(&subprogram_name) {
+        match self.static_memory_blocks.get(&scope_name) {
             Some(existing_memory_block_index) => {
                 let memory_block_index = *existing_memory_block_index;
                 self.memory_blocks[memory_block_index]
@@ -65,7 +65,7 @@ impl Context {
                 let variables = Variables::from(arguments);
                 let memory_block_index = self.do_push_new(variables, true);
                 self.static_memory_blocks
-                    .insert(subprogram_name, memory_block_index);
+                    .insert(scope_name, memory_block_index);
             }
         }
     }

rusty_basic/src/interpreter/main.rs

@@ -397,9 +397,9 @@ impl<TStdlib: Stdlib, TStdIn: Input, TStdOut: Printer, TLpt1: Printer>
                 self.context.stop_collecting_arguments();
                 self.stacktrace.insert(0, pos);
             }
-            Instruction::PushStaticStack(subprogram_name) => {
+            Instruction::PushStaticStack(scope_name) => {
                 self.context
-                    .stop_collecting_arguments_static(subprogram_name.clone());
+                    .stop_collecting_arguments_static(scope_name.clone());
                 self.stacktrace.insert(0, pos);
             }
             Instruction::PopStack => {

rusty_linter/src/built_ins/data.rs

@@ -1,10 +1,10 @@
 use rusty_common::{AtPos, Position};
 use rusty_parser::{Expression, ExpressionPos, Expressions};
 
-use crate::core::{LintError, LintErrorPos, NameScope};
+use crate::core::{LintError, LintErrorPos, ScopeKind};
 
-pub fn lint(args: &Expressions, name_scope: NameScope, pos: Position) -> Result<(), LintErrorPos> {
-    if name_scope == NameScope::Global {
+pub fn lint(args: &Expressions, scope_kind: ScopeKind, pos: Position) -> Result<(), LintErrorPos> {
+    if scope_kind == ScopeKind::Global {
         args.iter().try_for_each(require_constant)
     } else {
         Err(LintError::IllegalInSubFunction.at_pos(pos))

rusty_linter/src/built_ins/mod.rs

@@ -49,21 +49,21 @@ mod width;
 use rusty_common::Position;
 use rusty_parser::{BuiltInFunction, BuiltInSub, Expressions};
 
-use crate::core::{LintErrorPos, NameScope};
+use crate::core::{LintErrorPos, ScopeKind};
 
 pub fn lint_sub_call(
     built_in_sub: &BuiltInSub,
     pos: Position,
     args: &Expressions,
-    name_scope: NameScope,
+    scope_kind: ScopeKind,
 ) -> Result<(), LintErrorPos> {
     match built_in_sub {
         BuiltInSub::Beep => beep::lint(args, pos),
         BuiltInSub::CallAbsolute => Ok(()),
         BuiltInSub::Close => close::lint(args),
         BuiltInSub::Cls => cls::lint(args, pos),
         BuiltInSub::Color => color::lint(args, pos),
-        BuiltInSub::Data => data::lint(args, name_scope, pos),
+        BuiltInSub::Data => data::lint(args, scope_kind, pos),
         BuiltInSub::DefSeg => def_seg::lint(args, pos),
         BuiltInSub::Environ => environ_sub::lint(args, pos),
         BuiltInSub::Field => field::lint(args, pos),