Semantics (#28)

* made it an error to put a value of 0 for step

* syntatic sugar for slices

* cargo fmt

* made it an error to put a value of 0 for step

* syntatic sugar for slices

* cargo fmt

* implemented hash maps for name lookup for structs

* cargo format

* new git ignore to ignore snapshots

* updated error for invalid step argument

* Minor spelling fix

---------

Co-authored-by: Nikil-Shyamsunder <[email protected]>

Author: fpham0701

.gitignore

@@ -1,3 +1,4 @@
 /target
 Cargo.lock
 .idea/
+/tests/snapshots

src/ir.rs

@@ -304,8 +304,9 @@ entity_impl!(SymbolId, "symbol");
 #[derive(Debug, Clone, Eq, PartialEq, Default)]
 pub struct SymbolTable {
     entries: PrimaryMap<SymbolId, SymbolTableEntry>,
-    by_name: FxHashMap<String, SymbolId>,
+    by_name_sym: FxHashMap<String, SymbolId>,
     structs: PrimaryMap<StructId, Struct>,
+    by_name_struct: FxHashMap<String, StructId>,
 }
 
 impl SymbolTable {
@@ -323,17 +324,17 @@ impl SymbolTable {
         let lookup_name = entry.full_name(self);
 
         assert!(
-            !self.by_name.contains_key(&lookup_name),
+            !self.by_name_sym.contains_key(&lookup_name),
             "we already have an entry for {lookup_name}!",
         );
 
         let id = self.entries.push(entry);
-        self.by_name.insert(lookup_name, id);
+        self.by_name_sym.insert(lookup_name, id);
         id
     }
 
     pub fn symbol_id_from_name(&self, name: &str) -> Option<SymbolId> {
-        self.by_name.get(name).copied()
+        self.by_name_sym.get(name).copied()
     }
 
     pub fn add_with_parent(&mut self, name: String, parent: SymbolId) -> SymbolId {
@@ -365,28 +366,28 @@ impl SymbolTable {
         let lookup_name = entry.full_name(self);
 
         assert!(
-            !self.by_name.contains_key(&lookup_name),
+            !self.by_name_sym.contains_key(&lookup_name),
             "we already have an entry for {lookup_name}!",
         );
 
         let id = self.entries.push(entry);
-        self.by_name.insert(lookup_name, id);
+        self.by_name_sym.insert(lookup_name, id);
         id
     }
 
     pub fn add_struct(&mut self, name: String, pins: Vec<Field>) -> StructId {
-        let s = Struct { name, pins };
-        self.structs.push(s)
-    }
+        let s = Struct {
+            name: name.to_string(),
+            pins,
+        };
+        let id = self.structs.push(s);
 
-    pub fn struct_id_from_name(&mut self, name: &str) -> Option<StructId> {
-        self.structs
-            .iter()
-            .find_map(|(id, s)| if s.name() == name { Some(id) } else { None })
+        self.by_name_struct.insert(name, id);
+        id
     }
 
-    pub fn struct_from_struct_id(&mut self, struct_id: StructId) -> &Struct {
-        &self.structs[struct_id]
+    pub fn struct_id_from_name(&mut self, name: &str) -> Option<StructId> {
+        self.by_name_struct.get(name).copied()
     }
 
     pub fn struct_ids(&self) -> Vec<StructId> {
@@ -398,7 +399,7 @@ impl Index<&str> for SymbolTable {
     type Output = SymbolTableEntry;
 
     fn index(&self, index: &str) -> &Self::Output {
-        let index = self.by_name[index];
+        let index = self.by_name_sym[index];
         &self.entries[index]
     }
 }

src/parser.rs

@@ -184,7 +184,7 @@ impl<'a> ParserContext<'a> {
                                 .st
                                 .struct_id_from_name(path_id_2)
                                 .ok_or_else(|| format!("Undefined struct: {}", path_id_2))?;
-                            let dut_struct = self.st.struct_from_struct_id(struct_id).clone();
+                            let dut_struct = self.st[struct_id].clone();
                             let dut_symbol_id = self
                                 .st
                                 .add_without_parent(path_id_1.to_string(), Type::Struct(struct_id));

src/serialize.rs

@@ -47,12 +47,16 @@ pub fn serialize_expr(tr: &Transaction, st: &SymbolTable, expr_id: &ExprId) -> S
             serialize_expr(tr, st, lhs) + " == " + &serialize_expr(tr, st, rhs)
         }
         Expr::Slice(expr, idx1, idx2) => {
-            serialize_expr(tr, st, expr)
-                + "["
-                + idx1.to_string().as_str()
-                + ":"
-                + idx2.to_string().as_str()
-                + "]"
+            if *idx2 == *idx1 {
+                serialize_expr(tr, st, expr) + "[" + idx1.to_string().as_str() + "]"
+            } else {
+                serialize_expr(tr, st, expr)
+                    + "["
+                    + idx1.to_string().as_str()
+                    + ":"
+                    + idx2.to_string().as_str()
+                    + "]"
+            }
         }
     }
 }

src/typecheck.rs

@@ -4,6 +4,8 @@
 // author: Kevin Laeufer <[email protected]>
 // author: Francis Pham <[email protected]>
 
+use baa::BitVecOps;
+
 use crate::parser;
 use crate::{diagnostic::*, ir::*, serialize::*};
 
@@ -65,6 +67,17 @@ fn check_stmt_types(
         Stmt::Step(exprid) => {
             let expr_type = check_expr_types(tr, st, handler, exprid)?;
             if let Type::BitVec(_) = expr_type {
+                if let Expr::Const(val) = &tr[exprid] {
+                    if val.to_i64().unwrap() >= 1 {
+                        return Ok(());
+                    }
+                    handler.emit_diagnostic_expr(
+                        tr,
+                        exprid,
+                        &format!("Argument to step must be a positive, non-zero integer literal."),
+                        Level::Error,
+                    );
+                }
                 Ok(())
             } else {
                 handler.emit_diagnostic_stmt(