@@ -22,7 +22,7 @@ use cairo_lang_filesystem::ids::{FileKind, FileLongId, VirtualFile};
2222use cairo_lang_proc_macros:: DebugWithDb ;
2323use cairo_lang_syntax:: node:: ast:: {
2424 BinaryOperator , BlockOrIf , ClosureParamWrapper , ExprPtr , OptionReturnTypeClause , PatternListOr ,
25- PatternStructParam , UnaryOperator ,
25+ PatternStructParam , TerminalIdentifier , UnaryOperator ,
2626} ;
2727use cairo_lang_syntax:: node:: db:: SyntaxGroup ;
2828use cairo_lang_syntax:: node:: helpers:: { GetIdentifier , PathSegmentEx } ;
@@ -66,7 +66,7 @@ use crate::expr::inference::{ImplVarTraitItemMappings, InferenceId};
6666use crate :: items:: constant:: { ConstValue , resolve_const_expr_and_evaluate, validate_const_expr} ;
6767use crate :: items:: enm:: SemanticEnumEx ;
6868use crate :: items:: feature_kind:: extract_item_feature_config;
69- use crate :: items:: functions:: function_signature_params;
69+ use crate :: items:: functions:: { concrete_function_closure_params , function_signature_params} ;
7070use crate :: items:: imp:: { ImplLookupContext , filter_candidate_traits, infer_impl_by_self} ;
7171use crate :: items:: modifiers:: compute_mutability;
7272use crate :: items:: us:: get_use_path_segments;
@@ -424,7 +424,7 @@ pub fn maybe_compute_expr_semantic(
424424 ast:: Expr :: Indexed ( expr) => compute_expr_indexed_semantic ( ctx, expr) ,
425425 ast:: Expr :: FixedSizeArray ( expr) => compute_expr_fixed_size_array_semantic ( ctx, expr) ,
426426 ast:: Expr :: For ( expr) => compute_expr_for_semantic ( ctx, expr) ,
427- ast:: Expr :: Closure ( expr) => compute_expr_closure_semantic ( ctx, expr) ,
427+ ast:: Expr :: Closure ( expr) => compute_expr_closure_semantic ( ctx, expr, None ) ,
428428 }
429429}
430430
@@ -882,7 +882,7 @@ fn compute_expr_function_call_semantic(
882882 let mut arg_types = vec ! [ ] ;
883883 for arg_syntax in args_iter {
884884 let stable_ptr = arg_syntax. stable_ptr ( ) ;
885- let arg = compute_named_argument_clause ( ctx, arg_syntax) ;
885+ let arg = compute_named_argument_clause ( ctx, arg_syntax, None ) ;
886886 if arg. 2 != Mutability :: Immutable {
887887 return Err ( ctx. diagnostics . report ( stable_ptr, RefClosureArgument ) ) ;
888888 }
@@ -930,7 +930,7 @@ fn compute_expr_function_call_semantic(
930930 let named_args: Vec < _ > = args_syntax
931931 . elements ( syntax_db)
932932 . into_iter ( )
933- . map ( |arg_syntax| compute_named_argument_clause ( ctx, arg_syntax) )
933+ . map ( |arg_syntax| compute_named_argument_clause ( ctx, arg_syntax, None ) )
934934 . collect ( ) ;
935935 if named_args. len ( ) != 1 {
936936 return Err ( ctx. diagnostics . report ( syntax, WrongNumberOfArguments {
@@ -979,16 +979,21 @@ fn compute_expr_function_call_semantic(
979979 let mut args_iter = args_syntax. elements ( syntax_db) . into_iter ( ) ;
980980 // Normal parameters
981981 let mut named_args = vec ! [ ] ;
982- for _ in function_parameter_types ( ctx, function) ? {
982+ let closure_params = concrete_function_closure_params ( db, function) ?;
983+ for ty in function_parameter_types ( ctx, function) ? {
983984 let Some ( arg_syntax) = args_iter. next ( ) else {
984985 continue ;
985986 } ;
986- named_args. push ( compute_named_argument_clause ( ctx, arg_syntax) ) ;
987+ named_args. push ( compute_named_argument_clause (
988+ ctx,
989+ arg_syntax,
990+ closure_params. get ( & ty) . cloned ( ) ,
991+ ) ) ;
987992 }
988993
989994 // Maybe coupon
990995 if let Some ( arg_syntax) = args_iter. next ( ) {
991- named_args. push ( compute_named_argument_clause ( ctx, arg_syntax) ) ;
996+ named_args. push ( compute_named_argument_clause ( ctx, arg_syntax, None ) ) ;
992997 }
993998
994999 expr_function_call ( ctx, function, named_args, syntax, syntax. stable_ptr ( ) . into ( ) )
@@ -1006,6 +1011,7 @@ fn compute_expr_function_call_semantic(
10061011pub fn compute_named_argument_clause (
10071012 ctx : & mut ComputationContext < ' _ > ,
10081013 arg_syntax : ast:: Arg ,
1014+ closure_param_types : Option < TypeId > ,
10091015) -> NamedArg {
10101016 let syntax_db = ctx. db . upcast ( ) ;
10111017
@@ -1017,11 +1023,16 @@ pub fn compute_named_argument_clause(
10171023
10181024 let arg_clause = arg_syntax. arg_clause ( syntax_db) ;
10191025 let ( expr, arg_name_identifier) = match arg_clause {
1020- ast:: ArgClause :: Unnamed ( arg_unnamed) => {
1021- ( compute_expr_semantic ( ctx, & arg_unnamed. value ( syntax_db) ) , None )
1022- }
1023- ast:: ArgClause :: Named ( arg_named) => (
1024- compute_expr_semantic ( ctx, & arg_named. value ( syntax_db) ) ,
1026+ ast:: ArgClause :: Unnamed ( arg_unnamed) => handle_possible_closure_expr (
1027+ ctx,
1028+ & arg_unnamed. value ( syntax_db) ,
1029+ closure_param_types,
1030+ None ,
1031+ ) ,
1032+ ast:: ArgClause :: Named ( arg_named) => handle_possible_closure_expr (
1033+ ctx,
1034+ & arg_named. value ( syntax_db) ,
1035+ closure_param_types,
10251036 Some ( arg_named. name ( syntax_db) ) ,
10261037 ) ,
10271038 ast:: ArgClause :: FieldInitShorthand ( arg_field_init_shorthand) => {
@@ -1034,10 +1045,32 @@ pub fn compute_named_argument_clause(
10341045 ( expr, Some ( arg_name_identifier) )
10351046 }
10361047 } ;
1037-
10381048 NamedArg ( expr, arg_name_identifier, mutability)
10391049}
10401050
1051+ /// Handles the semantic computation of a closure expression.
1052+ /// It processes a closure expression, computes its semantic model,
1053+ /// allocates it in the expression arena, and ensures that the closure's
1054+ /// parameter types are conformed if provided.
1055+ fn handle_possible_closure_expr (
1056+ ctx : & mut ComputationContext < ' _ > ,
1057+ expr : & ast:: Expr ,
1058+ closure_param_types : Option < TypeId > ,
1059+ arg_name : Option < TerminalIdentifier > ,
1060+ ) -> ( ExprAndId , Option < TerminalIdentifier > ) {
1061+ if let ast:: Expr :: Closure ( expr_closure) = expr {
1062+ let expr = compute_expr_closure_semantic ( ctx, expr_closure, closure_param_types) ;
1063+ let expr = wrap_maybe_with_missing ( ctx, expr, expr_closure. stable_ptr ( ) . into ( ) ) ;
1064+ let id = ctx. arenas . exprs . alloc ( expr. clone ( ) ) ;
1065+ ( ExprAndId { expr, id } , arg_name)
1066+ } else {
1067+ let expr = compute_expr_semantic ( ctx, expr) ;
1068+ let expr = wrap_maybe_with_missing ( ctx, Ok ( expr. expr . clone ( ) ) , expr. stable_ptr ( ) ) ;
1069+ let id = ctx. arenas . exprs . alloc ( expr. clone ( ) ) ;
1070+ ( ExprAndId { expr, id } , arg_name)
1071+ }
1072+ }
1073+
10411074pub fn compute_root_expr (
10421075 ctx : & mut ComputationContext < ' _ > ,
10431076 syntax : & ast:: ExprBlock ,
@@ -1645,6 +1678,7 @@ fn compute_loop_body_semantic(
16451678fn compute_expr_closure_semantic (
16461679 ctx : & mut ComputationContext < ' _ > ,
16471680 syntax : & ast:: ExprClosure ,
1681+ param_types : Option < TypeId > ,
16481682) -> Maybe < Expr > {
16491683 ctx. are_closures_in_context = true ;
16501684 let syntax_db = ctx. db . upcast ( ) ;
@@ -1663,6 +1697,14 @@ fn compute_expr_closure_semantic(
16631697 } else {
16641698 vec ! [ ]
16651699 } ;
1700+ let closure_type =
1701+ TypeLongId :: Tuple ( params. iter ( ) . map ( |param| param. ty ) . collect ( ) ) . intern ( new_ctx. db ) ;
1702+ if let Some ( param_types) = param_types {
1703+ if let Err ( err_set) = new_ctx. resolver . inference ( ) . conform_ty ( closure_type, param_types)
1704+ {
1705+ new_ctx. resolver . inference ( ) . consume_error_without_reporting ( err_set) ;
1706+ }
1707+ }
16661708
16671709 params. iter ( ) . filter ( |param| param. mutability == Mutability :: Reference ) . for_each ( |param| {
16681710 new_ctx. diagnostics . report ( param. stable_ptr ( ctx. db . upcast ( ) ) , RefClosureParam ) ;
@@ -2834,16 +2876,22 @@ fn method_call_expr(
28342876 // Self argument.
28352877 let mut named_args = vec ! [ NamedArg ( fixed_lexpr, None , mutability) ] ;
28362878 // Other arguments.
2837- for _ in function_parameter_types ( ctx, function_id) ?. skip ( 1 ) {
2879+ let closure_params: OrderedHashMap < TypeId , TypeId > =
2880+ concrete_function_closure_params ( ctx. db , function_id) ?;
2881+ for ty in function_parameter_types ( ctx, function_id) ?. skip ( 1 ) {
28382882 let Some ( arg_syntax) = args_iter. next ( ) else {
28392883 break ;
28402884 } ;
2841- named_args. push ( compute_named_argument_clause ( ctx, arg_syntax) ) ;
2885+ named_args. push ( compute_named_argument_clause (
2886+ ctx,
2887+ arg_syntax,
2888+ closure_params. get ( & ty) . cloned ( ) ,
2889+ ) ) ;
28422890 }
28432891
28442892 // Maybe coupon
28452893 if let Some ( arg_syntax) = args_iter. next ( ) {
2846- named_args. push ( compute_named_argument_clause ( ctx, arg_syntax) ) ;
2894+ named_args. push ( compute_named_argument_clause ( ctx, arg_syntax, None ) ) ;
28472895 }
28482896
28492897 expr_function_call ( ctx, function_id, named_args, & expr, stable_ptr)
0 commit comments