chore: make .index() and .scope() use accessors (#480)

crates/core/src/marzano_context.rs

@@ -332,7 +332,7 @@ impl<'a> ExecContext<'a, MarzanoQueryContext> for MarzanoContext<'a> {
             };
         }
 
-        let Some(new_files) = state.bindings[GLOBAL_VARS_SCOPE_INDEX]
+        let Some(new_files) = state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
             .last()
             .and_then(|binding| binding[NEW_FILES_INDEX].value.as_ref())
             .and_then(ResolvedPattern::get_list_items)
@@ -376,8 +376,10 @@ impl<'a> ExecContext<'a, MarzanoQueryContext> for MarzanoContext<'a> {
         }
 
         state.effects = vector![];
-        let the_new_files =
-            state.bindings[GLOBAL_VARS_SCOPE_INDEX].back_mut().unwrap()[NEW_FILES_INDEX].as_mut();
+        let the_new_files = state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
+            .back_mut()
+            .unwrap()[NEW_FILES_INDEX]
+        .as_mut();
         the_new_files.value = Some(ResolvedPattern::from_list_parts([].into_iter()));
         Ok(true)
     }

crates/core/src/marzano_resolved_pattern.rs

@@ -395,7 +395,7 @@ impl<'a> ResolvedPattern<'a, MarzanoQueryContext> for MarzanoResolvedPattern<'a>
                     parts.push(ResolvedSnippet::Text(string.into()));
                 }
                 DynamicSnippetPart::Variable(var) => {
-                    let content = &state.bindings[var.scope].last().unwrap()[var.index];
+                    let content = &state.bindings[var.scope().into()].last().unwrap()[var.index().into()];
                     let name = &content.name;
                     // feels weird not sure if clone is correct
                     let value = if let Some(value) = &content.value {
@@ -424,7 +424,7 @@ impl<'a> ResolvedPattern<'a, MarzanoQueryContext> for MarzanoResolvedPattern<'a>
     ) -> GritResult<Self> {
         match pattern {
             DynamicPattern::Variable(var) => {
-                let content = &state.bindings[var.scope].last().unwrap()[var.index];
+                let content = &state.bindings[var.scope().into()].last().unwrap()[var.index().into()];
                 let name = &content.name;
                 // feels weird not sure if clone is correct
                 if let Some(value) = &content.value {
@@ -516,7 +516,7 @@ impl<'a> ResolvedPattern<'a, MarzanoQueryContext> for MarzanoResolvedPattern<'a>
             Pattern::FloatConstant(double) => Ok(Self::Constant(Constant::Float(double.value))),
             Pattern::BooleanConstant(bool) => Ok(Self::Constant(Constant::Boolean(bool.value))),
             Pattern::Variable(var) => {
-                let content = &state.bindings[var.scope].last().unwrap()[var.index];
+                let content = &state.bindings[var.scope().into()].last().unwrap()[var.index().into()];
                 let name = &content.name;
                 // feels weird not sure if clone is correct
                 if let Some(value) = &content.value {

crates/core/src/optimizer/hoist_files.rs

@@ -221,7 +221,7 @@ impl<Q: QueryContext> FilenamePatternExtractor<Q> for Predicate<Q> {
                 Ok(Some(Pattern::Any(Box::new(Any::new(patterns)))))
             }
             Predicate::Match(m) => {
-                match m.val {
+                match &m.val {
                     grit_pattern_matcher::pattern::Container::Variable(var) => {
                         if var.is_file_name() {
                             match &m.pattern {

crates/core/src/pattern_compiler/as_compiler.rs

@@ -51,9 +51,9 @@ impl NodeCompiler for AsCompiler {
         let pattern = PatternCompiler::from_node(&pattern, context)?;
         let variable = VariableCompiler::from_node(&variable, context)?;
         Ok(Where::new(
-            Pattern::Variable(variable),
+            Pattern::Variable(variable.clone()),
             Predicate::Match(Box::new(Match::new(
-                Container::Variable(variable),
+                Container::Variable(variable.clone()),
                 Some(pattern),
             ))),
         ))

crates/core/src/pattern_compiler/auto_wrap.rs

@@ -386,7 +386,7 @@ fn wrap_pattern_in_range<Q: QueryContext>(
         let range = file_range.range.clone();
         let range = PRange::from(range);
         let range_match = Predicate::Match(Box::new(Match::new(
-            Container::Variable(var),
+            Container::Variable(var.clone()),
             Some(Pattern::Range(range)),
         )));
         let file_match = Predicate::Match(Box::new(Match::new(
@@ -407,9 +407,9 @@ fn wrap_pattern_in_range<Q: QueryContext>(
         Predicate::Or(Box::new(PrOr::new(predicates))),
     )));
     let pattern = Pattern::Where(Box::new(Where::new(
-        Pattern::Variable(var),
+        Pattern::Variable(var.clone()),
         Predicate::Match(Box::new(Match::new(
-            Container::Variable(var),
+            Container::Variable(var.clone()),
             Some(pattern),
         ))),
     )));
@@ -423,9 +423,9 @@ fn wrap_pattern_in_contains<Q: QueryContext>(
 ) -> Result<Pattern<Q>> {
     let var = variable_from_name(var_name, context)?;
     let pattern = Pattern::Where(Box::new(Where::new(
-        Pattern::Variable(var),
+        Pattern::Variable(var.clone()),
         Predicate::Match(Box::new(Match::new(
-            Container::Variable(var),
+            Container::Variable(var.clone()),
             Some(pattern),
         ))),
     )));

crates/core/src/pattern_compiler/call_compiler.rs

@@ -128,10 +128,7 @@ impl NodeCompiler for CallCompiler {
                     )
                 })?;
             let args = match_args_to_params(kind, args, &collect_params(&info.parameters), lang)?;
-            Ok(Pattern::Call(Box::new(Call::new(
-                (info.index).to_owned(),
-                args,
-            ))))
+            Ok(Pattern::Call(Box::new(Call::new(info.index, args))))
         }
     }
 }

crates/core/src/pattern_compiler/snippet_compiler.rs

@@ -113,12 +113,12 @@ pub(crate) fn dynamic_snippet_from_source(
             )));
         } else if let Some(var) = context.global_vars.get(var.as_ref()) {
             if context.compilation.file == DEFAULT_FILE_NAME {
-                context.vars_array[GLOBAL_VARS_SCOPE_INDEX][*var]
+                context.vars_array[GLOBAL_VARS_SCOPE_INDEX as usize][*var]
                     .locations
                     .insert(range);
             }
             parts.push(DynamicSnippetPart::Variable(Variable::new(
-                GLOBAL_VARS_SCOPE_INDEX,
+                GLOBAL_VARS_SCOPE_INDEX as usize,
                 *var,
             )));
         } else if var.starts_with("$GLOBAL_") {

crates/core/src/problem.rs

@@ -553,8 +553,10 @@ impl Problem {
         let file_registry = FileRegistry::new_from_paths(file_names);
         let mut state = State::new(bindings, file_registry);
 
-        let the_new_files =
-            state.bindings[GLOBAL_VARS_SCOPE_INDEX].back_mut().unwrap()[NEW_FILES_INDEX].as_mut();
+        let the_new_files = state.bindings[GLOBAL_VARS_SCOPE_INDEX as usize]
+            .back_mut()
+            .unwrap()[NEW_FILES_INDEX]
+            .as_mut();
         the_new_files.value = Some(MarzanoResolvedPattern::from_list_parts([].into_iter()));
 
         let mut results: Vec<MatchResult> = Vec::new();

crates/core/src/variables.rs

@@ -70,19 +70,19 @@ fn register_variable_optional_range(
     if let Some(i) = global_vars.get(name) {
         if let Some(FileLocation { range, file_name }) = location {
             if file_name == DEFAULT_FILE_NAME {
-                vars_array[GLOBAL_VARS_SCOPE_INDEX][*i]
+                vars_array[GLOBAL_VARS_SCOPE_INDEX as usize][*i]
                     .locations
                     .insert(range);
             }
         }
-        return Ok(Variable::new(GLOBAL_VARS_SCOPE_INDEX, *i));
+        return Ok(Variable::new(GLOBAL_VARS_SCOPE_INDEX as usize, *i));
     }
     let (name_map, scope_index) = if name.starts_with("$GLOBAL_") || name.starts_with("^GLOBAL_") {
         (global_vars, GLOBAL_VARS_SCOPE_INDEX)
     } else {
-        (vars, *scope_index)
+        (vars, *scope_index as u16)
     };
-    let scope = &mut vars_array[scope_index];
+    let scope = &mut vars_array[scope_index as usize];
     let index = scope.len();
     name_map.insert(name.to_owned(), index);
 
@@ -100,5 +100,5 @@ fn register_variable_optional_range(
         file,
         locations,
     });
-    Ok(Variable::new(scope_index, index))
+    Ok(Variable::new(scope_index as usize, index))
 }

crates/grit-pattern-matcher/src/constants.rs

@@ -3,7 +3,7 @@ pub const PROGRAM_INDEX: usize = 1;
 pub const FILENAME_INDEX: usize = 2;
 pub const ABSOLUTE_PATH_INDEX: usize = 3;
 
-pub const GLOBAL_VARS_SCOPE_INDEX: usize = 0;
+pub const GLOBAL_VARS_SCOPE_INDEX: u16 = 0;
 
 pub const MATCH_VAR: &str = "$match";
 pub const GRIT_RANGE_VAR: &str = "$grit_range";

crates/grit-pattern-matcher/src/effects.rs

@@ -23,16 +23,17 @@ pub fn insert_effect<'a, Q: QueryContext>(
     match left {
         PatternOrResolved::Pattern(Pattern::Variable(var)) => {
             let var = state.trace_var(var);
-            if let Some(base) = state.bindings[var.scope].back_mut().unwrap()[var.index]
-                .value
-                .as_mut()
+            if let Some(base) = state.bindings[var.scope().into()].back_mut().unwrap()
+                [var.index().into()]
+            .value
+            .as_mut()
             {
                 base.extend(replacement, &mut state.effects, context.language())?;
                 Ok(true)
             } else {
                 Err(GritPatternError::new(format!(
                     "Variable {} is not bound",
-                    state.bindings[var.scope].last().unwrap()[var.index].name
+                    state.bindings[var.scope().into()].last().unwrap()[var.index().into()].name
                 )))
             }
         }

crates/grit-pattern-matcher/src/pattern/accumulate.rs

@@ -81,9 +81,10 @@ impl<Q: QueryContext> Evaluator<Q> for Accumulate<Q> {
         if let Pattern::Variable(var) = &self.left {
             let var = state.trace_var(var);
             let append = ResolvedPattern::from_pattern(&self.right, state, context, logs)?;
-            if let Some(base) = state.bindings[var.scope].back_mut().unwrap()[var.index]
-                .value
-                .as_mut()
+            if let Some(base) = state.bindings[var.scope().into()].back_mut().unwrap()
+                [var.index().into()]
+            .value
+            .as_mut()
             {
                 base.extend(append, &mut state.effects, context.language())?;
                 Ok(FuncEvaluation {
@@ -93,7 +94,7 @@ impl<Q: QueryContext> Evaluator<Q> for Accumulate<Q> {
             } else {
                 Err(GritPatternError::new(format!(
                     "Variable {} is not bound",
-                    state.bindings[var.scope].last().unwrap()[var.index].name
+                    state.bindings[var.scope().into()].last().unwrap()[var.index().into()].name
                 )))
             }
         } else {

crates/grit-pattern-matcher/src/pattern/container.rs

@@ -44,7 +44,7 @@ impl<Q: QueryContext> Container<Q> {
         match self {
             Container::Variable(v) => {
                 let var = state.trace_var(v);
-                let content = &mut state.bindings[var.scope].back_mut().unwrap()[var.index];
+                let content = &mut state.bindings[var.scope().into()].back_mut().unwrap()[var.index().into()];
                 match content.pattern {
                     Some(Pattern::Accessor(a)) => a.set_resolved(state, lang, value),
                     Some(Pattern::ListIndex(l)) => l.set_resolved(state, lang, value),

crates/grit-pattern-matcher/src/pattern/contains.rs

@@ -152,7 +152,7 @@ impl<Q: QueryContext> Matcher<Q> for Contains<Q> {
                 return Ok(false);
             }
 
-            init_state.bindings[GLOBAL_VARS_SCOPE_INDEX]
+            init_state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
                 .back_mut()
                 .unwrap()[PROGRAM_INDEX]
                 .value = Some(file.binding(&init_state.files));

crates/grit-pattern-matcher/src/pattern/file_pattern.rs

@@ -51,12 +51,22 @@ impl<Q: QueryContext> Matcher<Q> for FilePattern<Q> {
             .execute(&file.name(&state.files), state, context, logs)?;
 
         // Fill in the variables now - this is a bit of a hack
-        state.bindings[GLOBAL_VARS_SCOPE_INDEX].back_mut().unwrap()[PROGRAM_INDEX].value =
-            Some(file.binding(&state.files));
-        state.bindings[GLOBAL_VARS_SCOPE_INDEX].back_mut().unwrap()[FILENAME_INDEX].value =
-            Some(file.name(&state.files));
-        state.bindings[GLOBAL_VARS_SCOPE_INDEX].back_mut().unwrap()[ABSOLUTE_PATH_INDEX].value =
-            Some(file.absolute_path(&state.files, context.language())?);
+        state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
+            .back_mut()
+            .unwrap()[PROGRAM_INDEX]
+        .value = Some(file.binding(&state.files));
+        state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
+            .back_mut()
+            .unwrap()[FILENAME_INDEX]
+        .value = Some(file.name(&state.files));
+        state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
+            .back_mut()
+            .unwrap()[ABSOLUTE_PATH_INDEX]
+            .value = Some(file.name(&state.files));
+        state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
+            .back_mut()
+            .unwrap()[ABSOLUTE_PATH_INDEX]
+            .value = Some(file.absolute_path(&state.files, context.language())?);
 
         if !self
             .body

crates/grit-pattern-matcher/src/pattern/log.rs

@@ -60,7 +60,7 @@ impl<Q: QueryContext> Log<Q> {
             if self.message.is_none() {
                 message.push_str(&format!("Logging {}\n", name));
             }
-            let var_content = &state.bindings[var.scope].last().unwrap()[var.index];
+            let var_content = &state.bindings[var.scope().into()].last().unwrap()[var.index().into()];
             let value = var_content.value.as_ref();
             let src = value
                 .map(|v| {

crates/grit-pattern-matcher/src/pattern/match.rs

@@ -40,7 +40,7 @@ impl<Q: QueryContext> Evaluator<Q> for Match<Q> {
         match &self.val {
             Container::Variable(var) => {
                 let var = state.trace_var(var);
-                let var_content = &state.bindings[var.scope].last().unwrap()[var.index];
+                let var_content = &state.bindings[var.scope().into()].last().unwrap()[var.index().into()];
                 let predicator = if let Some(pattern) = &self.pattern {
                     if let Some(important_binding) = &var_content.value {
                         pattern.execute(&important_binding.clone(), state, context, logs)?

crates/grit-pattern-matcher/src/pattern/patterns.rs

@@ -235,8 +235,10 @@ impl<Q: QueryContext> Matcher<Q> for Pattern<Q> {
         logs: &mut AnalysisLogs,
     ) -> GritResult<bool> {
         if let Some(file) = binding.get_file() {
-            state.bindings[GLOBAL_VARS_SCOPE_INDEX].back_mut().unwrap()[FILENAME_INDEX].value =
-                Some(file.name(&state.files));
+            state.bindings[GLOBAL_VARS_SCOPE_INDEX.into()]
+                .back_mut()
+                .unwrap()[FILENAME_INDEX]
+            .value = Some(file.name(&state.files));
         }
 
         match self {

crates/grit-pattern-matcher/src/pattern/regex.rs

@@ -82,7 +82,7 @@ impl<Q: QueryContext> RegexPattern<Q> {
             // we should really be making the resolved pattern first, and using
             // variable execute, instead of reimplementing here.
             let variable_content =
-                &mut state.bindings[variable.scope].back_mut().unwrap()[variable.index];
+                &mut state.bindings[variable.scope().into()].back_mut().unwrap()[variable.index().into()];
 
             if let Some(previous_value) = &variable_content.value {
                 if previous_value
@@ -111,7 +111,7 @@ impl<Q: QueryContext> RegexPattern<Q> {
                     }
                 }
                 let variable_content =
-                    &mut state.bindings[variable.scope].back_mut().unwrap()[variable.index];
+                    &mut state.bindings[variable.scope().into()].back_mut().unwrap()[variable.index().into()];
                 variable_content.set_value(res);
             }
         }

crates/grit-pattern-matcher/src/pattern/rewrite.rs

@@ -62,8 +62,8 @@ impl<Q: QueryContext> Rewrite<Q> {
                         ..
                     }) = state
                         .bindings
-                        .get(var.scope)
-                        .and_then(|scope| scope.last().unwrap().get(var.index))
+                        .get(var.scope().into())
+                        .and_then(|scope| scope.last().unwrap().get(var.index().into()))
                         .cloned()
                         .map(|b| *b)
                     {

crates/grit-pattern-matcher/src/pattern/state.rs

@@ -296,7 +296,7 @@ impl<'a, Q: QueryContext> State<'a, Q> {
     // https://doc.rust-lang.org/nomicon/borrow-splitting.html
     // todo split State in a sensible way.
     pub fn get_name(&self, var: &Variable) -> &str {
-        &self.bindings[var.scope].last().unwrap()[var.index].name
+        &self.bindings[var.scope().into()].last().unwrap()[var.index().into()].name
     }
 
     /// Attempt to find a variable by name in any scope
@@ -339,11 +339,11 @@ impl<'a, Q: QueryContext> State<'a, Q> {
     /// Trace a variable to the root binding
     pub fn trace_var(&self, var: &Variable) -> Variable {
         if let Some(Pattern::Variable(v)) =
-            &self.bindings[var.scope].last().unwrap()[var.index].pattern
+            &self.bindings[var.scope().into()].last().unwrap()[var.index().into()].pattern
         {
             self.trace_var(v)
         } else {
-            *var
+            var.clone()
         }
     }