Rework visibility level while doing visibility checking.

sway-core/src/semantic_analysis/ast_node/expression/typed_expression.rs

@@ -1259,6 +1259,7 @@ impl ty::TyExpression {
             &storage_key_ident.into(),
             None,
             VisibilityCheck::No,
+            Visibility::Public,
         )?;
 
         let storage_key_struct_decl_id = storage_key_decl

sway-core/src/semantic_analysis/symbol_resolve_context.rs

@@ -43,6 +43,8 @@ pub struct SymbolResolveContext<'a> {
     ///
     /// This is `Disallow` everywhere except while checking type parameters bounds in struct instantiation.
     generic_shadowing_mode: GenericShadowingMode,
+    /// Visibility checking level for the current scope.
+    visibility_level: Visibility,
 }
 
 impl<'a> SymbolResolveContext<'a> {
@@ -57,6 +59,7 @@ impl<'a> SymbolResolveContext<'a> {
             self_type: None,
             const_shadowing_mode: ConstShadowingMode::ItemStyle,
             generic_shadowing_mode: GenericShadowingMode::Disallow,
+            visibility_level: Visibility::Public,
         }
     }
 
@@ -75,6 +78,7 @@ impl<'a> SymbolResolveContext<'a> {
             self_type: self.self_type,
             const_shadowing_mode: self.const_shadowing_mode,
             generic_shadowing_mode: self.generic_shadowing_mode,
+            visibility_level: Visibility::Public,
         }
     }
 
@@ -156,6 +160,15 @@ impl<'a> SymbolResolveContext<'a> {
         }
     }
 
+    /// Map this `SymbolResolveContext` instance to a new one with the given visibility level.
+    #[allow(unused)]
+    pub(crate) fn with_visibility_level(self, visibility_level: Visibility) -> Self {
+        Self {
+            visibility_level,
+            ..self
+        }
+    }
+
     // A set of accessor methods. We do this rather than making the fields `pub` in order to ensure
     // that these are only updated via the `with_*` methods that produce a new `SymbolResolveContext`.
     #[allow(unused)]
@@ -173,6 +186,10 @@ impl<'a> SymbolResolveContext<'a> {
         self.generic_shadowing_mode
     }
 
+    pub(crate) fn visibility_level(&self) -> Visibility {
+        self.visibility_level
+    }
+
     /// Get the engines needed for engine threading.
     pub(crate) fn engines(&self) -> &'a Engines {
         self.engines
@@ -192,6 +209,7 @@ impl<'a> SymbolResolveContext<'a> {
             call_path,
             self.self_type(),
             VisibilityCheck::Yes,
+            self.visibility_level(),
         )
     }
 }

sway-core/src/semantic_analysis/type_check_context.rs

@@ -110,6 +110,9 @@ pub struct TypeCheckContext<'a> {
     // In some nested places of the first pass we want to disable the first pass optimizations
     // To disable those optimizations we can set this to false.
     code_block_first_pass: bool,
+
+    /// Visibility checking level for the current scope.
+    visibility_level: Visibility,
 }
 
 impl<'a> TypeCheckContext<'a> {
@@ -139,6 +142,7 @@ impl<'a> TypeCheckContext<'a> {
             experimental,
             collecting_unifications: false,
             code_block_first_pass: false,
+            visibility_level: Visibility::Public,
         }
     }
 
@@ -183,6 +187,7 @@ impl<'a> TypeCheckContext<'a> {
             experimental,
             collecting_unifications: false,
             code_block_first_pass: false,
+            visibility_level: Visibility::Public,
         }
     }
 
@@ -214,6 +219,7 @@ impl<'a> TypeCheckContext<'a> {
             experimental: self.experimental,
             collecting_unifications: self.collecting_unifications,
             code_block_first_pass: self.code_block_first_pass,
+            visibility_level: self.visibility_level,
         }
     }
 
@@ -251,6 +257,7 @@ impl<'a> TypeCheckContext<'a> {
                         experimental: self.experimental,
                         collecting_unifications: self.collecting_unifications,
                         code_block_first_pass: self.code_block_first_pass,
+                        visibility_level: self.visibility_level,
                     };
                     with_scoped_ctx(ctx)
                 },
@@ -275,6 +282,7 @@ impl<'a> TypeCheckContext<'a> {
                 experimental: self.experimental,
                 collecting_unifications: self.collecting_unifications,
                 code_block_first_pass: self.code_block_first_pass,
+                visibility_level: self.visibility_level,
             };
             with_scoped_ctx(ctx)
         }
@@ -315,6 +323,7 @@ impl<'a> TypeCheckContext<'a> {
                         experimental: self.experimental,
                         collecting_unifications: self.collecting_unifications,
                         code_block_first_pass: self.code_block_first_pass,
+                        visibility_level: self.visibility_level,
                     };
                     Ok((with_scoped_ctx(ctx)?, namespace))
                 },
@@ -339,6 +348,7 @@ impl<'a> TypeCheckContext<'a> {
                 experimental: self.experimental,
                 collecting_unifications: self.collecting_unifications,
                 code_block_first_pass: self.code_block_first_pass,
+                visibility_level: self.visibility_level,
             };
             Ok((with_scoped_ctx(ctx)?, namespace))
         }
@@ -565,6 +575,10 @@ impl<'a> TypeCheckContext<'a> {
         self.code_block_first_pass
     }
 
+    pub(crate) fn visibility_level(&self) -> Visibility {
+        self.visibility_level
+    }
+
     /// Get the engines needed for engine threading.
     pub(crate) fn engines(&self) -> &'a Engines {
         self.engines
@@ -672,6 +686,7 @@ impl<'a> TypeCheckContext<'a> {
             self.self_type(),
             &self.subst_ctx(),
             VisibilityCheck::Yes,
+            Visibility::Public,
         )
     }
 
@@ -689,6 +704,7 @@ impl<'a> TypeCheckContext<'a> {
             self.self_type(),
             &self.subst_ctx(),
             VisibilityCheck::Yes,
+            self.visibility_level(),
         )
         .map(|d| d.expect_typed())
     }
@@ -707,6 +723,7 @@ impl<'a> TypeCheckContext<'a> {
             &symbol.clone().into(),
             self.self_type(),
             VisibilityCheck::No,
+            Visibility::Public,
         )
         .map(|d| d.expect_typed())
     }
@@ -725,6 +742,7 @@ impl<'a> TypeCheckContext<'a> {
             call_path,
             self.self_type(),
             VisibilityCheck::Yes,
+            self.visibility_level(),
         )
         .map(|d| d.expect_typed())
     }
@@ -743,6 +761,7 @@ impl<'a> TypeCheckContext<'a> {
             call_path,
             self.self_type(),
             VisibilityCheck::No,
+            self.visibility_level(),
         )
         .map(|d| d.expect_typed())
     }
@@ -789,6 +808,7 @@ impl<'a> TypeCheckContext<'a> {
             self.self_type(),
             &self.subst_ctx(),
             VisibilityCheck::Yes,
+            Visibility::Public,
         )
         .unwrap_or_else(|err| type_engine.id_of_error_recovery(err));