Add Global enum member to SubprogramName

Author: ngeor

rusty_basic/src/instruction_generator/dim.rs

@@ -1,4 +1,5 @@
 use rusty_common::*;
+use rusty_linter::SubprogramName;
 use rusty_parser::*;
 use rusty_variant::Variant;
 
@@ -45,13 +46,12 @@ impl InstructionGenerator {
 
 impl InstructionGenerator {
     fn is_in_static_subprogram(&self) -> bool {
-        match &self.current_subprogram {
-            Some(subprogram_name) => {
-                self.subprogram_info_repository
-                    .get_subprogram_info(subprogram_name)
-                    .is_static
-            }
-            _ => false,
+        if self.current_subprogram == SubprogramName::Global {
+            false
+        } else {
+            self.subprogram_info_repository
+                .get_subprogram_info(&self.current_subprogram)
+                .is_static
         }
     }
 

rusty_basic/src/instruction_generator/main.rs

@@ -264,7 +264,7 @@ pub struct InstructionGenerator {
     pub instructions: Vec<InstructionPos>,
     pub statement_addresses: Vec<usize>,
     pub subprogram_info_repository: SubprogramInfoRepository,
-    pub current_subprogram: Option<SubprogramName>,
+    pub current_subprogram: SubprogramName,
     pub linter_names: Names,
 }
 
@@ -274,7 +274,7 @@ impl InstructionGenerator {
             instructions: vec![],
             statement_addresses: vec![],
             subprogram_info_repository,
-            current_subprogram: None,
+            current_subprogram: SubprogramName::Global,
             linter_names,
         }
     }
@@ -402,11 +402,16 @@ impl InstructionGenerator {
     }
 
     fn mark_current_subprogram(&mut self, subprogram_name: SubprogramName, pos: Position) {
+        debug_assert_ne!(
+            subprogram_name,
+            SubprogramName::Global,
+            "should not mark global scope"
+        );
         self.push(
             Instruction::Label(Self::format_subprogram_label(&subprogram_name)),
             pos,
         );
-        self.current_subprogram = Some(subprogram_name);
+        self.current_subprogram = subprogram_name;
     }
 
     fn subprogram_body(&mut self, block: Statements, pos: Position) {
@@ -483,6 +488,9 @@ impl InstructionGenerator {
                 s.push_str(sub_name.as_ref());
                 s
             }
+            SubprogramName::Global => {
+                panic!("Should not generate label for global scope")
+            }
         };
         BareName::new(s)
     }

rusty_linter/src/core/subprogram_name.rs

@@ -1,11 +1,26 @@
 use rusty_parser::{BareName, Name};
 
+use crate::core::NameScope;
+
 /// Holds the resolved name of a subprogram.
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum SubprogramName {
+    /// The global scope.
+    Global,
+
     /// The resolved qualified name of a function.
     Function(Name),
 
     /// The resolved name of a sub.
     Sub(BareName),
 }
+
+impl From<&SubprogramName> for NameScope {
+    fn from(subprogram_name: &SubprogramName) -> Self {
+        match subprogram_name {
+            SubprogramName::Global => Self::Global,
+            SubprogramName::Function(_) => Self::Function,
+            SubprogramName::Sub(_) => Self::Sub,
+        }
+    }
+}

rusty_linter/src/names/main.rs

@@ -31,11 +31,9 @@ e.g. A = 3.14 (resolves as A! by the default rules), A$ = "hello", A% = 1
 5b. An extended variable cannot co-exist with other symbols of the same name
 */
 
-type Key = Option<SubprogramName>;
-
 pub struct Names {
-    data: HashMap<Key, NamesOneLevel>,
-    current_key: Key,
+    data: HashMap<SubprogramName, NamesOneLevel>,
+    current_key: SubprogramName,
 }
 
 /// Stores the data relevant to one level only (i.e. global symbols, or a FUNCTION, or a SUB).
@@ -47,12 +45,12 @@ struct NamesOneLevel(NamesInner, ImplicitVars);
 
 impl Names {
     pub fn new() -> Self {
-        let mut data: HashMap<Key, NamesOneLevel> = HashMap::new();
+        let mut data: HashMap<SubprogramName, NamesOneLevel> = HashMap::new();
         // insert GLOBAL scope
-        data.insert(None, NamesOneLevel::default());
+        data.insert(SubprogramName::Global, NamesOneLevel::default());
         Self {
             data,
-            current_key: None,
+            current_key: SubprogramName::Global,
         }
     }
 
@@ -79,8 +77,8 @@ impl Names {
     /// Returns the global names, but only if we are currently within a sub program.
     fn global_names(&self) -> Option<&NamesInner> {
         match &self.current_key {
-            Some(_) => self.data.get(&None).map(|x| &x.0),
-            None => None,
+            SubprogramName::Global => None,
+            _ => self.data.get(&SubprogramName::Global).map(|x| &x.0),
         }
     }
 
@@ -160,39 +158,40 @@ impl Names {
 
     pub fn is_in_function(&self, function_name: &BareName) -> bool {
         match &self.current_key {
-            Some(SubprogramName::Function(f)) => f.as_bare_name() == function_name,
+            SubprogramName::Function(f) => f.as_bare_name() == function_name,
             _ => false,
         }
     }
 
     pub fn is_in_subprogram(&self) -> bool {
-        self.current_key.is_some()
+        self.current_key != SubprogramName::Global
     }
 
     pub fn get_name_scope(&self) -> NameScope {
-        match &self.current_key {
-            Some(SubprogramName::Function(_)) => NameScope::Function,
-            Some(SubprogramName::Sub(_)) => NameScope::Sub,
-            None => NameScope::Global,
-        }
+        NameScope::from(&self.current_key)
     }
 
     pub fn push(&mut self, subprogram_name: SubprogramName) {
-        let key = Some(subprogram_name);
         debug_assert!(
-            !self.data.contains_key(&key),
+            !self.data.contains_key(&subprogram_name),
             "should not encounter same function/sub twice!"
         );
-        self.current_key = key.clone();
-        self.data.insert(key, NamesOneLevel::default());
+        debug_assert_ne!(
+            subprogram_name,
+            SubprogramName::Global,
+            "should not push global scope"
+        );
+        self.current_key = subprogram_name.clone();
+        self.data.insert(subprogram_name, NamesOneLevel::default());
     }
 
     pub fn pop(&mut self) {
-        debug_assert!(
-            self.current_key.is_some(),
+        debug_assert_ne!(
+            self.current_key,
+            SubprogramName::Global,
             "should not pop context from the global level"
         );
-        self.current_key = None;
+        self.current_key = SubprogramName::Global;
     }
 
     pub fn find_name_or_shared_in_parent(
@@ -208,7 +207,7 @@ impl Names {
 
     pub fn get_resolved_variable_info(
         &self,
-        subprogram_name: &Option<SubprogramName>,
+        subprogram_name: &SubprogramName,
         name: &Name,
     ) -> &VariableInfo {
         let one_level = self
@@ -218,11 +217,11 @@ impl Names {
         match one_level.0.get_variable_info_by_name(name) {
             Some(i) => i,
             None => {
-                if subprogram_name.is_some() {
+                if subprogram_name != &SubprogramName::Global {
                     // try then parent level but only for SHARED
                     let result = self
                         .data
-                        .get(&None)
+                        .get(&SubprogramName::Global)
                         .expect("Global name scope missing!")
                         .0
                         .get_variable_info_by_name(name)