Add support for a scoped index

The scoped index contains new variables and datatypes that could later
be merged into the main index.

Any ast statetment that could declare new variables or represents a
scope is marked with a new scope.
Further statements would inherit this scope to see new variables.
TODO: Going out of scope would merge the new variables with unique names
back into the index.

Co-authored-by: Michael <[email protected]>

compiler/plc_ast/src/provider.rs

@@ -5,7 +5,7 @@ use std::sync::{
 
 use crate::ast::AstId;
 
-#[derive(Clone)]
+#[derive(Debug, Clone)]
 pub struct IdProvider {
     current_id: Arc<AtomicUsize>,
 }

src/index.rs

@@ -22,6 +22,7 @@ use self::{
 
 pub mod const_expressions;
 mod instance_iterator;
+pub mod scoped_index;
 pub mod symbol;
 #[cfg(test)]
 mod tests;
@@ -734,7 +735,7 @@ impl PouIndexEntry {
 /// the TypeIndex carries all types.
 /// it is extracted into its seaprate struct so it can be
 /// internally borrowed individually from the other maps
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct TypeIndex {
     /// all types (structs, enums, type, POUs, etc.)
     types: SymbolMap<String, DataType>,

src/index/scoped_index.rs

@@ -0,0 +1,64 @@
+use std::{collections::HashMap, rc::Rc};
+
+use plc_ast::provider::IdProvider;
+use plc_source::source_location::SourceLocation;
+
+use crate::typesystem::DataType;
+
+use super::VariableIndexEntry;
+
+/// A minimal index implementation that can be used for local scopes
+#[derive(Debug, Clone)]
+pub struct ScopedIndex {
+    ///The scope of the current index, this is usually a POU
+    scope: String,
+
+    /// A unique identifier that new variables in this scope will inherit
+    suffix_provider: IdProvider,
+
+    /// The location that caused this scope to be created
+    start_location: SourceLocation,
+
+    /// New variables defined by this index
+    variables: HashMap<String, VariableIndexEntry>,
+
+    /// Datatypes defined by this index
+    type_index: HashMap<String, DataType>,
+
+    parent: Option<Rc<ScopedIndex>>,
+}
+
+impl ScopedIndex {
+    pub fn merge_into(self, target: &mut Self) {
+        target.variables.extend(self.variables);
+        target.type_index.extend(self.type_index);
+    }
+
+    pub fn add_variable(&mut self, _name: &str) {}
+
+    pub fn add_type(&mut self, _name: &str) {}
+
+    pub fn find_variable(&self, _name: &str) -> Option<&VariableIndexEntry> {
+        todo!()
+    }
+
+    pub fn find_type(&self, _name: &str) -> Option<&DataType> {
+        todo!()
+    }
+
+    pub fn new(
+        parent: Option<Rc<ScopedIndex>>,
+        location: SourceLocation,
+        scope: &str,
+        suffix_provider: IdProvider,
+    ) -> ScopedIndex {
+        ScopedIndex {
+            scope: scope.to_string(),
+            suffix_provider,
+            start_location: location,
+            parent,
+            type_index: Default::default(),
+            variables: Default::default(),
+        }
+    }
+}

src/index/symbol.rs

@@ -18,6 +18,16 @@ impl<K, V> Default for SymbolMap<K, V> {
     }
 }
 
+impl<K, V> Clone for SymbolMap<K, V>
+where
+    K: Clone,
+    V: Clone,
+{
+    fn clone(&self) -> Self {
+        Self { inner_map: self.inner_map.clone() }
+    }
+}
+
 impl<K, V> SymbolMap<K, V>
 where
     K: Hash + Eq,