Accumulate typechecking methods in impl TypeCheckContext, part 2

sway-core/src/language/ty/declaration/enum.rs

@@ -12,6 +12,7 @@ use sway_types::{Ident, Named, Span, Spanned};
 use crate::{
     engine_threading::*,
     language::{CallPath, Visibility},
+    semantic_analysis::type_check_context::MonomorphizeHelper,
     transform,
     type_system::*,
 };

sway-core/src/language/ty/declaration/function.rs

@@ -6,6 +6,8 @@ use std::{
 use sha2::{Digest, Sha256};
 use sway_error::handler::{ErrorEmitted, Handler};
 
+use crate::semantic_analysis::type_check_context::MonomorphizeHelper;
+
 use crate::{
     decl_engine::*,
     engine_threading::*,

sway-core/src/language/ty/declaration/struct.rs

@@ -12,6 +12,7 @@ use sway_types::{Ident, Named, Span, Spanned};
 use crate::{
     engine_threading::*,
     language::{CallPath, Visibility},
+    semantic_analysis::type_check_context::MonomorphizeHelper,
     transform,
     type_system::*,
 };

sway-core/src/language/ty/declaration/trait.rs

@@ -8,6 +8,7 @@ use crate::{
     },
     engine_threading::*,
     language::{parsed, Visibility},
+    semantic_analysis::type_check_context::MonomorphizeHelper,
     transform,
     type_system::*,
 };

sway-core/src/language/ty/declaration/trait_fn.rs

@@ -5,6 +5,7 @@ use sway_types::{Ident, Named, Span, Spanned};
 use crate::{
     engine_threading::*,
     language::{ty::*, Purity},
+    semantic_analysis::type_check_context::MonomorphizeHelper,
     transform,
     type_system::*,
 };

sway-core/src/language/ty/expression/expression_variant.rs

@@ -940,8 +940,7 @@ impl ReplaceDecls for TyExpressionVariant {
                     for type_param in method.type_parameters.iter() {
                         let TypeParameter { type_id, .. } = type_param;
 
-                        ctx.namespace
-                            .insert_trait_implementation_for_type(engines, *type_id);
+                        ctx.insert_trait_implementation_for_type(*type_id);
                     }
 
                     // Handle the trait constraints. This includes checking to see if the trait

sway-core/src/semantic_analysis.rs

@@ -6,7 +6,7 @@ mod module;
 pub mod namespace;
 mod node_dependencies;
 mod program;
-mod type_check_context;
+pub(crate) mod type_check_context;
 pub use ast_node::*;
 pub use namespace::Namespace;
 pub(crate) use type_check_context::TypeCheckContext;

sway-core/src/semantic_analysis/ast_node/declaration/constant.rs

@@ -10,8 +10,8 @@ use crate::{
         ty::{self, TyConstantDecl},
         CallPath,
     },
-    semantic_analysis::*,
-    EnforceTypeArguments, Engines, TypeInfo,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
+    Engines, TypeInfo,
 };
 
 impl ty::TyConstantDecl {

sway-core/src/semantic_analysis/ast_node/declaration/declaration.rs

@@ -4,7 +4,7 @@ use sway_types::{Named, Spanned};
 use crate::{
     decl_engine::{DeclEngineInsert, DeclRef, ReplaceFunctionImplementingType},
     language::{parsed, ty},
-    semantic_analysis::TypeCheckContext,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
     type_system::*,
 };
 

sway-core/src/semantic_analysis/ast_node/declaration/enum.rs

@@ -2,7 +2,7 @@ use sway_error::handler::{ErrorEmitted, Handler};
 
 use crate::{
     language::{parsed::*, ty, CallPath},
-    semantic_analysis::*,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
     type_system::*,
 };
 

sway-core/src/semantic_analysis/ast_node/declaration/function.rs

@@ -13,7 +13,7 @@ use crate::{
         ty::{self, TyCodeBlock},
         Visibility,
     },
-    semantic_analysis::*,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
     type_system::*,
 };
 use sway_types::{style::is_snake_case, Spanned};

sway-core/src/semantic_analysis/ast_node/declaration/function/function_parameter.rs

@@ -1,6 +1,6 @@
 use crate::{
     language::{parsed::FunctionParameter, ty},
-    semantic_analysis::TypeCheckContext,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
     type_system::*,
 };
 

sway-core/src/semantic_analysis/ast_node/declaration/impl_trait.rs

@@ -15,7 +15,9 @@ use crate::{
         *,
     },
     namespace::TryInsertingTraitImplOnFailure,
-    semantic_analysis::{AbiMode, ConstShadowingMode, TypeCheckContext},
+    semantic_analysis::{
+        type_check_context::EnforceTypeArguments, AbiMode, ConstShadowingMode, TypeCheckContext,
+    },
     type_system::*,
 };
 

sway-core/src/semantic_analysis/ast_node/declaration/struct.rs

@@ -2,7 +2,7 @@ use sway_error::handler::{ErrorEmitted, Handler};
 
 use crate::{
     language::{parsed::*, ty, CallPath},
-    semantic_analysis::*,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
     type_system::*,
 };
 

sway-core/src/semantic_analysis/ast_node/declaration/supertrait.rs

@@ -2,10 +2,11 @@ use sway_error::error::CompileError;
 use sway_error::handler::{ErrorEmitted, Handler};
 use sway_types::{Span, Spanned};
 
+use crate::semantic_analysis::type_check_context::EnforceTypeArguments;
 use crate::{
     language::{parsed, ty},
     semantic_analysis::TypeCheckContext,
-    EnforceTypeArguments, TypeId,
+    TypeId,
 };
 
 #[derive(Clone, PartialEq, Eq)]

sway-core/src/semantic_analysis/ast_node/declaration/trait_fn.rs

@@ -3,6 +3,7 @@ use sway_types::{Span, Spanned};
 use crate::{
     decl_engine::DeclId,
     language::{parsed, ty, Visibility},
+    semantic_analysis::type_check_context::EnforceTypeArguments,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
 

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

@@ -9,7 +9,7 @@ use sway_types::Span;
 use crate::{
     engine_threading::*,
     language::{parsed::Expression, ty},
-    semantic_analysis::TypeCheckContext,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
     type_system::*,
 };
 

sway-core/src/semantic_analysis/ast_node/expression/match_expression/typed/typed_scrutinee.rs

@@ -11,7 +11,7 @@ use crate::{
         ty::{self, TyDecl},
         CallPath,
     },
-    semantic_analysis::TypeCheckContext,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
     type_system::*,
 };
 

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

@@ -25,7 +25,7 @@ use crate::{
         ty::{self, TyImplItem},
         *,
     },
-    semantic_analysis::{expression::ReachableReport, *},
+    semantic_analysis::{expression::ReachableReport, type_check_context::EnforceTypeArguments, *},
     transform::to_parsed_lang::type_name_to_type_info_opt,
     type_system::*,
     Engines,
@@ -1009,8 +1009,7 @@ impl ty::TyExpression {
 
         // take any trait items that apply to `StorageKey<T>` and copy them to the
         // monomorphized type
-        ctx.namespace
-            .insert_trait_implementation_for_type(engines, access_type);
+        ctx.insert_trait_implementation_for_type(access_type);
 
         Ok(ty::TyExpression {
             expression: ty::TyExpressionVariant::StorageAccess(storage_access),

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

@@ -17,7 +17,6 @@ pub(crate) fn instantiate_function_application(
     span: Span,
 ) -> Result<ty::TyExpression, ErrorEmitted> {
     let decl_engine = ctx.engines.de();
-    let engines = ctx.engines();
 
     let mut function_decl = decl_engine.get_function(&function_decl_ref);
 
@@ -59,8 +58,7 @@ pub(crate) fn instantiate_function_application(
 
     // Retrieve the implemented traits for the type of the return type and
     // insert them in the broader namespace.
-    ctx.namespace
-        .insert_trait_implementation_for_type(engines, function_decl.return_type.type_id);
+    ctx.insert_trait_implementation_for_type(function_decl.return_type.type_id);
 
     // Handle the trait constraints. This includes checking to see if the trait
     // constraints are satisfied and replacing old decl ids based on the

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

@@ -2,7 +2,7 @@ use crate::{
     decl_engine::{DeclEngineInsert, DeclRefFunction, ReplaceDecls, UpdateConstantExpression},
     language::{parsed::*, ty, *},
     namespace::TryInsertingTraitImplOnFailure,
-    semantic_analysis::*,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, *},
     type_system::*,
 };
 use ast_node::typed_expression::check_function_arguments_arity;
@@ -325,8 +325,7 @@ pub(crate) fn type_check_method_application(
 
     // Retrieve the implemented traits for the type of the return type and
     // insert them in the broader namespace.
-    ctx.namespace
-        .insert_trait_implementation_for_type(engines, method.return_type.type_id);
+    ctx.insert_trait_implementation_for_type(method.return_type.type_id);
 
     // Handle the trait constraints. This includes checking to see if the trait
     // constraints are satisfied and replacing old decl ids based on the

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

@@ -7,7 +7,7 @@ use sway_types::{Ident, Span, Spanned};
 use crate::{
     decl_engine::DeclRefStruct,
     language::{parsed::*, ty, CallPath},
-    semantic_analysis::TypeCheckContext,
+    semantic_analysis::{type_check_context::EnforceTypeArguments, TypeCheckContext},
     type_system::*,
 };
 

sway-core/src/semantic_analysis/namespace/items.rs

@@ -252,14 +252,6 @@ impl Items {
             })
     }
 
-    pub(crate) fn insert_trait_implementation_for_type(
-        &mut self,
-        engines: &Engines,
-        type_id: TypeId,
-    ) {
-        self.implemented_traits.insert_for_type(engines, type_id);
-    }
-
     pub fn get_items_for_type(&self, engines: &Engines, type_id: TypeId) -> Vec<ty::TyTraitItem> {
         self.implemented_traits.get_items_for_type(engines, type_id)
     }

sway-core/src/semantic_analysis/namespace/root.rs

@@ -1,13 +1,8 @@
-use sway_error::{
-    error::CompileError,
-    handler::{ErrorEmitted, Handler},
-};
-use sway_types::Spanned;
-use sway_utils::iter_prefixes;
+use sway_error::handler::{ErrorEmitted, Handler};
 
 use crate::{
     language::{ty, CallPath},
-    Engines, Ident,
+    Ident,
 };
 
 use super::{module::Module, namespace::Namespace, Path};
@@ -44,52 +39,6 @@ impl Root {
         self.resolve_symbol(handler, &symbol_path, &call_path.suffix)
     }
 
-    /// Resolve a symbol that is potentially prefixed with some path, e.g. `foo::bar::symbol`.
-    ///
-    /// This will concatenate the `mod_path` with the `call_path`'s prefixes and
-    /// then calling `resolve_symbol` with the resulting path and call_path's suffix.
-    ///
-    /// The `mod_path` is significant here as we assume the resolution is done within the
-    /// context of the module pointed to by `mod_path` and will only check the call path prefixes
-    /// and the symbol's own visibility
-    pub(crate) fn resolve_call_path_with_visibility_check(
-        &self,
-        handler: &Handler,
-        engines: &Engines,
-        mod_path: &Path,
-        call_path: &CallPath,
-    ) -> Result<&ty::TyDecl, ErrorEmitted> {
-        let decl = self.resolve_call_path(handler, mod_path, call_path)?;
-
-        // In case there are no prefixes we don't need to check visibility
-        if call_path.prefixes.is_empty() {
-            return Ok(decl);
-        }
-
-        // check the visibility of the call path elements
-        // we don't check the first prefix because direct children are always accessible
-        for prefix in iter_prefixes(&call_path.prefixes).skip(1) {
-            let module = self.check_submodule(handler, prefix)?;
-            if module.visibility.is_private() {
-                let prefix_last = prefix[prefix.len() - 1].clone();
-                handler.emit_err(CompileError::ImportPrivateModule {
-                    span: prefix_last.span(),
-                    name: prefix_last,
-                });
-            }
-        }
-
-        // check the visibility of the symbol itself
-        if !decl.visibility(engines.de()).is_public() {
-            handler.emit_err(CompileError::ImportPrivateSymbol {
-                name: call_path.suffix.clone(),
-                span: call_path.suffix.span(),
-            });
-        }
-
-        Ok(decl)
-    }
-
     /// Given a path to a module and the identifier of a symbol within that module, resolve its
     /// declaration.
     ///