Introduce a type check Context. Replaces TypeCheckArguments. (#2004)

* Introduce a type check `Context`. Replaces `TypeCheckArguments`.

* Add missing unknown type annotation. Clean up some formatting.

Also adds some resetting of the help text and type annotation (to
unknown) in many cases to better match the original behaviour. It's
difficult to tell which locations these values were originally used as
placeholders, and which locations they're a necessity for correctness.
This at least appears to fix an issue with expression return type
inference.

* Rename semantic_analysis::Context to TypeCheckContext

* Improve field doc comments for help_text, self_type

* Add doc comment to mode field in TypeCheckContext

* Construct TypeCheckContext at Program level, not module level.

This should help to clarify how we can pass other type check context
(like the declaration and type engines once they're added) through to
the submodules. Previously, this was a little unclear as the
`TypeCheckContext` was only constructed at the module level.

* Add missing namespace field doc comment to TypeCheckContext

* Fix TypeCheckContext constructor in IR test

Author: mitchmindtree

sway-core/src/ir_generation/compile.rs

@@ -1,7 +1,7 @@
 use crate::{
     error::CompileError,
     parse_tree::{Purity, Visibility},
-    semantic_analysis::{ast_node::*, *},
+    semantic_analysis::{ast_node::*, namespace},
 };
 
 use super::{

sway-core/src/ir_generation/function.rs

@@ -10,7 +10,7 @@ use crate::{
 use super::{compile::compile_function, convert::*, lexical_map::LexicalMap, types::*};
 
 use fuel_crypto::Hasher;
-use sway_ir::*;
+use sway_ir::{Context, *};
 use sway_types::{
     ident::Ident,
     span::{Span, Spanned},

sway-core/src/parse_tree/declaration/type_parameter.rs

@@ -68,9 +68,9 @@ impl fmt::Display for TypeParameter {
 
 impl TypeParameter {
     pub(crate) fn type_check(
+        ctx: TypeCheckContext,
         type_parameter: TypeParameter,
-        namespace: &mut Namespace,
-    ) -> CompileResult<TypeParameter> {
+    ) -> CompileResult<Self> {
         let mut warnings = vec![];
         let mut errors = vec![];
         if !type_parameter.trait_constraints.is_empty() {
@@ -87,7 +87,7 @@ impl TypeParameter {
             name: type_parameter.name_ident.clone(),
             type_id,
         };
-        namespace
+        ctx.namespace
             .insert_symbol(type_parameter.name_ident.clone(), type_parameter_decl)
             .ok(&mut warnings, &mut errors);
         let type_parameter = TypeParameter {

sway-core/src/semantic_analysis.rs

@@ -4,10 +4,10 @@ mod module;
 pub mod namespace;
 mod node_dependencies;
 mod program;
-pub(crate) mod type_check_arguments;
+mod type_check_context;
 pub(crate) use ast_node::*;
 pub use ast_node::{TypedConstantDeclaration, TypedDeclaration, TypedFunctionDeclaration};
 pub use module::{TypedModule, TypedSubmodule};
 pub use namespace::Namespace;
 pub use program::{TypedProgram, TypedProgramKind};
-pub use type_check_arguments::*;
+pub(crate) use type_check_context::TypeCheckContext;

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

@@ -1,5 +1,4 @@
 use super::*;
-use crate::semantic_analysis::{ast_node::Mode, TypeCheckArguments};
 use crate::CodeBlock;
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -23,41 +22,24 @@ impl DeterministicallyAborts for TypedCodeBlock {
 
 impl TypedCodeBlock {
     pub(crate) fn type_check(
-        arguments: TypeCheckArguments<'_, CodeBlock>,
+        mut ctx: TypeCheckContext,
+        code_block: CodeBlock,
     ) -> CompileResult<(Self, TypeId)> {
         let mut warnings = Vec::new();
         let mut errors = Vec::new();
 
-        let TypeCheckArguments {
-            checkee: other,
-            namespace,
-            return_type_annotation: type_annotation,
-            help_text,
-            self_type,
-            opts,
-            ..
-        } = arguments;
-
         // Create a temp namespace for checking within the code block scope.
-        let mut code_block_namespace = namespace.clone();
-        let evaluated_contents = other
+        let mut code_block_namespace = ctx.namespace.clone();
+        let evaluated_contents = code_block
             .contents
             .iter()
             .filter_map(|node| {
-                TypedAstNode::type_check(TypeCheckArguments {
-                    checkee: node.clone(),
-                    namespace: &mut code_block_namespace,
-                    return_type_annotation: type_annotation,
-                    help_text,
-                    self_type,
-                    mode: Mode::NonAbi,
-                    opts,
-                })
-                .ok(&mut warnings, &mut errors)
+                let ctx = ctx.by_ref().scoped(&mut code_block_namespace);
+                TypedAstNode::type_check(ctx, node.clone()).ok(&mut warnings, &mut errors)
             })
             .collect::<Vec<TypedAstNode>>();
 
-        let implicit_return_span = other
+        let implicit_return_span = code_block
             .contents
             .iter()
             .find_map(|x| match &x.content {
@@ -81,27 +63,17 @@ impl TypedCodeBlock {
         });
 
         if let Some(return_type) = return_type {
-            let (mut new_warnings, new_errors) = unify_with_self(
-                return_type,
-                type_annotation,
-                self_type,
-                &implicit_return_span.unwrap_or_else(|| other.whole_block_span.clone()),
-                help_text,
-            );
+            let span = implicit_return_span.unwrap_or_else(|| code_block.whole_block_span.clone());
+            let (mut new_warnings, new_errors) = ctx.unify_with_self(return_type, &span);
             warnings.append(&mut new_warnings);
             errors.append(&mut new_errors.into_iter().map(|x| x.into()).collect());
             // The annotation will result in a cast, so set the return type accordingly.
         }
 
-        ok(
-            (
-                TypedCodeBlock {
-                    contents: evaluated_contents,
-                },
-                return_type.unwrap_or_else(|| insert_type(TypeInfo::Tuple(Vec::new()))),
-            ),
-            warnings,
-            errors,
-        )
+        let typed_code_block = TypedCodeBlock {
+            contents: evaluated_contents,
+        };
+        let type_id = return_type.unwrap_or_else(|| insert_type(TypeInfo::Tuple(Vec::new())));
+        ok((typed_code_block, type_id), warnings, errors)
     }
 }

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

@@ -3,9 +3,12 @@ use sway_types::{Ident, Span};
 
 use crate::{
     error::{err, ok},
-    semantic_analysis::ast_node::{type_check_interface_surface, type_check_trait_methods},
+    semantic_analysis::{
+        ast_node::{type_check_interface_surface, type_check_trait_methods},
+        TypeCheckContext,
+    },
     type_engine::{insert_type, AbiName, TypeId},
-    AbiDeclaration, CompileResult, FunctionDeclaration, Namespace, TypeInfo,
+    AbiDeclaration, CompileResult, FunctionDeclaration, TypeInfo,
 };
 
 use super::{CreateTypeId, TypedTraitFn};
@@ -40,10 +43,9 @@ impl CreateTypeId for TypedAbiDeclaration {
 
 impl TypedAbiDeclaration {
     pub(crate) fn type_check(
+        ctx: TypeCheckContext,
         abi_decl: AbiDeclaration,
-        namespace: &mut Namespace,
-        self_type: TypeId,
-    ) -> CompileResult<TypedAbiDeclaration> {
+    ) -> CompileResult<Self> {
         let mut warnings = vec![];
         let mut errors = vec![];
 
@@ -60,15 +62,15 @@ impl TypedAbiDeclaration {
         // so we don't support the case of calling a contract's own interface
         // from itself. This is by design.
         let interface_surface = check!(
-            type_check_interface_surface(interface_surface, namespace),
+            type_check_interface_surface(interface_surface, ctx.namespace),
             return err(warnings, errors),
             warnings,
             errors
         );
         // type check these for errors but don't actually use them yet -- the real
         // ones will be type checked with proper symbols when the ABI is implemented
         let _methods = check!(
-            type_check_trait_methods(methods.clone(), namespace, self_type,),
+            type_check_trait_methods(ctx, methods.clone()),
             vec![],
             warnings,
             errors

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

@@ -78,11 +78,7 @@ impl MonomorphizeHelper for TypedEnumDeclaration {
 }
 
 impl TypedEnumDeclaration {
-    pub fn type_check(
-        decl: EnumDeclaration,
-        namespace: &mut Namespace,
-        self_type: TypeId,
-    ) -> CompileResult<TypedEnumDeclaration> {
+    pub fn type_check(ctx: TypeCheckContext, decl: EnumDeclaration) -> CompileResult<Self> {
         let mut errors = vec![];
         let mut warnings = vec![];
 
@@ -95,14 +91,15 @@ impl TypedEnumDeclaration {
         } = decl;
 
         // create a namespace for the decl, used to create a scope for generics
-        let mut namespace = namespace.clone();
+        let mut decl_namespace = ctx.namespace.clone();
+        let mut ctx = ctx.scoped(&mut decl_namespace);
 
         // type check the type parameters
         // insert them into the namespace
         let mut new_type_parameters = vec![];
         for type_parameter in type_parameters.into_iter() {
             new_type_parameters.push(check!(
-                TypeParameter::type_check(type_parameter, &mut namespace),
+                TypeParameter::type_check(ctx.by_ref(), type_parameter),
                 return err(warnings, errors),
                 warnings,
                 errors
@@ -113,12 +110,7 @@ impl TypedEnumDeclaration {
         let mut variants_buf = vec![];
         for variant in variants {
             variants_buf.push(check!(
-                TypedEnumVariant::type_check(
-                    variant.clone(),
-                    &mut namespace,
-                    self_type,
-                    variant.span,
-                ),
+                TypedEnumVariant::type_check(ctx.by_ref(), variant.clone()),
                 continue,
                 warnings,
                 errors
@@ -216,18 +208,15 @@ impl ReplaceSelfType for TypedEnumVariant {
 
 impl TypedEnumVariant {
     pub(crate) fn type_check(
+        mut ctx: TypeCheckContext,
         variant: EnumVariant,
-        namespace: &mut Namespace,
-        self_type: TypeId,
-        span: Span,
-    ) -> CompileResult<TypedEnumVariant> {
+    ) -> CompileResult<Self> {
         let mut warnings = vec![];
         let mut errors = vec![];
         let enum_variant_type = check!(
-            namespace.resolve_type_with_self(
+            ctx.resolve_type_with_self(
                 insert_type(variant.type_info),
-                self_type,
-                &span,
+                &variant.span,
                 EnforceTypeArguments::Yes
             ),
             insert_type(TypeInfo::ErrorRecovery),

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

@@ -121,19 +121,10 @@ impl ToJsonAbi for TypedFunctionDeclaration {
 }
 
 impl TypedFunctionDeclaration {
-    pub fn type_check(
-        arguments: TypeCheckArguments<'_, FunctionDeclaration>,
-    ) -> CompileResult<TypedFunctionDeclaration> {
+    pub fn type_check(ctx: TypeCheckContext, fn_decl: FunctionDeclaration) -> CompileResult<Self> {
         let mut warnings = Vec::new();
         let mut errors = Vec::new();
-        let TypeCheckArguments {
-            checkee: fn_decl,
-            namespace,
-            self_type,
-            mode,
-            mut opts,
-            ..
-        } = arguments;
+
         let FunctionDeclaration {
             name,
             body,
@@ -147,17 +138,18 @@ impl TypedFunctionDeclaration {
             ..
         } = fn_decl;
         is_snake_case(&name).ok(&mut warnings, &mut errors);
-        opts.purity = purity;
 
         // create a namespace for the function
-        let mut namespace = namespace.clone();
+        let mut fn_namespace = ctx.namespace.clone();
+
+        let mut ctx = ctx.scoped(&mut fn_namespace).with_purity(purity);
 
         // type check the type parameters
         // insert them into the namespace
         let mut new_type_parameters = vec![];
         for type_parameter in type_parameters.into_iter() {
             new_type_parameters.push(check!(
-                TypeParameter::type_check(type_parameter, &mut namespace),
+                TypeParameter::type_check(ctx.by_ref(), type_parameter),
                 return err(warnings, errors),
                 warnings,
                 errors
@@ -169,7 +161,7 @@ impl TypedFunctionDeclaration {
         let mut new_parameters = vec![];
         for parameter in parameters.into_iter() {
             new_parameters.push(check!(
-                TypedFunctionParameter::type_check(parameter, &mut namespace, self_type),
+                TypedFunctionParameter::type_check(ctx.by_ref(), parameter),
                 continue,
                 warnings,
                 errors
@@ -178,9 +170,8 @@ impl TypedFunctionDeclaration {
 
         // type check the return type
         let return_type = check!(
-            namespace.resolve_type_with_self(
+            ctx.resolve_type_with_self(
                 insert_type(return_type),
-                self_type,
                 &return_type_span,
                 EnforceTypeArguments::Yes
             ),
@@ -193,24 +184,21 @@ impl TypedFunctionDeclaration {
         //
         // If there are no implicit block returns, then we do not want to type check them, so we
         // stifle the errors. If there _are_ implicit block returns, we want to type_check them.
-        let (body, _implicit_block_return) = check!(
-            TypedCodeBlock::type_check(TypeCheckArguments {
-                checkee: body,
-                namespace: &mut namespace,
-                return_type_annotation: return_type,
-                help_text:
-                    "Function body's return type does not match up with its return type annotation.",
-                self_type,
-                mode: Mode::NonAbi,
-                opts,
-            }),
-            (
-                TypedCodeBlock { contents: vec![] },
-                insert_type(TypeInfo::ErrorRecovery)
-            ),
-            warnings,
-            errors
-        );
+        let (body, _implicit_block_return) = {
+            let ctx = ctx
+                .by_ref()
+                .with_help_text("Function body's return type does not match up with its return type annotation.")
+                .with_type_annotation(return_type);
+            check!(
+                TypedCodeBlock::type_check(ctx, body),
+                (
+                    TypedCodeBlock { contents: vec![] },
+                    insert_type(TypeInfo::ErrorRecovery)
+                ),
+                warnings,
+                errors
+            )
+        };
 
         // gather the return statements
         let return_statements: Vec<&TypedExpression> = body
@@ -222,13 +210,11 @@ impl TypedFunctionDeclaration {
 
         // unify the types of the return statements with the function return type
         for stmt in return_statements {
-            let (mut new_warnings, new_errors) = unify_with_self(
-                stmt.return_type,
-                return_type,
-                self_type,
-                &stmt.span,
-                "Return statement must return the declared function return type.",
-            );
+            let (mut new_warnings, new_errors) = ctx
+                .by_ref()
+                .with_type_annotation(return_type)
+                .with_help_text("Return statement must return the declared function return type.")
+                .unify_with_self(stmt.return_type, &stmt.span);
             warnings.append(&mut new_warnings);
             errors.append(&mut new_errors.into_iter().map(|x| x.into()).collect());
         }
@@ -243,7 +229,7 @@ impl TypedFunctionDeclaration {
             return_type_span,
             visibility,
             // if this is for a contract, then it is a contract call
-            is_contract_call: mode == Mode::ImplAbiFn,
+            is_contract_call: ctx.mode() == Mode::ImplAbiFn,
             purity,
         };