Rework visibility level while doing visibility checking.

Author: tritao

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,
         }
     }
 
@@ -158,6 +162,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)]
@@ -175,6 +188,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
@@ -194,6 +211,7 @@ impl<'a> SymbolResolveContext<'a> {
             call_path,
             self.self_type(),
             VisibilityCheck::Yes,
+            self.visibility_level(),
         )
     }
 }

sway-core/src/semantic_analysis/type_check_context.rs

@@ -111,6 +111,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> {
@@ -140,6 +143,7 @@ impl<'a> TypeCheckContext<'a> {
             experimental,
             collecting_unifications: false,
             code_block_first_pass: false,
+            visibility_level: Visibility::Public,
         }
     }
 
@@ -184,6 +188,7 @@ impl<'a> TypeCheckContext<'a> {
             experimental,
             collecting_unifications: false,
             code_block_first_pass: false,
+            visibility_level: Visibility::Public,
         }
     }
 
@@ -215,6 +220,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,
         }
     }
 
@@ -265,6 +271,7 @@ impl<'a> TypeCheckContext<'a> {
                             experimental: ctx.experimental,
                             collecting_unifications: ctx.collecting_unifications,
                             code_block_first_pass: ctx.code_block_first_pass,
+                            visibility_level: ctx.visibility_level,
                         };
                         with_scoped_ctx(&mut ctx)
                     },
@@ -518,6 +525,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
@@ -625,6 +636,7 @@ impl<'a> TypeCheckContext<'a> {
             self.self_type(),
             &self.subst_ctx(),
             VisibilityCheck::Yes,
+            Visibility::Public,
         )
     }
 
@@ -642,6 +654,7 @@ impl<'a> TypeCheckContext<'a> {
             self.self_type(),
             &self.subst_ctx(),
             VisibilityCheck::Yes,
+            self.visibility_level(),
         )
         .map(|d| d.expect_typed())
     }
@@ -660,6 +673,7 @@ impl<'a> TypeCheckContext<'a> {
             &symbol.clone().into(),
             self.self_type(),
             VisibilityCheck::No,
+            Visibility::Public,
         )
         .map(|d| d.expect_typed())
     }
@@ -678,6 +692,7 @@ impl<'a> TypeCheckContext<'a> {
             call_path,
             self.self_type(),
             VisibilityCheck::Yes,
+            self.visibility_level(),
         )
         .map(|d| d.expect_typed())
     }
@@ -696,6 +711,7 @@ impl<'a> TypeCheckContext<'a> {
             call_path,
             self.self_type(),
             VisibilityCheck::No,
+            self.visibility_level(),
         )
         .map(|d| d.expect_typed())
     }
@@ -740,6 +756,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));