Add pub attribute for struct fields

examples/assignment.no

@@ -1,5 +1,5 @@
 struct Thing {
-    xx: Field,
+    pub xx: Field,
 }
 
 fn try_to_mutate(thing: Thing) {

examples/types.no

@@ -1,6 +1,6 @@
 struct Thing {
-    xx: Field,
-    yy: Field,
+    pub xx: Field,
+    pub yy: Field,
 }
 
 fn main(pub xx: Field, pub yy: Field) {

examples/types_array.no

@@ -1,6 +1,6 @@
 struct Thing {
-    xx: Field,
-    yy: Field,
+    pub xx: Field,
+    pub yy: Field,
 }
 
 fn main(pub xx: Field, pub yy: Field) {

examples/types_array_output.no

@@ -1,6 +1,6 @@
 struct Thing {
-    xx: Field,
-    yy: Field,
+    pub xx: Field,
+    pub yy: Field,
 }
 
 fn main(pub xx: Field, pub yy: Field) -> [Thing; 2] {

src/circuit_writer/writer.rs

@@ -320,7 +320,7 @@ impl<B: Backend> CircuitWriter<B> {
                     .clone();
 
                 let mut offset = 0;
-                for (_field_name, field_typ) in &struct_info.fields {
+                for (_field_name, field_typ, _attribute) in &struct_info.fields {
                     let len = self.size_of(field_typ);
                     let range = offset..(offset + len);
                     self.constrain_inputs_to_main(&input[range], field_typ, span)?;
@@ -473,7 +473,7 @@ impl<B: Backend> CircuitWriter<B> {
                 // find range of field
                 let mut start = 0;
                 let mut len = 0;
-                for (field, field_typ) in &struct_info.fields {
+                for (field, field_typ, _attribute) in &struct_info.fields {
                     if field == &rhs.value {
                         len = self.size_of(field_typ);
                         break;

src/error.rs

@@ -362,4 +362,7 @@ pub enum ErrorKind {
 
     #[error("division by zero")]
     DivisionByZero,
+
+    #[error("cannot access private field `{1}` of struct `{0}` from outside its methods.")]
+    PrivateFieldAccess(String, String),
 }

src/inputs.rs

@@ -140,7 +140,7 @@ impl<B: Backend> CompiledCircuit<B> {
 
                 // parse each field
                 let mut res = vec![];
-                for (field_name, field_ty) in fields {
+                for (field_name, field_ty, attribute) in fields {
                     let value = map.remove(field_name).ok_or_else(|| {
                         ParsingError::MissingStructFieldIdent(field_name.to_string())
                     })?;

src/mast/mod.rs

@@ -446,7 +446,7 @@ impl<B: Backend> Mast<B> {
 
                 let mut sum = 0;
 
-                for (_, t) in &struct_info.fields {
+                for (_, t, _) in &struct_info.fields {
                     sum += self.size_of(t);
                 }
 
@@ -548,8 +548,8 @@ fn monomorphize_expr<B: Backend>(
             let typ = struct_info
                 .fields
                 .iter()
-                .find(|(name, _)| name == &rhs.value)
-                .map(|(_, typ)| typ.clone());
+                .find(|(name, _, _)| name == &rhs.value)
+                .map(|(_, typ, _)| typ.clone());
 
             let mexpr = expr.to_mast(
                 ctx,

src/name_resolution/context.rs

@@ -150,7 +150,7 @@ impl NameResCtx {
         self.resolve(module, true)?;
 
         // we resolve the fully-qualified types of the fields
-        for (_field_name, field_typ) in fields {
+        for (_field_name, field_typ, attribute) in fields {
             self.resolve_typ_kind(&mut field_typ.kind)?;
         }
 

src/negative_tests.rs

@@ -700,7 +700,7 @@ fn test_nonhint_call_with_unsafe() {
 fn test_no_cst_struct_field_prop() {
     let code = r#"
     struct Thing {
-        val: Field,
+        pub val: Field,
     }
 
     fn gen(const LEN: Field) -> [Field; LEN] {
@@ -725,7 +725,7 @@ fn test_no_cst_struct_field_prop() {
 fn test_mut_cst_struct_field_prop() {
     let code = r#"
     struct Thing {
-        val: Field,
+        pub val: Field,
     }
 
     fn gen(const LEN: Field) -> [Field; LEN] {
@@ -747,3 +747,30 @@ fn test_mut_cst_struct_field_prop() {
         ErrorKind::ArgumentTypeMismatch(..)
     ));
 }
+
+#[test]
+fn test_private_field_access() {
+    let code = r#"
+    struct Room {
+        pub beds: Field, // public
+            size: Field // private
+    }
+
+    fn Room.access_size(self) {
+        let room2 = Room {beds: self.beds, size: self.size};
+    }
+
+    fn main(pub beds: Field) {
+        let mut room = Room {beds: 2, size: 10};
+        room.beds = beds; // allowed
+        room.size = 5; // not allowed
+        room.access_size(); // allowed
+    }
+    "#;
+
+    let res = tast_pass(code).0;
+    assert!(matches!(
+        res.unwrap_err().kind,
+        ErrorKind::PrivateFieldAccess(..)
+    ));
+}

src/parser/structs.rs

@@ -3,12 +3,12 @@ use serde::{Deserialize, Serialize};
 use crate::{
     constants::Span,
     error::{ErrorKind, Result},
-    lexer::{Token, TokenKind, Tokens},
+    lexer::{Keyword, Token, TokenKind, Tokens},
     syntax::is_type,
 };
 
 use super::{
-    types::{Ident, ModulePath, Ty, TyKind},
+    types::{Attribute, AttributeKind, Ident, ModulePath, Ty, TyKind},
     Error, ParserCtx,
 };
 
@@ -17,7 +17,7 @@ pub struct StructDef {
     //pub attribute: Attribute,
     pub module: ModulePath, // name resolution
     pub name: CustomType,
-    pub fields: Vec<(Ident, Ty)>,
+    pub fields: Vec<(Ident, Ty, Option<Attribute>)>,
     pub span: Span,
 }
 
@@ -55,6 +55,26 @@ impl StructDef {
                 tokens.bump(ctx);
                 break;
             }
+
+            // check for pub keyword
+            // struct Foo { pub a: Field, b: Field }
+            //              ^
+            let attribute = if matches!(
+                tokens.peek(),
+                Some(Token {
+                    kind: TokenKind::Keyword(Keyword::Pub),
+                    ..
+                })
+            ) {
+                tokens.bump(ctx);
+                Some(Attribute {
+                    kind: AttributeKind::Pub,
+                    span: ctx.last_span(),
+                })
+            } else {
+                None
+            };
+
             // struct Foo { a: Field, b: Field }
             //              ^
             let field_name = Ident::parse(ctx, tokens)?;
@@ -67,7 +87,7 @@ impl StructDef {
             //                 ^^^^^
             let field_ty = Ty::parse(ctx, tokens)?;
             span = span.merge_with(field_ty.span);
-            fields.push((field_name, field_ty));
+            fields.push((field_name, field_ty, attribute));
 
             // struct Foo { a: Field, b: Field }
             //                      ^          ^

src/stdlib/native/int/lib.no

@@ -8,7 +8,7 @@ hint fn divmod(dividend: Field, divisor: Field) -> [Field; 2];
 // u8
 // must use new() to create a Uint8, so the value is range checked
 struct Uint8 {
-    inner: Field,
+    pub inner: Field,
 }
 
 fn Uint8.new(val: Field) -> Uint8 {

src/tests/modules.rs

@@ -31,7 +31,7 @@ use mimoo::liblib;
 
 // test a library's type that links to its own type
 struct Inner {
-    inner: Field,
+    pub inner: Field,
 }
 
 struct Lib {

src/type_checker/checker.rs

@@ -10,7 +10,8 @@ use crate::{
     imports::FnKind,
     parser::{
         types::{
-            is_numeric, FnSig, ForLoopArgument, FunctionDef, Stmt, StmtKind, Symbolic, Ty, TyKind,
+            is_numeric, Attribute, AttributeKind, FnSig, ForLoopArgument, FuncOrMethod,
+            FunctionDef, Stmt, StmtKind, Symbolic, Ty, TyKind,
         },
         CustomType, Expr, ExprKind, Op2,
     },
@@ -55,7 +56,7 @@ impl<B: Backend> FnInfo<B> {
 #[derive(Deserialize, Serialize, Default, Debug, Clone)]
 pub struct StructInfo {
     pub name: String,
-    pub fields: Vec<(String, TyKind)>,
+    pub fields: Vec<(String, TyKind, Option<Attribute>)>,
     pub methods: HashMap<String, FunctionDef>,
 }
 
@@ -116,14 +117,37 @@ impl<B: Backend> TypeChecker<B> {
                     .expect("this struct is not defined, or you're trying to access a field of a struct defined in a third-party library (TODO: better error)");
 
                 // find field type
-                let res = struct_info
+                if let Some((_, field_typ, attribute)) = struct_info
                     .fields
                     .iter()
-                    .find(|(name, _)| name == &rhs.value)
-                    .map(|(_, typ)| typ.clone());
+                    .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);
+
+                    // 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
+                    };
 
-                if let Some(res) = res {
-                    Some(ExprTyInfo::new(lhs_node.var_name, res))
+                    if is_public || in_method {
+                        // allow access
+                        Some(ExprTyInfo::new(lhs_node.var_name, field_typ.clone()))
+                    } else {
+                        // block access
+                        Err(self.error(
+                            ErrorKind::PrivateFieldAccess(struct_name.clone(), rhs.value.clone()),
+                            expr.span,
+                        ))?
+                    }
                 } else {
                     return Err(self.error(
                         ErrorKind::UndefinedField(struct_info.name.clone(), rhs.value.clone()),

src/type_checker/fn_env.rs

@@ -5,7 +5,7 @@ use std::collections::HashMap;
 use crate::{
     constants::Span,
     error::{Error, ErrorKind, Result},
-    parser::types::TyKind,
+    parser::types::{FuncOrMethod, TyKind},
 };
 
 /// Some type information on local variables that we want to track in the [TypedFnEnv] environment.
@@ -55,6 +55,9 @@ pub struct TypedFnEnv {
 
     /// Determines if forloop variables are allowed to be accessed.
     forbid_forloop_scope: bool,
+
+    /// The kind of function we're currently type checking
+    current_fn_kind: Option<FuncOrMethod>,
 }
 
 impl TypedFnEnv {
@@ -182,4 +185,12 @@ impl TypedFnEnv {
             Ok(None)
         }
     }
+
+    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);
+    }
 }

src/type_checker/mod.rs

@@ -298,8 +298,8 @@ impl<B: Backend> TypeChecker<B> {
                     let fields: Vec<_> = fields
                         .iter()
                         .map(|field| {
-                            let (name, typ) = field;
-                            (name.value.clone(), typ.kind.clone())
+                            let (name, typ, attribute) = field;
+                            (name.value.clone(), typ.kind.clone(), attribute.clone())
                         })
                         .collect();
 
@@ -331,6 +331,8 @@ impl<B: Backend> TypeChecker<B> {
                     // 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());
+
                     // if we're expecting a library, this should not be the main function
                     let is_main = function.is_main();
                     if is_main && is_lib {