Introduce the collection context in the type check context.

sway-core/src/engine_threading.rs

@@ -219,6 +219,12 @@ impl<T: DebugWithEngines> DebugWithEngines for Vec<T> {
     }
 }
 
+impl DebugWithEngines for Span {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>, engines: &Engines) -> fmt::Result {
+        DisplayWithEngines::fmt(self, f, engines)
+    }
+}
+
 pub trait HashWithEngines {
     fn hash<H: Hasher>(&self, state: &mut H, engines: &Engines);
 }

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

@@ -1,7 +1,6 @@
 use crate::{
     engine_threading::*,
     language::{parsed::*, *},
-    namespace::LexicalScopeId,
     transform::{self, AttributeKind},
     type_system::*,
 };
@@ -29,7 +28,6 @@ pub struct FunctionDeclaration {
     pub where_clause: Vec<(Ident, Vec<TraitConstraint>)>,
     pub kind: FunctionDeclarationKind,
     pub implementing_type: Option<Declaration>,
-    pub lexical_scope: LexicalScopeId,
 }
 
 impl EqWithEngines for FunctionDeclaration {}

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

@@ -1,15 +1,10 @@
 use std::hash::{Hash, Hasher};
 
-use sway_error::handler::{ErrorEmitted, Handler};
-use sway_types::Ident;
+use sway_types::{Ident, Named, Spanned};
 
 use crate::{
     engine_threading::*,
     language::{parsed::VariableDeclaration, ty::*},
-    semantic_analysis::{
-        TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckFinalization,
-        TypeCheckFinalizationContext,
-    },
     type_system::*,
 };
 
@@ -26,6 +21,18 @@ impl TyDeclParsedType for TyVariableDecl {
     type ParsedType = VariableDeclaration;
 }
 
+impl Named for TyVariableDecl {
+    fn name(&self) -> &sway_types::BaseIdent {
+        &self.name
+    }
+}
+
+impl Spanned for TyVariableDecl {
+    fn span(&self) -> sway_types::Span {
+        self.name.span()
+    }
+}
+
 impl EqWithEngines for TyVariableDecl {}
 impl PartialEqWithEngines for TyVariableDecl {
     fn eq(&self, other: &Self, ctx: &PartialEqWithEnginesContext) -> bool {
@@ -65,24 +72,3 @@ impl SubstTypes for TyVariableDecl {
         self.body.subst(type_mapping, ctx)
     }
 }
-
-impl TypeCheckAnalysis for TyVariableDecl {
-    fn type_check_analyze(
-        &self,
-        handler: &Handler,
-        ctx: &mut TypeCheckAnalysisContext,
-    ) -> Result<(), ErrorEmitted> {
-        self.body.type_check_analyze(handler, ctx)?;
-        Ok(())
-    }
-}
-
-impl TypeCheckFinalization for TyVariableDecl {
-    fn type_check_finalize(
-        &mut self,
-        handler: &Handler,
-        ctx: &mut TypeCheckFinalizationContext,
-    ) -> Result<(), ErrorEmitted> {
-        self.body.type_check_finalize(handler, ctx)
-    }
-}

sway-core/src/lib.rs

@@ -570,14 +570,15 @@ pub fn parsed_to_ast(
 
     let namespace = Namespace::init_root(initial_namespace);
     // Collect the program symbols.
-    let _collection_ctx =
+    let mut collection_ctx =
         ty::TyProgram::collect(handler, engines, parse_program, namespace.clone())?;
 
     // Type check the program.
     let typed_program_opt = ty::TyProgram::type_check(
         handler,
         engines,
         parse_program,
+        &mut collection_ctx,
         namespace,
         package_name,
         build_config,

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

@@ -11,13 +11,15 @@ impl ty::TyCodeBlock {
         ctx: &mut SymbolCollectionContext,
         code_block: &CodeBlock,
     ) -> Result<(), ErrorEmitted> {
-        let _ = code_block
-            .contents
-            .iter()
-            .map(|node| ty::TyAstNode::collect(handler, engines, ctx, node))
-            .filter_map(|res| res.ok())
-            .collect::<Vec<_>>();
-
+        let _ = ctx.scoped(engines, code_block.whole_block_span.clone(), |scoped_ctx| {
+            let _ = code_block
+                .contents
+                .iter()
+                .map(|node| ty::TyAstNode::collect(handler, engines, scoped_ctx, node))
+                .filter_map(|res| res.ok())
+                .collect::<Vec<_>>();
+            Ok(())
+        });
         Ok(())
     }
 
@@ -28,17 +30,21 @@ impl ty::TyCodeBlock {
         is_root: bool,
     ) -> Result<Self, ErrorEmitted> {
         if !is_root {
-            let code_block_result = ctx.by_ref().scoped(|mut ctx| {
-                let evaluated_contents = code_block
-                    .contents
-                    .iter()
-                    .filter_map(|node| ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok())
-                    .collect::<Vec<ty::TyAstNode>>();
-                Ok(ty::TyCodeBlock {
-                    contents: evaluated_contents,
-                    whole_block_span: code_block.whole_block_span.clone(),
-                })
-            })?;
+            let code_block_result =
+                ctx.by_ref()
+                    .scoped(handler, Some(code_block.span()), |mut ctx| {
+                        let evaluated_contents = code_block
+                            .contents
+                            .iter()
+                            .filter_map(|node| {
+                                ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok()
+                            })
+                            .collect::<Vec<ty::TyAstNode>>();
+                        Ok(ty::TyCodeBlock {
+                            contents: evaluated_contents,
+                            whole_block_span: code_block.whole_block_span.clone(),
+                        })
+                    })?;
 
             return Ok(code_block_result);
         }
@@ -57,7 +63,7 @@ impl ty::TyCodeBlock {
         ctx.by_ref()
             .with_collecting_unifications()
             .with_code_block_first_pass(true)
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(code_block.span()), |mut ctx| {
                 code_block.contents.iter().for_each(|node| {
                     ty::TyAstNode::type_check(&Handler::default(), ctx.by_ref(), node).ok();
                 });
@@ -66,18 +72,19 @@ impl ty::TyCodeBlock {
 
         ctx.engines.te().reapply_unifications(ctx.engines());
 
-        ctx.by_ref().scoped(|mut ctx| {
-            let evaluated_contents = code_block
-                .contents
-                .iter()
-                .filter_map(|node| ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok())
-                .collect::<Vec<ty::TyAstNode>>();
+        ctx.by_ref()
+            .scoped(handler, Some(code_block.span()), |mut ctx| {
+                let evaluated_contents = code_block
+                    .contents
+                    .iter()
+                    .filter_map(|node| ty::TyAstNode::type_check(handler, ctx.by_ref(), node).ok())
+                    .collect::<Vec<ty::TyAstNode>>();
 
-            Ok(ty::TyCodeBlock {
-                contents: evaluated_contents,
-                whole_block_span: code_block.whole_block_span.clone(),
+                Ok(ty::TyCodeBlock {
+                    contents: evaluated_contents,
+                    whole_block_span: code_block.whole_block_span.clone(),
+                })
             })
-        })
     }
 
     pub fn compute_return_type_and_span(

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

@@ -4,14 +4,17 @@ use sway_error::error::CompileError;
 use sway_types::{Ident, Named, Span, Spanned};
 
 use crate::{
-    decl_engine::{DeclEngineGetParsedDeclId, DeclEngineInsert, DeclEngineInsertArc, DeclId},
-    language::ty::TyAbiDecl,
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineGetParsedDeclId, DeclEngineInsert, DeclEngineInsertArc,
+        DeclId,
+    },
+    language::ty::{TyAbiDecl, TyFunctionDecl},
     namespace::{IsExtendingExistingImpl, IsImplSelf, TryInsertingTraitImplOnFailure},
     semantic_analysis::{
-        TypeCheckAnalysis, TypeCheckAnalysisContext, TypeCheckFinalization,
-        TypeCheckFinalizationContext,
+        symbol_collection_context::SymbolCollectionContext, TypeCheckAnalysis,
+        TypeCheckAnalysisContext, TypeCheckFinalization, TypeCheckFinalizationContext,
     },
-    TypeParameter,
+    Engines, TypeParameter,
 };
 use sway_error::handler::{ErrorEmitted, Handler};
 
@@ -29,6 +32,33 @@ use crate::{
 };
 
 impl ty::TyAbiDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<AbiDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let abi_decl = engines.pe().get_abi(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            abi_decl.name.clone(),
+            Declaration::AbiDeclaration(*decl_id),
+        )?;
+
+        let _ = ctx.scoped(engines, abi_decl.span.clone(), |scoped_ctx| {
+            abi_decl.interface_surface.iter().for_each(|item| {
+                let _ = TyTraitItem::collect(handler, engines, scoped_ctx, item);
+            });
+
+            abi_decl.methods.iter().for_each(|decl_id| {
+                let _ = TyFunctionDecl::collect(handler, engines, scoped_ctx, decl_id);
+            });
+            Ok(())
+        });
+        Ok(())
+    }
+
     pub(crate) fn type_check(
         handler: &Handler,
         ctx: TypeCheckContext,
@@ -55,7 +85,7 @@ impl ty::TyAbiDecl {
         // A temporary namespace for checking within this scope.
         ctx.with_abi_mode(AbiMode::ImplAbiFn(name.clone(), None))
             .with_self_type(Some(self_type_id))
-            .scoped(|mut ctx| {
+            .scoped(handler, Some(span.clone()), |mut ctx| {
                 // Insert the "self" type param into the namespace.
                 self_type_param.insert_self_type_into_namespace(handler, ctx.by_ref());
 

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

@@ -324,7 +324,18 @@ where
         assert!(!handler.has_warnings(), "{:?}", handler);
 
         let ctx = self.ctx.by_ref();
-        let r = ctx.scoped_and_namespace(|ctx| {
+        let _r = TyDecl::collect(
+            &handler,
+            engines,
+            ctx.collection_ctx,
+            Declaration::FunctionDeclaration(decl),
+        );
+        if handler.has_errors() {
+            return Err(handler);
+        }
+
+        let ctx = self.ctx.by_ref();
+        let r = ctx.scoped_and_namespace(&handler, None, |ctx| {
             TyDecl::type_check(
                 &handler,
                 ctx,
@@ -375,7 +386,17 @@ where
         assert!(!handler.has_errors(), "{:?}", handler);
 
         let ctx = self.ctx.by_ref();
-        let r = ctx.scoped_and_namespace(|ctx| {
+        let _r = TyDecl::collect(
+            &handler,
+            engines,
+            ctx.collection_ctx,
+            Declaration::ImplSelfOrTrait(decl),
+        );
+        if handler.has_errors() {
+            return Err(handler);
+        }
+
+        let r = ctx.scoped_and_namespace(&handler, None, |ctx| {
             TyDecl::type_check(&handler, ctx, Declaration::ImplSelfOrTrait(decl))
         });
 

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

@@ -6,19 +6,42 @@ use sway_error::{
     warning::{CompileWarning, Warning},
 };
 use sway_types::{style::is_screaming_snake_case, Spanned};
+use symbol_collection_context::SymbolCollectionContext;
 
 use crate::{
-    decl_engine::{DeclEngineGetParsedDeclId, DeclEngineInsert, ReplaceDecls},
+    decl_engine::{
+        parsed_id::ParsedDeclId, DeclEngineGetParsedDeclId, DeclEngineInsert, ReplaceDecls,
+    },
     language::{
         parsed::*,
-        ty::{self, TyConfigurableDecl},
+        ty::{self, TyConfigurableDecl, TyExpression},
         CallPath,
     },
     semantic_analysis::{type_check_context::EnforceTypeArguments, *},
-    SubstTypes, SubstTypesContext, TypeArgument, TypeBinding, TypeCheckTypeBinding, TypeInfo,
+    Engines, SubstTypes, SubstTypesContext, TypeArgument, TypeBinding, TypeCheckTypeBinding,
+    TypeInfo,
 };
 
 impl ty::TyConfigurableDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<ConfigurableDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let configurable_decl = engines.pe().get_configurable(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            configurable_decl.name.clone(),
+            Declaration::ConfigurableDeclaration(*decl_id),
+        )?;
+        if let Some(value) = &configurable_decl.value {
+            TyExpression::collect(handler, engines, ctx, value)?;
+        }
+        Ok(())
+    }
+
     pub fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,

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

@@ -3,18 +3,39 @@ use sway_error::{
     warning::{CompileWarning, Warning},
 };
 use sway_types::{style::is_screaming_snake_case, Spanned};
+use symbol_collection_context::SymbolCollectionContext;
 
 use crate::{
+    decl_engine::parsed_id::ParsedDeclId,
     language::{
         parsed::{self, *},
-        ty::{self, TyConstantDecl},
+        ty::{self, TyConstantDecl, TyExpression},
         CallPath,
     },
     semantic_analysis::{type_check_context::EnforceTypeArguments, *},
     Engines, SubstTypes, SubstTypesContext, TypeInfo,
 };
 
 impl ty::TyConstantDecl {
+    pub(crate) fn collect(
+        handler: &Handler,
+        engines: &Engines,
+        ctx: &mut SymbolCollectionContext,
+        decl_id: &ParsedDeclId<ConstantDeclaration>,
+    ) -> Result<(), ErrorEmitted> {
+        let constant_decl = engines.pe().get_constant(decl_id);
+        ctx.insert_parsed_symbol(
+            handler,
+            engines,
+            constant_decl.name.clone(),
+            Declaration::ConstantDeclaration(*decl_id),
+        )?;
+        if let Some(value) = &constant_decl.value {
+            TyExpression::collect(handler, engines, ctx, value)?;
+        }
+        Ok(())
+    }
+
     pub fn type_check(
         handler: &Handler,
         mut ctx: TypeCheckContext,