Add pub attribute for struct fields

src/type_checker/checker.rs

@@ -123,22 +123,13 @@ impl<B: Backend> TypeChecker<B> {
                     .find(|(field_name, _, _)| field_name == &rhs.value)
                 {
                     // check for the pub attribute
-                    let is_public = attribute
-                        .as_ref()
-                        .map(|attr| matches!(attr.kind, AttributeKind::Pub))
-                        .unwrap_or(false);
+                    let is_public = matches!(attribute, &Some(Attribute { kind: AttributeKind::Pub, .. }));
 
                     // check if we're inside a method of the same struct
-                    let in_method = if let Some(fn_kind) = typed_fn_env.current_fn_kind() {
-                        match fn_kind {
-                            FuncOrMethod::Method(method_struct) => {
-                                method_struct.name == struct_name
-                            }
-                            FuncOrMethod::Function(_) => false,
-                        }
-                    } else {
-                        false
-                    };
+                    let in_method = matches!(
+                        typed_fn_env.current_fn_kind(),
+                        FuncOrMethod::Method(method_struct) if method_struct.name == struct_name
+                    );
 
                     if is_public || in_method {
                         // allow access

src/type_checker/fn_env.rs

@@ -39,7 +39,7 @@ impl TypeInfo {
 }
 
 /// The environment we use to type check functions.
-#[derive(Default, Debug, Clone)]
+#[derive(Debug, Clone)]
 pub struct TypedFnEnv {
     /// The current nesting level.
     /// Starting at 0 (top level), and increasing as we go into a block.
@@ -57,13 +57,19 @@ pub struct TypedFnEnv {
     forbid_forloop_scope: bool,
 
     /// The kind of function we're currently type checking
-    current_fn_kind: Option<FuncOrMethod>,
+    current_fn_kind: FuncOrMethod,
 }
 
 impl TypedFnEnv {
-    /// Creates a new TypeEnv
-    pub fn new() -> Self {
-        Self::default()
+    /// Creates a new TypeEnv with the given function kind
+    pub fn new(fn_kind: &FuncOrMethod) -> Self {
+        Self {
+            current_scope: 0,
+            vars: HashMap::new(),
+            forloop_scopes: Vec::new(),
+            forbid_forloop_scope: false,
+            current_fn_kind: fn_kind.clone(),
+        }
     }
 
     /// Enters a scoped block.
@@ -186,11 +192,7 @@ impl TypedFnEnv {
         }
     }
 
-    pub fn current_fn_kind(&self) -> Option<&FuncOrMethod> {
-        self.current_fn_kind.as_ref()
-    }
-
-    pub fn set_current_fn_kind(&mut self, kind: FuncOrMethod) {
-        self.current_fn_kind = Some(kind);
+    pub fn current_fn_kind(&self) -> &FuncOrMethod {
+        &self.current_fn_kind
     }
 }

src/type_checker/mod.rs

@@ -329,9 +329,7 @@ impl<B: Backend> TypeChecker<B> {
                 // `fn main() { ... }`
                 RootKind::FunctionDef(function) => {
                     // create a new typed fn environment to type check the function
-                    let mut typed_fn_env = TypedFnEnv::default();
-
-                    typed_fn_env.set_current_fn_kind(function.sig.kind.clone());
+                    let mut typed_fn_env = TypedFnEnv::new(&function.sig.kind);
 
                     // if we're expecting a library, this should not be the main function
                     let is_main = function.is_main();