Rename NameContext to NameScope

Context is a rather overloaded and overused term. Scope is more appropriate here.

Author: ngeor

rusty_linter/src/built_ins/data.rs

@@ -1,14 +1,14 @@
 use rusty_common::{AtPos, Position};
 use rusty_parser::{Expression, ExpressionPos, Expressions};
 
-use crate::core::{LintError, LintErrorPos, NameContext};
+use crate::core::{LintError, LintErrorPos, NameScope};
 
 pub fn lint(
     args: &Expressions,
-    name_context: NameContext,
+    name_scope: NameScope,
     pos: Position,
 ) -> Result<(), LintErrorPos> {
-    if name_context == NameContext::Global {
+    if name_scope == NameScope::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, NameContext};
+use crate::core::{LintErrorPos, NameScope};
 
 pub fn lint_sub_call(
     built_in_sub: &BuiltInSub,
     pos: Position,
     args: &Expressions,
-    name_context: NameContext,
+    name_scope: NameScope,
 ) -> 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_context, pos),
+        BuiltInSub::Data => data::lint(args, name_scope, pos),
         BuiltInSub::DefSeg => def_seg::lint(args, pos),
         BuiltInSub::Environ => environ_sub::lint(args, pos),
         BuiltInSub::Field => field::lint(args, pos),

rusty_linter/src/converter/statement/main.rs

@@ -3,7 +3,7 @@ use rusty_parser::{ExitObject, Statement};
 
 use crate::converter::common::{Context, Convertible, ConvertibleIn, DimContext, ExprContext};
 use crate::converter::statement::{assignment, const_rules};
-use crate::core::{LintError, LintErrorPos, NameContext};
+use crate::core::{LintError, LintErrorPos, NameScope};
 
 impl ConvertibleIn<Position> for Statement {
     fn convert_in(self, ctx: &mut Context, pos: Position) -> Result<Self, LintErrorPos> {
@@ -37,16 +37,16 @@ impl ConvertibleIn<Position> for Statement {
                     Ok(Self::Resume(resume_option))
                 }
             }
-            Self::Exit(exit_object) => match ctx.names.get_name_context() {
-                NameContext::Global => Err(LintError::IllegalOutsideSubFunction.at_pos(pos)),
-                NameContext::Sub => {
+            Self::Exit(exit_object) => match ctx.names.get_name_scope() {
+                NameScope::Global => Err(LintError::IllegalOutsideSubFunction.at_pos(pos)),
+                NameScope::Sub => {
                     if exit_object == ExitObject::Sub {
                         Ok(Self::Exit(exit_object))
                     } else {
                         Err(LintError::IllegalInSubFunction.at_pos(pos))
                     }
                 }
-                NameContext::Function => {
+                NameScope::Function => {
                     if exit_object == ExitObject::Function {
                         Ok(Self::Exit(exit_object))
                     } else {

rusty_linter/src/core/mod.rs

@@ -1,7 +1,7 @@
 mod casting;
 mod const_value_resolver;
 mod error;
-mod name_context;
+mod name_scope;
 mod qb_casting;
 mod qualify_variant;
 mod ref_to_value_visitor;
@@ -17,7 +17,7 @@ mod visitor;
 pub use self::casting::*;
 pub use self::const_value_resolver::*;
 pub use self::error::*;
-pub use self::name_context::*;
+pub use self::name_scope::*;
 pub use self::qb_casting::*;
 pub use self::qualify_variant::*;
 pub use self::ref_to_value_visitor::*;

rusty_linter/src/core/name_context.rs rusty_linter/src/core/name_scope.rsrusty_linter/src/core/name_context.rs renamed to rusty_linter/src/core/name_scope.rs

@@ -1,5 +1,5 @@
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub enum NameContext {
+pub enum NameScope {
     Global,
     Sub,
     Function,

rusty_linter/src/names/main.rs

@@ -6,7 +6,7 @@ use rusty_parser::{
 };
 use rusty_variant::Variant;
 
-use crate::core::{ConstLookup, NameContext, SubprogramName};
+use crate::core::{ConstLookup, NameScope, SubprogramName};
 use crate::names::ImplicitVars;
 use crate::names::names_inner::NamesInner;
 use crate::names::traits::ManyNamesTrait;
@@ -169,11 +169,11 @@ impl Names {
         self.current_key.is_some()
     }
 
-    pub fn get_name_context(&self) -> NameContext {
+    pub fn get_name_scope(&self) -> NameScope {
         match &self.current_key {
-            Some(SubprogramName::Function(_)) => NameContext::Function,
-            Some(SubprogramName::Sub(_)) => NameContext::Sub,
-            None => NameContext::Global,
+            Some(SubprogramName::Function(_)) => NameScope::Function,
+            Some(SubprogramName::Sub(_)) => NameScope::Sub,
+            None => NameScope::Global,
         }
     }
 

rusty_linter/src/post_linter/built_in_linter.rs

@@ -3,17 +3,17 @@ use rusty_parser::*;
 
 use super::post_conversion_linter::PostConversionLinter;
 use crate::built_ins::{lint_function_call, lint_sub_call};
-use crate::core::{LintErrorPos, NameContext};
+use crate::core::{LintErrorPos, NameScope};
 
 /// Lints built-in functions and subs.
 pub struct BuiltInLinter {
-    name_context: NameContext,
+    name_scope: NameScope,
 }
 
 impl BuiltInLinter {
     pub fn new() -> Self {
         Self {
-            name_context: NameContext::Global,
+            name_scope: NameScope::Global,
         }
     }
 }
@@ -23,16 +23,16 @@ impl PostConversionLinter for BuiltInLinter {
         &mut self,
         f: &FunctionImplementation,
     ) -> Result<(), LintErrorPos> {
-        self.name_context = NameContext::Function;
+        self.name_scope = NameScope::Function;
         let result = self.visit_statements(&f.body);
-        self.name_context = NameContext::Global;
+        self.name_scope = NameScope::Global;
         result
     }
 
     fn visit_sub_implementation(&mut self, s: &SubImplementation) -> Result<(), LintErrorPos> {
-        self.name_context = NameContext::Sub;
+        self.name_scope = NameScope::Sub;
         let result = self.visit_statements(&s.body);
-        self.name_context = NameContext::Global;
+        self.name_scope = NameScope::Global;
         result
     }
 
@@ -43,7 +43,7 @@ impl PostConversionLinter for BuiltInLinter {
     ) -> Result<(), LintErrorPos> {
         let (built_in_sub, args) = built_in_sub_call.into();
         self.visit_expressions(args)?;
-        lint_sub_call(built_in_sub, pos, args, self.name_context)
+        lint_sub_call(built_in_sub, pos, args, self.name_scope)
     }
 
     fn visit_expression(&mut self, expr_pos: &ExpressionPos) -> Result<(), LintErrorPos> {