Added support for private file-local types

IsaacShelton · IsaacShelton · commit b7d6aba6bf56 · 2025-02-22T23:58:54.000-06:00
diff --git a/src/asg/type_decl.rs b/src/asg/type_decl.rs
@@ -2,13 +2,15 @@ use super::{Asg, TypeKind};
 use crate::{
     ast::{self, Privacy},
     source_files::Source,
+    workspace::fs::FsNodeId,
 };
 
 #[derive(Clone, Debug)]
 pub struct TypeDecl {
     pub kind: TypeKind,
     pub source: Source,
     pub privacy: Privacy,
+    pub file_fs_node_id: FsNodeId,
 }
 
 impl TypeDecl {
diff --git a/src/parser/parse_enum.rs b/src/parser/parse_enum.rs
@@ -20,6 +20,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         for annotation in annotations {
             match annotation.kind {
                 AnnotationKind::Public => privacy = Privacy::Public,
+                AnnotationKind::Private => privacy = Privacy::Private,
                 _ => return Err(self.unexpected_annotation(&annotation, Some("for enum"))),
             }
         }
diff --git a/src/parser/parse_structure.rs b/src/parser/parse_structure.rs
@@ -25,6 +25,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
             match annotation.kind {
                 AnnotationKind::Packed => is_packed = true,
                 AnnotationKind::Public => privacy = Privacy::Public,
+                AnnotationKind::Private => privacy = Privacy::Private,
                 _ => return Err(self.unexpected_annotation(&annotation, Some("for struct"))),
             }
         }
diff --git a/src/parser/parse_trait.rs b/src/parser/parse_trait.rs
@@ -22,6 +22,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {
         for annotation in annotations {
             match annotation.kind {
                 AnnotationKind::Public => privacy = Privacy::Public,
+                AnnotationKind::Private => privacy = Privacy::Private,
                 _ => return Err(self.unexpected_annotation(&annotation, Some("for trait"))),
             }
         }
diff --git a/src/resolve/type_ctx/find.rs b/src/resolve/type_ctx/find.rs
@@ -31,6 +31,10 @@ impl<'a> ResolveTypeCtx<'a> {
                 self.types_in_modules
                     .get(&self.module_fs_node_id)
                     .and_then(|types_in_module| types_in_module.get(name))
+                    .filter(|ty_decl| {
+                        !ty_decl.privacy.is_private()
+                            || self.file_fs_node_id == ty_decl.file_fs_node_id
+                    })
             })
             .filter(|local| local.num_parameters(self.asg) == type_args.len())
             .map(Ok)
diff --git a/src/resolve/type_definition/prepare.rs b/src/resolve/type_definition/prepare.rs
@@ -21,34 +21,55 @@ pub fn prepare_type_jobs(
     let mut type_jobs = Vec::with_capacity(ast_workspace.files.len());
 
     for (physical_file_id, file) in ast_workspace.files.iter() {
-        let module_fs_node_id = ast_workspace.get_owning_module_or_self(*physical_file_id);
+        let physical_file_id = *physical_file_id;
+        let module_fs_node_id = ast_workspace.get_owning_module_or_self(physical_file_id);
 
         let mut job = TypeJob {
-            physical_file_id: *physical_file_id,
+            physical_file_id,
             type_aliases: Vec::with_capacity(file.type_aliases.len()),
             traits: Vec::with_capacity(file.traits.len()),
             structs: Vec::with_capacity(file.structs.len()),
             enums: Vec::with_capacity(file.enums.len()),
         };
 
         for user_trait in file.traits.iter() {
-            job.traits
-                .push(prepare_trait(ctx, asg, module_fs_node_id, user_trait)?);
+            job.traits.push(prepare_trait(
+                ctx,
+                asg,
+                module_fs_node_id,
+                physical_file_id,
+                user_trait,
+            )?);
         }
 
         for structure in file.structs.iter() {
-            job.structs
-                .push(prepare_structure(ctx, asg, module_fs_node_id, structure)?);
+            job.structs.push(prepare_structure(
+                ctx,
+                asg,
+                module_fs_node_id,
+                physical_file_id,
+                structure,
+            )?);
         }
 
         for definition in file.enums.iter() {
-            job.enums
-                .push(prepare_enum(ctx, asg, module_fs_node_id, definition)?);
+            job.enums.push(prepare_enum(
+                ctx,
+                asg,
+                module_fs_node_id,
+                physical_file_id,
+                definition,
+            )?);
         }
 
         for definition in file.type_aliases.iter() {
-            job.type_aliases
-                .push(prepare_type_alias(ctx, asg, module_fs_node_id, definition)?);
+            job.type_aliases.push(prepare_type_alias(
+                ctx,
+                asg,
+                module_fs_node_id,
+                physical_file_id,
+                definition,
+            )?);
         }
 
         type_jobs.push(job);
@@ -61,6 +82,7 @@ fn prepare_structure(
     ctx: &mut ResolveCtx,
     asg: &mut Asg,
     module_fs_node_id: FsNodeId,
+    physical_fs_node_id: FsNodeId,
     structure: &ast::Struct,
 ) -> Result<StructRef, ResolveError> {
     let struct_ref = asg.structs.insert(asg::Struct {
@@ -80,6 +102,7 @@ fn prepare_structure(
     declare_type(
         ctx,
         module_fs_node_id,
+        physical_fs_node_id,
         &structure.name,
         structure.source,
         structure.privacy,
@@ -97,6 +120,7 @@ fn prepare_enum(
     ctx: &mut ResolveCtx,
     asg: &mut Asg,
     module_fs_node_id: FsNodeId,
+    physical_fs_node_id: FsNodeId,
     definition: &ast::Enum,
 ) -> Result<EnumRef, ResolveError> {
     let enum_ref = asg.enums.insert(asg::Enum {
@@ -109,6 +133,7 @@ fn prepare_enum(
     declare_type(
         ctx,
         module_fs_node_id,
+        physical_fs_node_id,
         &definition.name,
         definition.source,
         definition.privacy,
@@ -122,6 +147,7 @@ fn prepare_trait(
     ctx: &mut ResolveCtx,
     asg: &mut Asg,
     module_fs_node_id: FsNodeId,
+    physical_fs_node_id: FsNodeId,
     definition: &ast::Trait,
 ) -> Result<TraitRef, ResolveError> {
     let trait_ref = asg.traits.insert(asg::Trait {
@@ -140,6 +166,7 @@ fn prepare_trait(
     declare_type(
         ctx,
         module_fs_node_id,
+        physical_fs_node_id,
         &definition.name,
         definition.source,
         definition.privacy,
@@ -153,6 +180,7 @@ fn prepare_type_alias(
     ctx: &mut ResolveCtx,
     asg: &mut Asg,
     module_fs_node_id: FsNodeId,
+    physical_fs_node_id: FsNodeId,
     definition: &ast::TypeAlias,
 ) -> Result<TypeAliasRef, ResolveError> {
     let type_alias_ref = asg.type_aliases.insert(asg::TypeAlias {
@@ -171,6 +199,7 @@ fn prepare_type_alias(
     declare_type(
         ctx,
         module_fs_node_id,
+        physical_fs_node_id,
         &definition.name,
         definition.source,
         definition.privacy,
@@ -187,6 +216,7 @@ fn prepare_type_alias(
 fn declare_type(
     ctx: &mut ResolveCtx,
     module_fs_node_id: FsNodeId,
+    physical_fs_node_id: FsNodeId,
     name: &str,
     source: Source,
     privacy: Privacy,
@@ -202,6 +232,7 @@ fn declare_type(
                 kind,
                 source,
                 privacy,
+                file_fs_node_id: physical_fs_node_id,
             },
         )
         .is_some()
diff --git a/tests/error/cannot_use_private_type/_.adept b/tests/error/cannot_use_private_type/_.adept
@@ -0,0 +1,7 @@
+
+pragma => adept("3.0")
+
+func main {
+    name := Name { firstname: c"Isaac" }
+    test()
+}
diff --git a/tests/error/cannot_use_private_type/test.adept b/tests/error/cannot_use_private_type/test.adept
@@ -0,0 +1,15 @@
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+#[private]
+struct Name (firstname ptr#char)
+
+func test {
+    name := Name { firstname: c"John" }
+    name.ptr().greet()
+}
+
+func greet(name ptr#Name) {
+    printf(c"Hello %s\n", name.firstname)
+}
diff --git a/tests/success/private_type/_.adept b/tests/success/private_type/_.adept
@@ -0,0 +1,6 @@
+
+pragma => adept("3.0")
+
+func main {
+    test()
+}
diff --git a/tests/success/private_type/test.adept b/tests/success/private_type/test.adept
@@ -0,0 +1,15 @@
+
+#[foreign]
+func printf(format ptr#char, ...) int
+
+#[private]
+struct Name (firstname ptr#char)
+
+func test {
+    name := Name { firstname: c"John" }
+    name.ptr().greet()
+}
+
+func greet(name ptr#Name) {
+    printf(c"Hello %s\n", name.firstname)
+}

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {`
`20`	`20`	`for annotation in annotations {`
`21`	`21`	`match annotation.kind {`
`22`	`22`	`AnnotationKind::Public => privacy = Privacy::Public,`
	`23`	`+ AnnotationKind::Private => privacy = Privacy::Private,`
`23`	`24`	`_ => return Err(self.unexpected_annotation(&annotation, Some("for enum"))),`
`24`	`25`	`}`
`25`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {`
`25`	`25`	`match annotation.kind {`
`26`	`26`	`AnnotationKind::Packed => is_packed = true,`
`27`	`27`	`AnnotationKind::Public => privacy = Privacy::Public,`
	`28`	`+ AnnotationKind::Private => privacy = Privacy::Private,`
`28`	`29`	`_ => return Err(self.unexpected_annotation(&annotation, Some("for struct"))),`
`29`	`30`	`}`
`30`	`31`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ impl<'a, I: Inflow<Token>> Parser<'a, I> {`
`22`	`22`	`for annotation in annotations {`
`23`	`23`	`match annotation.kind {`
`24`	`24`	`AnnotationKind::Public => privacy = Privacy::Public,`
	`25`	`+ AnnotationKind::Private => privacy = Privacy::Private,`
`25`	`26`	`_ => return Err(self.unexpected_annotation(&annotation, Some("for trait"))),`
`26`	`27`	`}`
`27`	`28`	`}`