From bea48eb18bc499c8df9730a7b6bc5a1549cfdd81 Mon Sep 17 00:00:00 2001 From: Nathan Braswell Date: Wed, 1 Feb 2023 01:01:37 -0500 Subject: [PATCH] Reviewing and making notes about analysises, looking to see if they can be implemented with a generic traversal or something --- partial_eval.scm | 29 +++++++++++++++++++---------- 1 file changed, 19 insertions(+), 10 deletions(-) diff --git a/partial_eval.scm b/partial_eval.scm index 455d372..ac29a8d 100644 --- a/partial_eval.scm +++ b/partial_eval.scm @@ -4620,19 +4620,25 @@ ; dynamic call unval-partial-eval branch ; ; Rembember to account for (dont_compile dont_lazy_env dont_y_comb dont_prim_inline dont_closure_inline) + + ; (... ) + + ; call-info will be a fairly simple pre-order traversal (looking at caller before params) + ; infer-type has to walk though cond in pairs, special handle the (and ) case, and adjust parameters for veval + ; perceus is weird, as it has to look at the head to determine how to order/combine the children, as well as an extra sub-data for the call itself (though I guess this is just part of the node data) (call-info (rec-lambda call-info (c env_id) (cond ((val? c) nil) ((and (marked_symbol? c) (.marked_symbol_is_val c)) nil) ((marked_symbol? c) nil) ((marked_env? c) nil) ; So it actually needs to recurse into env (no, I don't think so, maybe only fake) + ((prim_comb? c) nil) + ((and (marked_array? c) (.marked_array_is_val c)) nil) ; and array values + ((comb? c) (dlet ( ((wrap_level env_id de? se variadic params body) (.comb c)) (_ (mif (> wrap_level 1) (error "wrap level TOO DARN HIGH"))) ) nil)) - ((prim_comb? c) nil) - ((and (marked_array? c) (.marked_array_is_val c)) nil) ; and array values - ((and (marked_array? c) ;(>= 2 (len (.marked_array_values c))) (let_like_inline_closure (idx (.marked_array_values c) 0) env_id)) nil) ; REMEMBER - new env_id inside @@ -4831,10 +4837,9 @@ (_ (if (not (marked_env? (idx params 1))) (error "call to veval has not marked_env second param"))) (new_env_id (.marked_env_idx (idx params 1))) - ((btyp bimpl b_assertion b_subdata) (infer_types (idx params 0) new_env_id empty_dict-list empty_dict-list)) (sub_data (array (infer_types func env_id implies guarentees) - (array btyp bimpl b_assertion b_subdata) + (infer_types (idx params 0) new_env_id empty_dict-list empty_dict-list) (infer_types (idx params 1) env_id implies guarentees))) ) (array btyp false empty_dict-list sub_data))) @@ -4844,6 +4849,7 @@ ;(_ (true_print " doing infer-types for random call ")) (sub_results (map (lambda (x) (infer_types x env_id implies guarentees)) (.marked_array_values c))) ;(_ (true_print " done infer-types for random call ")) + ; I belive this .hash doesn't do anything ) (array (get-list-or guarentees (.hash c) false) false empty_dict-list sub_results))) ; fallthrough @@ -4979,6 +4985,7 @@ ; YES remember to check for Y-combiner recursion knot tying - (and (!= nil (.marked_array_this_rec_stop c)) (get_passthrough (idx (.marked_array_this_rec_stop c) 0) ctx)) ; YES remember to check for let-like inlining (and (marked_array? c) (let_like_inline_closure (idx (.marked_array_values c) 0) env_id)) ; YES remember to properly handle crazy stuff like inlining inside of veval (does that mean we have to re-pick up inside veval after all?) + ; TODO: properly handle param usage based on wrap level if unknown (based on call-info) ; remember to think (/modify appropriately) about TCE - I think it's fine to have it act like a normal call? ((and (marked_array? c) (not (.marked_array_is_val c))) (dlet ( ; check func first for val or not & if val if it uses de (comb that uses de, prim_comb that takes it) @@ -5039,7 +5046,7 @@ ((and (marked_array? c) (.marked_array_is_val c)) (array b borrow_nil)) ; no matter if env is real or not, it's borrowed, ; as it will be cached for the length of the function - ((marked_env? c) (array b borrow_nil)) + ((marked_env? c) (array b borrow_nil)) ; I feel like all of these value ones but esp this one should be true instead of b? must-be-borrowed ((and (marked_symbol? c) (not (.marked_symbol_is_val c))) (array (and b (not (cached_pseudo_perceus_sym_borrowed used_map_sub_data))) borrow_nil)) ; comb value just does its env ((comb? c) (borrow? (.comb_env c) b env_id used_map_sub_data)) @@ -5091,6 +5098,7 @@ ) (array borrowed sub_data))) ; call taxonomy a bit simpler this time - if it's not already special cased, it's either an inline or it's owned + ; This also has to be adjusted based on possibly dynamic calls with unknown wrap level ((and (marked_array? c) (not (.marked_array_is_val c))) (dlet ( (func_param_values (.marked_array_values c)) (num_params (- (len func_param_values) 1)) @@ -5121,14 +5129,14 @@ ((wrap_level env_id de? se variadic params body) (.comb c)) (full_params (concat params (mif de? (array de?) (array)))) - ;------------- + (call_info (call-info c env_id)) - ;------------- (inner_type_data (infer_types body env_id empty_dict-list empty_dict-list)) ((used_map_before used_map_sub_data) (pseudo_perceus body env_id memo (push_used_map empty_use_map full_params))) ((borrowed borrow_sub_data) (borrow? body false env_id used_map_sub_data)) (_ (mif borrowed (error "body hast to be borrowed? " borrowed " " (true_str_strip body)))) - (inner_analysis_data (array inner_type_data used_map_sub_data)) + + (inner_analysis_data (array inner_type_data used_map_sub_data call_info)) ) inner_analysis_data))) @@ -5142,9 +5150,10 @@ ;( t (cached_infer_types_idx c env_id (idx cache 0) i)) ;( p (mif cache (pseudo_perceus_just_sub_idx (idx cache 1) i) nil)) ( p nil ) + ( c nil ) ;(_ (true_print "done infer-types-idx")) - ) (array t p)))) + ) (array t p c)))) (compile-inner (rec-lambda compile-inner (ctx c need_value inside_veval outer_s_env_access_code s_env_access_code inline_level tce_data analysis_data) (cond