implementation module type import StdEnv import syntax, typesupport, check, analtypes, overloading, unitype, refmark, predef, utilities, compare_constructor // , RWSDebug import cheat import generics // AA :: TypeInput = { ti_common_defs :: !{# CommonDefs } , ti_functions :: !{# {# FunType }} , ti_main_dcl_module_n :: !Int } :: TypeState = { ts_fun_env :: !.{! FunctionType} , ts_var_store :: !Int , ts_attr_store :: !Int , ts_var_heap :: !.VarHeap , ts_type_heaps :: !.TypeHeaps , ts_expr_heap :: !.ExpressionHeap , ts_td_infos :: !.TypeDefInfos , ts_error :: !.ErrorAdmin , ts_out :: !.File } :: TypeCoercion = { tc_demanded :: !AType , tc_offered :: !AType , tc_position :: !CoercionPosition , tc_coercible :: !Bool } :: SharedAttribute = { sa_attr_nr :: !Int , sa_position :: !Expression } :: Requirements = { req_overloaded_calls :: ![ExprInfoPtr] , req_type_coercions :: ![TypeCoercion] , req_type_coercion_groups:: ![TypeCoercionGroup] , req_attr_coercions :: ![AttrCoercion] , req_cons_variables :: ![[TempVarId]] , req_case_and_let_exprs :: ![ExprInfoPtr] } :: TypeCoercionGroup = { tcg_type_coercions :: ![TypeCoercion] , tcg_position :: !Position } instance toString BoundVar where toString varid = varid.var_name.id_name class arraySubst type :: !type !u:{!Type} -> (!type, !u:{! Type}) /* instance arraySubst AType where arraySubst atype=:{at_type} subst # (at_type, subst) = arraySubst at_type subst = ({ atype & at_type = at_type }, subst) instance arraySubst Type where arraySubst tv=:(TempV tv_number) subst #! type = subst.[tv_number] = case type of TE -> (tv, subst) _ -> arraySubst type subst arraySubst (arg_type --> res_type) subst # (arg_type, subst) = arraySubst arg_type subst (res_type, subst) = arraySubst res_type subst = (arg_type --> res_type, subst) arraySubst (TA cons_id cons_args) subst # (cons_args, subst) = arraySubst cons_args subst = (TA cons_id cons_args, subst) arraySubst (TempCV tv_number :@: types) subst #! type = subst.[tv_number] = case type of TE # (types, subst) = arraySubst types subst -> (TempCV tv_number :@: types, subst) _ # (type, subst) = arraySubst type subst (types, subst) = arraySubst types subst -> (simplify_type_appl type types, subst) where simplify_type_appl :: !Type ![AType] -> Type simplify_type_appl (TA type_cons=:{type_arity} cons_args) type_args = TA { type_cons & type_arity = type_arity + length type_args } (cons_args ++ type_args) simplify_type_appl (cons_var :@: types) type_args = cons_var :@: (types ++ type_args) simplify_type_appl (TempV tv_number) type_args = TempCV tv_number :@: type_args simplify_type_appl (TempQV tv_number) type_args = TempQCV tv_number :@: type_args arraySubst type subst = (type, subst) instance arraySubst [a] | arraySubst a where arraySubst l subst = mapSt arraySubst l subst instance arraySubst TempSymbolType where arraySubst tst=:{tst_args,tst_result,tst_context} subst # (tst_args, subst) = arraySubst tst_args subst (tst_result, subst) = arraySubst tst_result subst (tst_context, subst) = arraySubst tst_context subst = ({tst & tst_args = tst_args,tst_result = tst_result,tst_context = tst_context}, subst) instance arraySubst TypeContext where arraySubst tc=:{tc_types} subst # (tc_types, subst) = arraySubst tc_types subst = ({ tc & tc_types = tc_types}, subst) /* instance arraySubst OverloadedCall where arraySubst oc=:{oc_context} subst # (oc_context, subst) = arraySubst oc_context subst = ({ oc & oc_context = oc_context }, subst) */ instance arraySubst CaseType where arraySubst ct=:{ct_pattern_type,ct_result_type,ct_cons_types} subst # (ct_pattern_type, subst) = arraySubst ct_pattern_type subst (ct_result_type, subst) = arraySubst ct_result_type subst (ct_cons_types, subst) = arraySubst ct_cons_types subst = ({ ct & ct_pattern_type = ct_pattern_type, ct_result_type = ct_result_type, ct_cons_types = ct_cons_types }, subst) */ instance arraySubst AType where arraySubst atype=:{at_type} subst # (changed,at_type, subst) = arraySubst2 at_type subst | changed = ({ atype & at_type = at_type }, subst) = (atype, subst) instance arraySubst Type where arraySubst tv=:(TempV tv_number) subst #! type = subst.[tv_number] = case type of TE -> (tv, subst) _ -> arraySubst type subst arraySubst type=:(arg_type0 --> res_type0) subst # (changed,arg_type, subst) = arraySubst2 arg_type0 subst | changed # (changed,res_type, subst) = arraySubst2 res_type0 subst | changed = (arg_type --> res_type, subst) = (arg_type --> res_type0, subst) # (changed,res_type, subst) = arraySubst2 res_type0 subst | changed = (arg_type0 --> res_type, subst) = (type, subst) arraySubst type=:(TA cons_id cons_args) subst # (changed,cons_args, subst) = arraySubst2 cons_args subst | changed = (TA cons_id cons_args, subst) = (type, subst) arraySubst tcv=:(TempCV tv_number :@: types) subst #! type = subst.[tv_number] = case type of TE # (changed,types, subst) = arraySubst2 types subst | changed -> (TempCV tv_number :@: types, subst) -> (tcv, subst) _ # (type, subst) = arraySubst type subst (types, subst) = arraySubst types subst -> (simplify_type_appl type types, subst) where simplify_type_appl :: !Type ![AType] -> Type simplify_type_appl (TA type_cons=:{type_arity} cons_args) type_args = TA { type_cons & type_arity = type_arity + length type_args } (cons_args ++ type_args) simplify_type_appl (cons_var :@: types) type_args = cons_var :@: (types ++ type_args) simplify_type_appl (TempV tv_number) type_args = TempCV tv_number :@: type_args simplify_type_appl (TempQV tv_number) type_args = TempQCV tv_number :@: type_args arraySubst type subst = (type, subst) instance arraySubst [a] | arraySubst2 a where arraySubst [] subst = ([],subst) arraySubst t=:[type0:types0] subst # (changed,types,subst) = arraySubst2 types0 subst | changed # (changed,type,subst) = arraySubst2 type0 subst | changed = ([type:types],subst) = ([type0:types],subst) # (changed,type,subst) = arraySubst2 type0 subst | changed = ([type:types0],subst) = (t,subst) instance arraySubst TempSymbolType where arraySubst tst=:{tst_args,tst_result,tst_context} subst # (changed,tst_args, subst) = arraySubst2 tst_args subst | changed # (changed,tst_result, subst) = arraySubst2 tst_result subst # (changed,tst_context, subst) = arraySubst2 tst_context subst = ({tst & tst_args = tst_args,tst_result = tst_result,tst_context = tst_context}, subst) # (changed,tst_result, subst) = arraySubst2 tst_result subst | changed # (changed,tst_context, subst) = arraySubst2 tst_context subst = ({tst & tst_result = tst_result,tst_context = tst_context}, subst) # (changed,tst_context, subst) = arraySubst2 tst_context subst | changed = ({tst & tst_context = tst_context}, subst) = (tst, subst) instance arraySubst TypeContext where arraySubst tc=:{tc_types} subst # (changed,tc_types, subst) = arraySubst2 tc_types subst | changed = ({ tc & tc_types = tc_types}, subst) = ( tc, subst) instance arraySubst CaseType where arraySubst ct=:{ct_pattern_type,ct_result_type,ct_cons_types} subst # (changed,ct_pattern_type, subst) = arraySubst2 ct_pattern_type subst | changed # (changed,ct_result_type, subst) = arraySubst2 ct_result_type subst # (changed,ct_cons_types, subst) = arraySubst2 ct_cons_types subst = ({ ct & ct_pattern_type = ct_pattern_type, ct_result_type = ct_result_type, ct_cons_types = ct_cons_types }, subst) # (changed,ct_result_type, subst) = arraySubst2 ct_result_type subst | changed # (changed,ct_cons_types, subst) = arraySubst2 ct_cons_types subst = ({ ct & ct_result_type = ct_result_type, ct_cons_types = ct_cons_types }, subst) # (changed,ct_cons_types, subst) = arraySubst2 ct_cons_types subst | changed = ({ ct & ct_cons_types = ct_cons_types }, subst) = (ct, subst) class arraySubst2 type :: !type !u:{!Type} -> (!Bool,!type, !u:{! Type}) instance arraySubst2 AType where arraySubst2 atype=:{at_type} subst # (changed,at_type, subst) = arraySubst2 at_type subst | changed = (True,{ atype & at_type = at_type }, subst) = (False,atype, subst) instance arraySubst2 Type where arraySubst2 tv=:(TempV tv_number) subst #! type = subst.[tv_number] = case type of TE -> (False,tv, subst) _ # (t,s) = arraySubst type subst -> (True,t,s) arraySubst2 type=:(arg_type0 --> res_type0) subst # (changed,arg_type, subst) = arraySubst2 arg_type0 subst | changed # (changed,res_type, subst) = arraySubst2 res_type0 subst | changed = (True,arg_type --> res_type, subst) = (True,arg_type --> res_type0, subst) # (changed,res_type, subst) = arraySubst2 res_type0 subst | changed = (True,arg_type0 --> res_type, subst) = (False,type, subst) arraySubst2 type=:(TA cons_id cons_args) subst # (changed,cons_args, subst) = arraySubst2 cons_args subst | changed = (True,TA cons_id cons_args, subst) = (False,type, subst) arraySubst2 tcv=:(TempCV tv_number :@: types) subst #! type = subst.[tv_number] = case type of TE # (changed,types, subst) = arraySubst2 types subst | changed -> (True,TempCV tv_number :@: types, subst) -> (False,tcv, subst) _ # (type, subst) = arraySubst type subst (types, subst) = arraySubst types subst -> (True,simplify_type_appl type types, subst) where simplify_type_appl :: !Type ![AType] -> Type simplify_type_appl (TA type_cons=:{type_arity} cons_args) type_args = TA { type_cons & type_arity = type_arity + length type_args } (cons_args ++ type_args) simplify_type_appl (cons_var :@: types) type_args = cons_var :@: (types ++ type_args) simplify_type_appl (TempV tv_number) type_args = TempCV tv_number :@: type_args simplify_type_appl (TempQV tv_number) type_args = TempQCV tv_number :@: type_args arraySubst2 type subst = (False,type, subst) instance arraySubst2 [a] | arraySubst2 a where arraySubst2 [] subst = (False,[],subst) arraySubst2 t=:[type0:types0] subst # (changed,types,subst) = arraySubst2 types0 subst | changed # (changed,type,subst) = arraySubst2 type0 subst | changed = (True,[type:types],subst) = (True,[type0:types],subst) # (changed,type,subst) = arraySubst2 type0 subst | changed = (True,[type:types0],subst) = (False,t,subst) instance arraySubst2 TempSymbolType where arraySubst2 tst=:{tst_args,tst_result,tst_context} subst # (changed,tst_args, subst) = arraySubst2 tst_args subst | changed # (changed,tst_result, subst) = arraySubst2 tst_result subst # (changed,tst_context, subst) = arraySubst2 tst_context subst = (True,{tst & tst_args = tst_args,tst_result = tst_result,tst_context = tst_context}, subst) # (changed,tst_result, subst) = arraySubst2 tst_result subst | changed # (changed,tst_context, subst) = arraySubst2 tst_context subst = (True,{tst & tst_result = tst_result,tst_context = tst_context}, subst) # (changed,tst_context, subst) = arraySubst2 tst_context subst | changed = (True,{tst & tst_context = tst_context}, subst) = (False,tst, subst) instance arraySubst2 TypeContext where arraySubst2 tc=:{tc_types} subst # (changed,tc_types, subst) = arraySubst2 tc_types subst | changed = (True,{ tc & tc_types = tc_types}, subst) = (False, tc, subst) instance arraySubst2 CaseType where arraySubst2 ct=:{ct_pattern_type,ct_result_type,ct_cons_types} subst # (changed,ct_pattern_type, subst) = arraySubst2 ct_pattern_type subst | changed # (changed,ct_result_type, subst) = arraySubst2 ct_result_type subst # (changed,ct_cons_types, subst) = arraySubst2 ct_cons_types subst = (True,{ ct & ct_pattern_type = ct_pattern_type, ct_result_type = ct_result_type, ct_cons_types = ct_cons_types }, subst) # (changed,ct_result_type, subst) = arraySubst2 ct_result_type subst | changed # (changed,ct_cons_types, subst) = arraySubst2 ct_cons_types subst = (True,{ ct & ct_result_type = ct_result_type, ct_cons_types = ct_cons_types }, subst) # (changed,ct_cons_types, subst) = arraySubst2 ct_cons_types subst | changed = (True,{ ct & ct_cons_types = ct_cons_types }, subst) = (False,ct, subst) class contains_var a :: !Int !a -> Bool instance contains_var [a] | contains_var a where contains_var var_id [elem:list] = contains_var var_id elem || contains_var var_id list contains_var var_id [] = False instance contains_var AType where contains_var var_id {at_type} = contains_var var_id at_type instance contains_var Type where contains_var var_id (TempV tv_number) = var_id == tv_number contains_var var_id (arg_type --> res_type) = contains_var var_id arg_type || contains_var var_id res_type contains_var var_id (TA cons_id cons_args) = contains_var var_id cons_args contains_var var_id (type :@: types) = contains_var var_id type || contains_var var_id types contains_var _ _ = False instance contains_var ConsVariable where contains_var var_id (TempCV tv_number) = var_id == tv_number contains_var var_id _ = False type_error =: "Type error" type_error_format =: { form_properties = cNoProperties, form_attr_position = No } cannotUnify t1 t2 position=:(CP_Expression expr) err=:{ea_loc=[ip:_]} = case tryToOptimizePosition expr of Yes (id_name, line) # err = pushErrorAdmin { ip & ip_ident.id_name = id_name, ip_line = line } err err = errorHeading type_error err err = popErrorAdmin err // -> { err & ea_file = err.ea_file <<< " cannot unify " <:: (type_error_format, t1, Yes initialTypeVarBeautifulizer) // <<< " with " <:: (type_error_format, t2, Yes initialTypeVarBeautifulizer) <<< '\n' } -> { err & ea_file = err.ea_file <<< " cannot unify " <:: (type_error_format, t1, No) <<< " with " <:: (type_error_format, t2, No) <<< '\n' } _ -> cannot_unify t1 t2 position err cannotUnify t1 t2 position err = cannot_unify t1 t2 position err cannot_unify t1 t2 position err # (err=:{ea_file}) = errorHeading type_error err ea_file = case position of CP_FunArg _ _ -> ea_file <<< "\"" <<< position <<< "\"" _ -> ea_file ea_file = ea_file <<< " cannot unify " <:: (type_error_format, t1, No) <<< " with " <:: (type_error_format, t2, No) // ea_file = ea_file <<< " cannot unify " <:: (type_error_format, t1, Yes initialTypeVarBeautifulizer) // <<< " with " <:: (type_error_format, t2, Yes initialTypeVarBeautifulizer) ea_file = case position of CP_FunArg _ _ -> ea_file _ -> ea_file <<< " near " <<< position = { err & ea_file = ea_file <<< '\n' } tryToOptimizePosition (Case {case_ident=Yes {id_name}}) = optBeautifulizeIdent id_name tryToOptimizePosition (App {app_symb={symb_name}}) = optBeautifulizeIdent symb_name.id_name tryToOptimizePosition (fun @ _) = tryToOptimizePosition fun tryToOptimizePosition _ = No class unify a :: !a !a !TypeInput !*{! Type} !*TypeHeaps -> (!Bool, !*{! Type}, !*TypeHeaps) instance unify (a, b) | unify, arraySubst a & unify, arraySubst b where unify (t1x, t1y) (t2x, t2y) modules subst heaps # (succ, subst, heaps) = unify t1y t2y modules subst heaps | succ # (t1x, subst) = arraySubst t1x subst (t2x, subst) = arraySubst t2x subst = unify t1x t2x modules subst heaps = (False, subst, heaps) //instance unify [a] | unify, arraySubst a instance unify [a] | unify, arraySubst, arraySubst2 a where unify [t1 : ts1] [t2 : ts2] modules subst heaps = unify (t1,ts1) (t2,ts2) modules subst heaps unify [] [] modules subst heaps = (True, subst, heaps) unify _ _ modules subst heaps = (False, subst, heaps) instance unify AType where unify t1 t2 modules subst heaps = unifyTypes t1.at_type t1.at_attribute t2.at_type t2.at_attribute modules subst heaps unifyTypes :: !Type !TypeAttribute !Type !TypeAttribute !TypeInput !*{! Type} !*TypeHeaps -> (!Bool, !*{! Type}, !*TypeHeaps) unifyTypes (TempV tv_number1) attr1 tv=:(TempV tv_number2) attr2 modules subst heaps = unifyTempVarIds tv_number1 tv_number2 subst heaps unifyTypes tv=:(TempV tv_number) attr1 type attr2 modules subst heaps | contains_var tv_number type = (False, subst, heaps) = (True, { subst & [tv_number] = type}, heaps) unifyTypes type attr1 tv=:(TempV _) attr2 modules subst heaps = unifyTypes tv attr2 type attr1 modules subst heaps unifyTypes t1=:(TB tb1) attr1 t2=:(TB tb2) attr2 modules subst heaps | tb1 == tb2 = (True, subst, heaps) = (False, subst, heaps) unifyTypes (arg_type1 --> res_type1) attr1 (arg_type2 --> res_type2) attr2 modules subst heaps = unify (arg_type1,res_type1) (arg_type2,res_type2) modules subst heaps unifyTypes t1=:(TA cons_id1 cons_args1) attr1 t2=:(TA cons_id2 cons_args2) attr2 modules subst heaps | cons_id1 == cons_id2 = unify cons_args1 cons_args2 modules subst heaps # (succ1, t1, heaps) = tryToExpand t1 attr1 modules heaps (succ2, t2, heaps) = tryToExpand t2 attr2 modules heaps | succ1 || succ2 = unifyTypes t1 attr1 t2 attr2 modules subst heaps = (False, subst, heaps) unifyTypes (cons_var :@: types) attr1 type2 attr2 modules subst heaps # (_, type2, heaps) = tryToExpand type2 attr2 modules heaps = unifyTypeApplications cons_var types type2 modules subst heaps unifyTypes type1 attr1 (cons_var :@: types) attr2 modules subst heaps # (_, type1, heaps) = tryToExpand type1 attr1 modules heaps = unifyTypeApplications cons_var types type1 modules subst heaps unifyTypes t1=:(TempQV qv_number1) attr1 t2=:(TempQV qv_number2) attr2 modules subst heaps = (qv_number1 == qv_number2, subst, heaps) unifyTypes (TempQV qv_number) attr1 type attr2 modules subst heaps = (False, subst, heaps) unifyTypes type attr1 (TempQV qv_number1) attr2 modules subst heaps = (False, subst, heaps) unifyTypes type1 attr1 type2 attr2 modules subst heaps # (succ1, type1, heaps) = tryToExpand type1 attr1 modules heaps (succ2, type2, heaps) = tryToExpand type2 attr2 modules heaps | succ1 || succ2 = unifyTypes type1 attr1 type2 attr2 modules subst heaps = (False, subst, heaps) tryToExpand type=:(TA {type_index={glob_object,glob_module}} type_args) type_attr {ti_common_defs} type_heaps #! type_def = ti_common_defs.[glob_module].com_type_defs.[glob_object] = case type_def.td_rhs of SynType {at_type} # (res_type, type_heaps) = expandTypeApplication type_def.td_args type_def.td_attribute at_type type_args type_attr type_heaps -> (True, res_type, type_heaps) _ -> (False, type, type_heaps) tryToExpand type type_attr modules type_heaps = (False, type, type_heaps) unifyConsVariables (TempCV tv_number1) (TempCV tv_number2) subst heaps = unifyTempVarIds tv_number1 tv_number2 subst heaps unifyConsVariables (TempCV tv_number1) (TempQCV tv_number2) subst heaps = (True, { subst & [tv_number1] = TempQV tv_number2}, heaps) unifyConsVariables (TempQCV tv_number1) (TempCV tv_number2) subst heaps = (True, { subst & [tv_number2] = TempQV tv_number1}, heaps) unifyConsVariables (TempQCV tv_number1) (TempQCV tv_number2) subst heaps = (tv_number1 == tv_number2, subst, heaps) unifyTempVarIds tv_number1 tv_number2 subst heaps | tv_number1 == tv_number2 = (True, subst, heaps) = (True, { subst & [tv_number1] = TempV tv_number2}, heaps) constructorVariableToTypeVariable (TempCV temp_var_id) = TempV temp_var_id constructorVariableToTypeVariable (TempQCV temp_var_id) = TempQV temp_var_id unifyTypeApplications cons_var type_args type=:(TA type_cons cons_args) modules subst heaps # diff = type_cons.type_arity - length type_args | diff >= 0 # (succ, subst, heaps) = unify type_args (drop diff cons_args) modules subst heaps | succ # (rest_args, subst) = arraySubst (take diff cons_args) subst = unifyTypes (constructorVariableToTypeVariable cons_var) TA_Multi (TA { type_cons & type_arity = diff } rest_args) TA_Multi modules subst heaps = (False, subst, heaps) = (False, subst, heaps) unifyTypeApplications cons_var1 type_args type=:(cons_var2 :@: types) modules subst heaps # arity1 = length type_args arity2 = length types diff = arity1 - arity2 | diff == 0 # (succ, subst, heaps) = unifyConsVariables cons_var1 cons_var2 subst heaps | succ # (type_args, subst) = arraySubst type_args subst (types, subst) = arraySubst types subst = unify type_args types modules subst heaps = (False, subst, heaps) | diff < 0 # diff = 0 - diff (succ, subst, heaps) = unifyTypes (constructorVariableToTypeVariable cons_var1) TA_Multi (cons_var2 :@: take diff types) TA_Multi modules subst heaps | succ # (type_args, subst) = arraySubst type_args subst (types, subst) = arraySubst (drop diff types) subst = unify type_args types modules subst heaps = (False, subst, heaps) // | otherwise # (succ, subst, heaps) = unifyTypes (cons_var1 :@: take diff type_args) TA_Multi (constructorVariableToTypeVariable cons_var2) TA_Multi modules subst heaps | succ # (type_args, subst) = arraySubst (drop diff type_args) subst (types, subst) = arraySubst types subst = unify type_args types modules subst heaps = (False, subst, heaps) unifyTypeApplications cons_var type_args type modules subst heaps = (False, subst, heaps) :: CopyState = { copy_heaps :: !.TypeHeaps } instance fromInt TypeAttribute where fromInt AttrUni = TA_Unique fromInt AttrMulti = TA_Multi fromInt av_number = TA_TempVar av_number class freshCopy a :: !a !*CopyState -> (!a, !*CopyState) instance freshCopy [a] | freshCopy a where freshCopy l ls = mapSt freshCopy l ls /* cDoExtendAttrEnv :== True cDontExtendAttrEnv :== False freshCopies :: !Bool ![a] !{# CommonDefs } !*CopyState -> (![a], !*CopyState) | freshCopy a freshCopies extend_env [] modules cs = ([], [], cs) freshCopies extend_env [t:ts] modules cs # (t, prop, cs) = freshCopy extend_env t modules cs (ts, props, cs) = freshCopies extend_env ts modules cs = ([t:ts], [prop:props], cs) */ freshCopyOfAttributeVar {av_name,av_info_ptr} attr_var_heap # (av_info, attr_var_heap) = readPtr av_info_ptr attr_var_heap = case av_info of AVI_Attr attr -> (attr, attr_var_heap) _ -> abort ("freshCopyOfAttributeVar (type,icl)" ---> av_name) freshCopyOfTypeAttribute (TA_Var avar) attr_var_heap = freshCopyOfAttributeVar avar attr_var_heap /* A temporary hack to handle the new Object IO lib */ /* Should be removed !!!!!!!!!! */ freshCopyOfTypeAttribute (TA_RootVar avar) attr_var_heap = PA_BUG (TA_TempExVar, attr_var_heap) (freshCopyOfAttributeVar avar attr_var_heap) freshCopyOfTypeAttribute TA_None attr_var_heap = (TA_Multi, attr_var_heap) freshCopyOfTypeAttribute TA_Unique attr_var_heap = (TA_Unique, attr_var_heap) freshCopyOfTypeAttribute attr attr_var_heap = (attr, attr_var_heap) cIsExistential :== True cIsNotExistential :== False freshCopyOfTypeVariable {tv_name,tv_info_ptr} cs=:{copy_heaps} # (TVI_Type fresh_var, th_vars) = readPtr tv_info_ptr copy_heaps.th_vars // = (fresh_var, { cs & copy_heaps.th_vars = th_vars } ) // 2.0 = (fresh_var, { cs & copy_heaps = { copy_heaps & th_vars = th_vars }}) freshConsVariable {tv_info_ptr} type_var_heap # (tv_info, type_var_heap) = readPtr tv_info_ptr type_var_heap = (to_constructor_variable tv_info, type_var_heap) where to_constructor_variable (TVI_Type (TempV temp_var_id)) = TempCV temp_var_id to_constructor_variable (TVI_Type (TempQV temp_var_id)) = TempQCV temp_var_id instance freshCopy AType where freshCopy type=:{at_type = CV tv :@: types, at_attribute} cs=:{copy_heaps} # (fresh_cons_var, th_vars) = freshConsVariable tv copy_heaps.th_vars (fresh_attribute, th_attrs) = freshCopyOfTypeAttribute at_attribute copy_heaps.th_attrs (types, cs) = freshCopy types { cs & copy_heaps = { copy_heaps & th_attrs = th_attrs, th_vars = th_vars }} = ({type & at_type = fresh_cons_var :@: types, at_attribute = fresh_attribute }, cs) freshCopy type=:{at_type, at_attribute} cs=:{copy_heaps} # (fresh_attribute, th_attrs) = freshCopyOfTypeAttribute at_attribute copy_heaps.th_attrs (fresh_type, cs) = freshCopy at_type { cs & copy_heaps = { copy_heaps & th_attrs = th_attrs }} = ({ type & at_type = fresh_type, at_attribute = fresh_attribute }, cs) instance freshCopy Type where freshCopy (TV tv) cs=:{copy_heaps} = freshCopyOfTypeVariable tv cs freshCopy (TA cons_id=:{type_index={glob_object,glob_module}} cons_args) cs # (cons_args, cs) = freshCopy cons_args cs = (TA cons_id cons_args, cs) freshCopy (arg_type --> res_type) cs # (arg_type, cs) = freshCopy arg_type cs (res_type, cs) = freshCopy res_type cs = (arg_type --> res_type, cs) freshCopy type cs = (type, cs) freshExistentialVariables type_variables state = foldSt fresh_existential_variable type_variables state where fresh_existential_variable {atv_variable={tv_info_ptr}} (var_heap, var_store) = (var_heap <:= (tv_info_ptr, TVI_Type (TempQV var_store)), inc var_store) freshAlgebraicType :: !(Global Int) ![AlgebraicPattern] !{#CommonDefs} !*TypeState -> (![[AType]],!AType,![AttrCoercion],!*TypeState) freshAlgebraicType {glob_module, glob_object} patterns common_defs ts=:{ts_var_store,ts_attr_store,ts_type_heaps,ts_td_infos} # {td_rhs,td_args,td_attrs,td_name,td_attribute} = common_defs.[glob_module].com_type_defs.[glob_object] # (th_vars, ts_var_store) = fresh_type_variables td_args (ts_type_heaps.th_vars, ts_var_store) (th_attrs, ts_attr_store) = fresh_attributes td_attrs (ts_type_heaps.th_attrs, ts_attr_store) copy_heaps = { ts_type_heaps & th_vars = th_vars, th_attrs = th_attrs } (cons_types, alg_type, ts_var_store, attr_env, copy_heaps) = fresh_symbol_types patterns common_defs.[glob_module].com_cons_defs ts_var_store copy_heaps = (cons_types, alg_type, attr_env, { ts & ts_var_store = ts_var_store, ts_attr_store = ts_attr_store, ts_type_heaps = copy_heaps }) // ---> ("freshAlgebraicType", alg_type, cons_types) where fresh_symbol_types [{ap_symbol={glob_object}}] cons_defs var_store copy_heaps # {cons_type = {st_args,st_attr_env,st_result}, cons_index, cons_exi_vars} = cons_defs.[glob_object.ds_index] (th_vars, var_store) = freshExistentialVariables cons_exi_vars (copy_heaps.th_vars, var_store) (attr_env, th_attrs) = fresh_environment st_attr_env ([], copy_heaps.th_attrs) (result_type, cs) = freshCopy st_result { copy_heaps = { copy_heaps & th_attrs = th_attrs, th_vars = th_vars } } (fresh_args, cs) = freshCopy st_args cs = ([fresh_args], result_type, var_store, attr_env, cs.copy_heaps) fresh_symbol_types [{ap_symbol={glob_object}} : patterns] cons_defs var_store copy_heaps # (cons_types, result_type, var_store, attr_env, copy_heaps) = fresh_symbol_types patterns cons_defs var_store copy_heaps {cons_type = {st_args,st_attr_env}, cons_index, cons_exi_vars} = cons_defs.[glob_object.ds_index] (th_vars, var_store) = freshExistentialVariables cons_exi_vars (copy_heaps.th_vars, var_store) (attr_env, th_attrs) = fresh_environment st_attr_env (attr_env, copy_heaps.th_attrs) (fresh_args, cs) = freshCopy st_args { copy_heaps = { copy_heaps & th_attrs = th_attrs, th_vars = th_vars }} = ([fresh_args : cons_types], result_type, var_store, attr_env, cs.copy_heaps) fresh_type_variables type_variables state = foldSt (\{atv_variable={tv_info_ptr}} (var_heap, var_store) -> (var_heap <:= (tv_info_ptr, TVI_Type (TempV var_store)), inc var_store)) type_variables state fresh_attributes attributes state = foldSt (\{av_info_ptr} (attr_heap, attr_store) -> (attr_heap <:= (av_info_ptr, AVI_Attr (TA_TempVar attr_store)), inc attr_store)) attributes state fresh_environment inequalities (attr_env, attr_heap) = foldSt fresh_inequality inequalities (attr_env, attr_heap) fresh_inequality {ai_demanded,ai_offered} (attr_env, attr_heap) # (AVI_Attr dem_temp_attr, attr_heap) = readPtr ai_demanded.av_info_ptr attr_heap (AVI_Attr off_temp_attr, attr_heap) = readPtr ai_offered.av_info_ptr attr_heap = case dem_temp_attr of TA_TempVar dem_attr_var -> case off_temp_attr of TA_TempVar off_attr_var | is_new_ineqality dem_attr_var off_attr_var attr_env -> ([{ac_demanded = dem_attr_var, ac_offered = off_attr_var} : attr_env ], attr_heap) -> (attr_env, attr_heap) _ -> (attr_env, attr_heap) _ -> (attr_env, attr_heap) is_new_ineqality dem_attr_var off_attr_var [{ac_demanded, ac_offered} : attr_env] = (dem_attr_var <> ac_demanded || off_attr_var <> ac_offered) && is_new_ineqality dem_attr_var off_attr_var attr_env is_new_ineqality dem_attr_var off_attr_var [] = True cWithFreshContextVars :== True cWithoutFreshContextVars :== False freshSymbolType :: !Bool !SymbolType {#u:CommonDefs} !*TypeState -> (!TempSymbolType,![Int],!*TypeState) freshSymbolType fresh_context_vars st=:{st_vars,st_args,st_result,st_context,st_attr_vars,st_attr_env,st_arity} common_defs ts=:{ts_var_store,ts_attr_store,ts_type_heaps,ts_td_infos,ts_var_heap} # (th_vars, ts_var_store) = fresh_type_variables st_vars (ts_type_heaps.th_vars, ts_var_store) (th_attrs, ts_attr_store) = fresh_attributes st_attr_vars (ts_type_heaps.th_attrs, ts_attr_store) (attr_env, th_attrs) = freshEnvironment st_attr_env th_attrs cs = { copy_heaps = { ts_type_heaps & th_vars = th_vars, th_attrs = th_attrs }} (tst_args, cs) = freshCopy st_args cs (tst_result, cs) = freshCopy st_result cs (tst_context, ({copy_heaps}, ts_var_heap)) = freshTypeContexts fresh_context_vars st_context (cs, ts_var_heap) cons_variables = foldSt (collect_cons_variables_in_tc common_defs) tst_context [] = ({ tst_args = tst_args, tst_result = tst_result, tst_context = tst_context, tst_attr_env = attr_env, tst_arity = st_arity, tst_lifted = 0 }, cons_variables, { ts & ts_var_store = ts_var_store, ts_attr_store = ts_attr_store, ts_type_heaps = copy_heaps, ts_var_heap = ts_var_heap}) //---> ("freshSymbolType", st, tst_args, tst_result, tst_context) where fresh_type_variables :: .[TypeVar] *(*Heap TypeVarInfo,.Int) -> (!.Heap TypeVarInfo,!Int); fresh_type_variables type_variables state = foldr (\{tv_info_ptr} (var_heap, var_store) -> (writePtr tv_info_ptr (TVI_Type (TempV var_store)) var_heap, inc var_store)) state type_variables fresh_attributes :: .[AttributeVar] *(*Heap AttrVarInfo,.Int) -> (!.Heap AttrVarInfo,!Int); fresh_attributes attributes state = foldr (\{av_info_ptr} (attr_heap, attr_store) -> (writePtr av_info_ptr (AVI_Attr (TA_TempVar attr_store)) attr_heap, inc attr_store)) state attributes collect_cons_variables_in_tc common_defs tc=:{tc_class={glob_module,glob_object={ds_index}}, tc_types} collected_cons_vars # {class_cons_vars} = common_defs.[glob_module].com_class_defs.[ds_index] = collect_cons_variables tc_types class_cons_vars collected_cons_vars collect_cons_variables [] class_cons_vars collected_cons_vars = collected_cons_vars collect_cons_variables [type : tc_types] class_cons_vars collected_cons_vars | class_cons_vars bitand 1 == 0 = collect_cons_variables tc_types (class_cons_vars >> 1) collected_cons_vars = case type of TempV temp_var_id -> collect_cons_variables tc_types (class_cons_vars >> 1) (add_variable temp_var_id collected_cons_vars) // ---> ("collect_cons_variables", temp_var_id) _ -> collect_cons_variables tc_types (class_cons_vars >> 1) collected_cons_vars add_variable new_var_id [] = [new_var_id] add_variable new_var_id vars=:[var_id : var_ids] | new_var_id == var_id = vars = [var_id : add_variable new_var_id var_ids] // JVG: added type: freshInequality :: AttrInequality *(Heap AttrVarInfo) -> (!AttrCoercion,!.Heap AttrVarInfo); freshInequality {ai_demanded,ai_offered} attr_heap # (av_dem_info, attr_heap) = readPtr ai_demanded.av_info_ptr attr_heap (av_off_info, attr_heap) = readPtr ai_offered.av_info_ptr attr_heap (AVI_Attr (TA_TempVar dem_attr_var)) = av_dem_info (AVI_Attr (TA_TempVar off_attr_var)) = av_off_info = ({ac_demanded = dem_attr_var, ac_offered = off_attr_var}, attr_heap) // <<- (av_dem_info,av_off_info) freshEnvironment [ineq : ineqs] attr_heap # (fresh_ineq, attr_heap) = freshInequality ineq attr_heap (fresh_env, attr_heap) = freshEnvironment ineqs attr_heap = ([fresh_ineq : fresh_env], attr_heap) freshEnvironment [] attr_heap = ([], attr_heap) freshTypeContexts fresh_context_vars tcs cs_and_var_heap = mapSt (fresh_type_context fresh_context_vars) tcs cs_and_var_heap where fresh_type_context fresh_context_vars tc=:{tc_types} (cs, var_heap) # (tc_types, cs) = mapSt fresh_context_type tc_types cs | fresh_context_vars # (new_info_ptr, var_heap) = newPtr VI_Empty var_heap = ({ tc & tc_types = tc_types, tc_var = new_info_ptr }, (cs, var_heap)) = ({ tc & tc_types = tc_types}, (cs, var_heap)) fresh_context_type (CV tv :@: types) cs=:{copy_heaps} # (fresh_cons_var, th_vars) = freshConsVariable tv copy_heaps.th_vars (types, cs) = freshCopy types { cs & copy_heaps = { copy_heaps & th_vars = th_vars }} = (fresh_cons_var :@: types, cs) fresh_context_type type cs = freshCopy type cs freshAttributedVariable :: !u:TypeState -> (!AType, !u:TypeState) freshAttributedVariable ts=:{ts_var_store,ts_attr_store} = ({ at_attribute = TA_TempVar ts_attr_store, at_annotation = AN_None, at_type = TempV ts_var_store }, {ts & ts_var_store = inc ts_var_store, ts_attr_store = inc ts_attr_store}) freshNonUniqueVariable :: !u:TypeState -> (!AType, !u:TypeState) freshNonUniqueVariable ts=:{ts_var_store} = ({ at_attribute = TA_Multi, at_annotation = AN_None, at_type = TempV ts_var_store }, {ts & ts_var_store = inc ts_var_store}) freshAttribute :: !u:TypeState -> (!TypeAttribute, !u:TypeState) freshAttribute ts=:{ts_attr_store} = (TA_TempVar ts_attr_store, {ts & ts_attr_store = inc ts_attr_store}) :: PropState = { prop_type_heaps :: !.TypeHeaps , prop_td_infos :: !.TypeDefInfos , prop_attr_vars :: ![AttributeVar] , prop_attr_env :: ![AttrInequality] , prop_error :: !.Optional .ErrorAdmin } attribute_error type_attr No = No // XXX abort ("sanity check nr 723 failed in module type"--->("type_attr", type_attr)) attribute_error type_attr (Yes err) # err = errorHeading "Type error" err = Yes { err & ea_file = err.ea_file <<< "* attribute expected instead of " <<< type_attr <<< '\n' } addPropagationAttributesToAType :: {#CommonDefs} !AType !*PropState -> *(!AType,Int,!*PropState); addPropagationAttributesToAType modules type=:{at_type = TA cons_id=:{type_index={glob_object,glob_module},type_name} cons_args, at_attribute} ps # (cons_args, props, ps=:{prop_td_infos,prop_type_heaps,prop_attr_vars,prop_attr_env,prop_error}) = add_propagation_attributes_to_atypes modules cons_args ps (prop_class, th_vars, prop_td_infos) = propClassification glob_object glob_module props modules prop_type_heaps.th_vars prop_td_infos (at_attribute, prop_class, th_attrs, prop_attr_vars, prop_attr_env, prop_error) = determine_attribute_of_cons modules at_attribute cons_args prop_class prop_type_heaps.th_attrs prop_attr_vars prop_attr_env prop_error ({tdi_kinds}, prop_td_infos) = prop_td_infos![glob_module,glob_object] prop_error = case prop_error of No // this function is called after typechecking (during transformations) -> No Yes error_admin # (_, error_admin) = unsafeFold2St (check_kind type_name modules) tdi_kinds cons_args (1, error_admin) -> Yes error_admin = ({ type & at_type = TA cons_id cons_args, at_attribute = at_attribute }, prop_class, { ps & prop_attr_vars = prop_attr_vars, prop_td_infos = prop_td_infos, prop_attr_env = prop_attr_env, prop_type_heaps = { prop_type_heaps & th_vars = th_vars, th_attrs = th_attrs}, prop_error = prop_error }) where add_propagation_attributes_to_atypes modules [] ps = ([], [], ps) add_propagation_attributes_to_atypes modules [atype : atypes] ps # (atype, prop_class, ps) = addPropagationAttributesToAType modules atype ps (atypes, prop_classes, ps) = add_propagation_attributes_to_atypes modules atypes ps = ([atype : atypes], [prop_class : prop_classes], ps) determine_attribute_of_cons modules TA_Unique cons_args prop_class attr_var_heap attr_vars attr_env ps_error = (TA_Unique, prop_class >> length cons_args, attr_var_heap, attr_vars, attr_env, ps_error) determine_attribute_of_cons modules cons_attr cons_args prop_class attr_var_heap attr_vars attr_env ps_error # (cumm_attr, prop_attrs, prop_class) = determine_cummulative_attribute cons_args TA_Multi [] prop_class (comb_attr, attr_var_heap, attr_vars, attr_env, ps_error) = combine_attributes cons_attr cumm_attr prop_attrs attr_var_heap attr_vars attr_env ps_error = (comb_attr, prop_class, attr_var_heap, attr_vars, attr_env, ps_error) determine_cummulative_attribute [] cumm_attr attr_vars prop_class = (cumm_attr, attr_vars, prop_class) determine_cummulative_attribute [{at_attribute} : types ] cumm_attr attr_vars prop_class | prop_class bitand 1 == 0 = determine_cummulative_attribute types cumm_attr attr_vars (prop_class >> 1) = case at_attribute of TA_Unique -> (TA_Unique, [], prop_class >> length types) TA_Multi -> determine_cummulative_attribute types cumm_attr attr_vars (prop_class >> 1) TA_Var attr_var -> determine_cummulative_attribute types at_attribute [attr_var : attr_vars] (prop_class >> 1) TA_MultiOfPropagatingConsVar -> determine_cummulative_attribute types cumm_attr attr_vars (prop_class >> 1) combine_attributes (TA_Var attr_var) cumm_attr prop_vars attr_var_heap attr_vars attr_env ps_error = case cumm_attr of TA_Unique -> (TA_Unique, attr_var_heap, attr_vars, attr_env, attribute_error attr_var ps_error) TA_Multi -> (TA_Var attr_var, attr_var_heap, attr_vars, attr_env, ps_error) TA_Var _ -> (TA_Var attr_var, attr_var_heap, attr_vars, foldSt (new_inequality attr_var) prop_vars attr_env, ps_error) where new_inequality off_attr_var dem_attr_var [] = [{ ai_demanded = dem_attr_var, ai_offered = off_attr_var }] new_inequality off_attr_var dem_attr_var ins=:[ inequal : iequals ] | dem_attr_var.av_info_ptr == inequal.ai_demanded.av_info_ptr && off_attr_var.av_info_ptr == inequal.ai_offered.av_info_ptr = ins = [ inequal : new_inequality off_attr_var dem_attr_var iequals ] combine_attributes _ (TA_Var var) prop_vars attr_var_heap attr_vars attr_env ps_error # (new_attr_ptr, attr_var_heap) = newPtr AVI_Empty attr_var_heap new_attr_var = { var & av_info_ptr = new_attr_ptr } = (TA_Var new_attr_var, attr_var_heap, [new_attr_var : attr_vars], mapAppend (\ai_demanded -> { ai_demanded = ai_demanded, ai_offered = new_attr_var }) prop_vars attr_env, ps_error) combine_attributes cons_attr TA_Unique _ attr_var_heap attr_vars attr_env ps_error = (TA_Unique, attr_var_heap, attr_vars, attr_env, ps_error) combine_attributes cons_attr _ _ attr_var_heap attr_vars attr_env ps_error = (cons_attr, attr_var_heap, attr_vars, attr_env, ps_error) check_kind type_name modules type_kind {at_type} (arg_nr, error_admin) # ok = kind_is_ok modules (my_kind_to_int type_kind) at_type | ok = (arg_nr+1, error_admin) # error_admin = errorHeading type_error error_admin = (arg_nr+1, { error_admin & ea_file = error_admin.ea_file <<< " argument " <<< arg_nr <<< " of type " <<< type_name <<< " expected kind " <<< type_kind <<< "\n" }) where kind_is_ok modules demanded_kind (TA {type_index={glob_object,glob_module}} args) # {td_arity} = modules.[glob_module].com_type_defs.[glob_object] = demanded_kind == td_arity-length args kind_is_ok modules 0 (_ --> _) = True kind_is_ok modules _ (_ :@: _) = True kind_is_ok modules 0 (TB _) = True kind_is_ok modules _ (GTV _) = True kind_is_ok modules _ (TV _) = True kind_is_ok modules _ (TQV _) = True kind_is_ok modules _ _ = False my_kind_to_int KindConst = 0 my_kind_to_int (KindArrow k) = length k addPropagationAttributesToAType modules type=:{at_type} ps # (at_type, ps) = addPropagationAttributesToType modules at_type ps = ({ type & at_type = at_type }, NoPropClass, ps) // MW probably = ({ type & at_type = at_type, at_annotation = AN_None }, NoPropClass, ps) addPropagationAttributesToType modules (arg_type --> res_type) ps # (arg_type, prop_class, ps) = addPropagationAttributesToAType modules arg_type ps (res_type, prop_class, ps) = addPropagationAttributesToAType modules res_type ps = (arg_type --> res_type, ps) addPropagationAttributesToType modules (type_var :@: types) ps # (types, ps) = addPropagationAttributesToATypes modules types ps = (type_var :@: types, ps) addPropagationAttributesToType modules type ps = (type, ps) addPropagationAttributesToATypes :: {#CommonDefs} ![AType] !*PropState -> (![AType],!*PropState) addPropagationAttributesToATypes modules types ps = mapSt (add_propagation_attributes_to_atype modules) types ps where add_propagation_attributes_to_atype modules type ps # (type, prop_class, ps) = addPropagationAttributesToAType modules type ps = (type, ps) :: Base :== {! AType} currySymbolType st=:{tst_args,tst_arity,tst_result,tst_attr_env} req_arity ts=:{ts_attr_store} | tst_arity == req_arity = (st, ts) # (tst_args, rest_args, is_unique) = split_args req_arity tst_args | is_unique # (type, _, _) = buildCurriedType rest_args tst_result TA_Unique [] 0 = ({ st & tst_args = tst_args, tst_arity = req_arity, tst_result = type }, ts) # (type, tst_attr_env, ts_attr_store) = buildCurriedType rest_args tst_result (TA_TempVar ts_attr_store) (build_attr_env ts_attr_store tst_args tst_attr_env) (inc ts_attr_store) = ({ st & tst_args = tst_args, tst_arity = req_arity, tst_result = type, tst_attr_env = tst_attr_env }, { ts & ts_attr_store = ts_attr_store }) where split_args 0 args = ([], args, False) split_args n [atype=:{at_attribute} : args] # (left, right, is_unique) = split_args (dec n) args = ([ atype : left ], right, is_unique || attr_is_unique at_attribute) attr_is_unique TA_Unique = True attr_is_unique _ = False build_attr_env cum_attr_var [] attr_env = attr_env build_attr_env cum_attr_var [{at_attribute=(TA_TempVar attr_var)} : args] attr_env = build_attr_env cum_attr_var args [{ ac_demanded = attr_var, ac_offered = cum_attr_var } : attr_env] build_attr_env cum_attr_var [_ : args] attr_env = build_attr_env cum_attr_var args attr_env emptyIdent =: { id_name = "", id_info = nilPtr } buildCurriedType [] type cum_attr attr_env attr_store = (type, attr_env, attr_store) buildCurriedType [at=:{at_attribute}:ats] type cum_attr attr_env attr_store # (next_cum_attr, attr_env, attr_store) = combine_attributes at_attribute cum_attr attr_env attr_store (res_type, attr_env, attr_store) = buildCurriedType ats type next_cum_attr attr_env attr_store = ({at_annotation = AN_None, at_attribute = cum_attr , at_type = at --> res_type }, attr_env, attr_store) where combine_attributes TA_Unique cum_attr attr_env attr_store = (TA_Unique, attr_env, attr_store) combine_attributes (TA_TempVar attr_var) (TA_TempVar cum_attr_var) attr_env attr_store = (TA_TempVar attr_store, [{ ac_demanded = cum_attr_var,ac_offered = attr_store },{ ac_demanded = attr_var,ac_offered = attr_store }:attr_env], inc attr_store) combine_attributes (TA_TempVar _) cum_attr attr_env attr_store = (cum_attr, attr_env, attr_store) combine_attributes _ (TA_TempVar cum_attr_var) attr_env attr_store = (TA_TempVar attr_store, [{ ac_demanded = cum_attr_var,ac_offered = attr_store }:attr_env], inc attr_store) combine_attributes _ cum_attr attr_env attr_store = (cum_attr, attr_env, attr_store) determineSymbolTypeOfFunction ident act_arity st=:{st_args,st_result,st_attr_vars,st_attr_env} type_ptr common_defs ts=:{ts_var_heap} # (type_info, ts_var_heap) = readPtr type_ptr ts_var_heap ts = { ts & ts_var_heap = ts_var_heap } = case type_info of VI_PropagationType symb_type # (copy_symb_type, cons_variables, ts) = freshSymbolType cWithFreshContextVars symb_type common_defs ts (curried_st, ts) = currySymbolType copy_symb_type act_arity ts -> (curried_st, cons_variables, ts) _ # (st_args, ps) = addPropagationAttributesToATypes common_defs st_args { prop_type_heaps = ts.ts_type_heaps, prop_td_infos = ts.ts_td_infos, prop_attr_vars = st_attr_vars, prop_attr_env = st_attr_env, prop_error = Yes ts.ts_error} (st_result, _, {prop_type_heaps,prop_td_infos,prop_attr_vars,prop_error = Yes ts_error,prop_attr_env}) = addPropagationAttributesToAType common_defs st_result ps st = { st & st_args = st_args, st_result = st_result, st_attr_vars = prop_attr_vars, st_attr_env = prop_attr_env } # (copy_symb_type, cons_variables, ts) = freshSymbolType cWithFreshContextVars st common_defs { ts & ts_type_heaps = prop_type_heaps, ts_td_infos = prop_td_infos, ts_error = ts_error, ts_var_heap = ts.ts_var_heap <:= (type_ptr, VI_PropagationType st) } (curried_st, ts) = currySymbolType copy_symb_type act_arity ts -> (curried_st, cons_variables, ts) standardFieldSelectorType {glob_object={ds_ident,ds_index},glob_module} {ti_common_defs} ts=:{ts_var_store,ts_type_heaps} #! {sd_type,sd_exi_vars} = ti_common_defs.[glob_module].com_selector_defs.[ds_index] # (th_vars, ts_var_store) = freshExistentialVariables sd_exi_vars (ts_type_heaps.th_vars, ts_var_store) (inst, cons_variables, ts) = freshSymbolType cWithFreshContextVars sd_type ti_common_defs { ts & ts_type_heaps = { ts_type_heaps & th_vars = th_vars }, ts_var_store = ts_var_store } = (inst, ts) // ---> ("standardFieldSelectorType", ds_ident, inst) standardTupleSelectorType {ds_index} arg_nr {ti_common_defs} ts #! {cons_type} = ti_common_defs.[cPredefinedModuleIndex].com_cons_defs.[ds_index] (fresh_type, cons_variables, ts) = freshSymbolType cWithFreshContextVars { cons_type & st_args = [cons_type.st_result], st_result = cons_type.st_args !! arg_nr } ti_common_defs ts = (fresh_type, ts) standardRhsConstructorType index mod arity {ti_common_defs} ts #! {cons_symb, cons_type, cons_exi_vars } = ti_common_defs.[mod].com_cons_defs.[index] # cons_type = { cons_type & st_vars = mapAppend (\{atv_variable} -> atv_variable) cons_exi_vars cons_type.st_vars } (fresh_type, _, ts) = freshSymbolType cWithFreshContextVars cons_type ti_common_defs ts = currySymbolType fresh_type arity ts // ---> ("standardRhsConstructorType", cons_symb, fresh_type) standardLhsConstructorType index mod arity {ti_common_defs} ts=:{ts_var_store,ts_type_heaps} #! {cons_symb, cons_type, cons_exi_vars } = ti_common_defs.[mod].com_cons_defs.[index] # (th_vars, ts_var_store) = freshExistentialVariables cons_exi_vars (ts_type_heaps.th_vars, ts_var_store) (fresh_type, _, ts) = freshSymbolType cWithFreshContextVars cons_type ti_common_defs { ts & ts_type_heaps = { ts_type_heaps & th_vars = th_vars }, ts_var_store = ts_var_store } = (fresh_type, ts) // ---> ("standardLhsConstructorType", cons_symb, fresh_type) :: ReferenceMarking :== Bool cIsRecursive :== True cIsNotRecursive :== False storeAttribute (Yes expt_ptr) type_attribute symbol_heap = symbol_heap <:= (expt_ptr, EI_Attribute (toInt type_attribute)) storeAttribute No type_attribute symbol_heap = symbol_heap getSymbolType ti=:{ti_functions,ti_common_defs,ti_main_dcl_module_n} {symb_kind = SK_Function {glob_module,glob_object}, symb_arity, symb_name} ts | glob_module == ti_main_dcl_module_n | glob_object>=size ts.ts_fun_env = abort symb_name.id_name; # (fun_type, ts) = ts!ts_fun_env.[glob_object] = case fun_type of UncheckedType fun_type # (fun_type_copy, ts) = currySymbolType fun_type symb_arity ts -> (fun_type_copy, [], [], ts) SpecifiedType fun_type lifted_arg_types _ # (fun_type_copy=:{tst_args,tst_arity}, cons_variables, ts) = freshSymbolType cWithoutFreshContextVars fun_type ti_common_defs ts (fun_type_copy, ts) = currySymbolType { fun_type_copy & tst_args = lifted_arg_types ++ fun_type_copy.tst_args, tst_arity = tst_arity + length lifted_arg_types } symb_arity ts -> (fun_type_copy, cons_variables, [], ts) CheckedType fun_type # (fun_type_copy, cons_variables, ts) = freshSymbolType cWithFreshContextVars fun_type ti_common_defs ts (fun_type_copy,ts) = currySymbolType fun_type_copy symb_arity ts -> (fun_type_copy, cons_variables, [], ts) _ -> abort ("getSymbolType: SK_Function "+++toString symb_name+++" "+++toString glob_object) // -> abort "getSymbolType (type.icl)" ---> (symb_name, glob_object, fun_type) # {ft_type,ft_type_ptr,ft_specials} = ti_functions.[glob_module].[glob_object] | glob_module>=size ti_functions || glob_object>=size ti_functions.[glob_module] = abort (toString glob_module+++" "+++toString glob_object+++" "+++toString ti_main_dcl_module_n+++" "+++symb_name.id_name); # (fun_type_copy, cons_variables, ts) = determineSymbolTypeOfFunction symb_name symb_arity ft_type ft_type_ptr ti_common_defs ts = (fun_type_copy, cons_variables, get_specials ft_specials, ts) where get_specials (SP_ContextTypes specials) = specials get_specials SP_None = [] getSymbolType ti {symb_kind = SK_Constructor {glob_module,glob_object}, symb_arity} ts # (fresh_cons_type, ts) = standardRhsConstructorType glob_object glob_module symb_arity ti ts = (fresh_cons_type, [], [], ts) getSymbolType ti=:{ti_functions,ti_common_defs,ti_main_dcl_module_n} {symb_kind = SK_LocalMacroFunction glob_object, symb_arity, symb_name} ts | glob_object>=size ts.ts_fun_env = abort symb_name.id_name; # (fun_type, ts) = ts!ts_fun_env.[glob_object] = case fun_type of UncheckedType fun_type # (fun_type_copy, ts) = currySymbolType fun_type symb_arity ts -> (fun_type_copy, [], [], ts) SpecifiedType fun_type lifted_arg_types _ # (fun_type_copy=:{tst_args,tst_arity}, cons_variables, ts) = freshSymbolType cWithoutFreshContextVars fun_type ti_common_defs ts (fun_type_copy, ts) = currySymbolType { fun_type_copy & tst_args = lifted_arg_types ++ fun_type_copy.tst_args, tst_arity = tst_arity + length lifted_arg_types } symb_arity ts -> (fun_type_copy, cons_variables, [], ts) CheckedType fun_type # (fun_type_copy, cons_variables, ts) = freshSymbolType cWithFreshContextVars fun_type ti_common_defs ts (fun_type_copy,ts) = currySymbolType fun_type_copy symb_arity ts -> (fun_type_copy, cons_variables, [], ts) _ -> abort ("getSymbolType SK_LocalMacroFunction: "+++toString symb_name+++" " +++toString glob_object) // -> abort "getSymbolType (type.icl)" ---> (symb_name, glob_object, fun_type) getSymbolType ti=:{ti_common_defs} {symb_kind = SK_OverloadedFunction {glob_module,glob_object}, symb_arity} ts # {me_symb, me_type,me_type_ptr} = ti_common_defs.[glob_module].com_member_defs.[glob_object] (fun_type_copy, cons_variables, ts) = determineSymbolTypeOfFunction me_symb symb_arity me_type me_type_ptr ti_common_defs ts = (fun_type_copy, cons_variables, [], ts) // AA.. getSymbolType ti=:{ti_common_defs} symbol=:{symb_kind = SK_Generic gen_glob kind} ts # (found, member_glob) = getGenericMember gen_glob kind ti_common_defs | not found = abort "getSymbolType: no class for kind" = getSymbolType ti {symbol & symb_kind = SK_OverloadedFunction member_glob} ts // ..AA class requirements a :: !TypeInput !a !(!u:Requirements, !*TypeState) -> (!AType, !Optional ExprInfoPtr, !(!u:Requirements, !*TypeState)) instance requirements BoundVar where requirements ti {var_name,var_info_ptr,var_expr_ptr} (reqs, ts) # (var_info, ts_var_heap) = readPtr var_info_ptr ts.ts_var_heap ts = { ts & ts_var_heap = ts_var_heap } = (case var_info of VI_Type type _ -> type _ -> abort "requirements BoundVar " // ---> (var_name <<- var_info)) , Yes var_expr_ptr, (reqs, ts)) instance requirements App where requirements ti {app_symb,app_args,app_info_ptr} (reqs=:{req_cons_variables, req_attr_coercions}, ts) # (tst=:{tst_attr_env,tst_args,tst_result,tst_context}, cons_variables, specials, ts) = getSymbolType ti app_symb ts reqs = { reqs & req_attr_coercions = tst_attr_env ++ req_attr_coercions, req_cons_variables = [cons_variables : req_cons_variables] } (reqs, ts) = requirements_of_args ti app_symb.symb_name 1 app_args tst_args (reqs, ts) | isEmpty tst_context = (tst_result, No, (reqs, ts)) = (tst_result, No, ({ reqs & req_overloaded_calls = [app_info_ptr : reqs.req_overloaded_calls ]}, { ts & ts_expr_heap = ts.ts_expr_heap <:= (app_info_ptr, EI_Overloaded { oc_symbol = app_symb, oc_context = tst_context, oc_specials = specials })})) where requirements_of_args :: !TypeInput !Ident !Int ![Expression] ![AType] !(!u:Requirements, !*TypeState) -> (!u:Requirements, !*TypeState) requirements_of_args ti _ _ [] [] reqs_ts = reqs_ts requirements_of_args ti fun_ident arg_nr [expr:exprs] [lt:lts] reqs_ts # (e_type, opt_expr_ptr, (reqs, ts)) = requirements ti expr reqs_ts req_type_coercions = [{ tc_demanded = lt, tc_offered = e_type, tc_position = CP_FunArg fun_ident arg_nr, tc_coercible = True } : reqs.req_type_coercions ] ts_expr_heap = storeAttribute opt_expr_ptr lt.at_attribute ts.ts_expr_heap = requirements_of_args ti fun_ident (arg_nr+1) exprs lts ({ reqs & req_type_coercions = req_type_coercions}, { ts & ts_expr_heap = ts_expr_heap }) instance requirements Case where requirements ti {case_expr,case_guards,case_default,case_info_ptr, case_default_pos} reqs_ts # (expr_type, opt_expr_ptr, (reqs, ts)) = requirements ti case_expr reqs_ts (fresh_v, ts) = freshAttributedVariable ts (cons_types, reqs_ts) = requirements_of_guarded_expressions ti case_guards case_expr expr_type opt_expr_ptr fresh_v (reqs, ts) (reqs, ts) = requirements_of_default ti case_default case_default_pos fresh_v reqs_ts ts_expr_heap = ts.ts_expr_heap <:= (case_info_ptr, EI_CaseType { ct_pattern_type = expr_type, ct_result_type = fresh_v, ct_cons_types = cons_types }) = (fresh_v, No, ({ reqs & req_case_and_let_exprs = [case_info_ptr : reqs.req_case_and_let_exprs]}, { ts & ts_expr_heap = ts_expr_heap })) where requirements_of_guarded_expressions ti=:{ti_common_defs} (AlgebraicPatterns alg_type patterns) match_expr pattern_type opt_pattern_ptr goal_type (reqs, ts) # (cons_types, result_type, new_attr_env, ts) = freshAlgebraicType alg_type patterns ti_common_defs ts (used_cons_types, (reqs, ts)) = requirements_of_algebraic_patterns ti patterns cons_types goal_type [] (reqs, ts) ts_expr_heap = storeAttribute opt_pattern_ptr result_type.at_attribute ts.ts_expr_heap (position, ts_var_heap) = getPositionOfExpr match_expr ts.ts_var_heap = (reverse used_cons_types, ({ reqs & req_type_coercions = [{tc_demanded = result_type,tc_offered = pattern_type, tc_position = position, tc_coercible = True} : reqs.req_type_coercions], req_attr_coercions = new_attr_env ++ reqs.req_attr_coercions }, { ts & ts_expr_heap = ts_expr_heap, ts_var_heap = ts_var_heap })) requirements_of_guarded_expressions ti (BasicPatterns bas_type patterns) match_expr pattern_type opt_pattern_ptr goal_type (reqs, ts) # (attr_bas_type, ts) = attributedBasicType bas_type ts (reqs, ts) = requirements_of_basic_patterns ti patterns goal_type (reqs, ts) ts_expr_heap = storeAttribute opt_pattern_ptr attr_bas_type.at_attribute ts.ts_expr_heap = ([], ({ reqs & req_type_coercions = [{tc_demanded = attr_bas_type,tc_offered = pattern_type, tc_position = CP_Expression match_expr, tc_coercible = True} : reqs.req_type_coercions]}, { ts & ts_expr_heap = ts_expr_heap })) requirements_of_guarded_expressions ti (DynamicPatterns dynamic_patterns) match_expr pattern_type opt_pattern_ptr goal_type reqs_ts # dyn_type = { at_type = TB BT_Dynamic, at_attribute = TA_Multi, at_annotation = AN_None } (used_dyn_types, (reqs, ts)) = requirements_of_dynamic_patterns ti goal_type dynamic_patterns [] reqs_ts ts_expr_heap = storeAttribute opt_pattern_ptr TA_Multi ts.ts_expr_heap = (reverse used_dyn_types, ({ reqs & req_type_coercions = [{tc_demanded = dyn_type, tc_offered = pattern_type, tc_position = CP_Expression match_expr, tc_coercible = True} : reqs.req_type_coercions] }, { ts & ts_expr_heap = ts_expr_heap })) requirements_of_algebraic_patterns ti [] cons_types goal_type used_cons_types reqs_ts = (used_cons_types, reqs_ts) requirements_of_algebraic_patterns ti [alg_pattern=:{ap_position}:alg_patterns] [ cons_arg_types : cons_types] goal_type used_cons_types reqs_ts = requirements_of_algebraic_patterns ti alg_patterns cons_types goal_type [ cons_arg_types : used_cons_types ] (possibly_accumulate_reqs_in_new_group ap_position (requirements_of_algebraic_pattern ti alg_pattern cons_arg_types goal_type) reqs_ts ) requirements_of_algebraic_pattern ti {ap_symbol, ap_vars, ap_expr} cons_arg_types goal_type (reqs, ts) # (res_type, opt_expr_ptr, (reqs, ts)) = requirements ti ap_expr (reqs, { ts & ts_var_heap = makeBase ap_symbol.glob_object.ds_ident 1 ap_vars cons_arg_types ts.ts_var_heap}) ts_expr_heap = storeAttribute opt_expr_ptr res_type.at_attribute ts.ts_expr_heap = ({ reqs & req_type_coercions = [ { tc_demanded = goal_type, tc_offered = res_type, tc_position = CP_Expression ap_expr, tc_coercible = True } : reqs.req_type_coercions] }, { ts & ts_expr_heap = ts_expr_heap }) requirements_of_basic_patterns _ [] goal_type reqs_ts = reqs_ts requirements_of_basic_patterns ti [{bp_expr, bp_position}:gs] goal_type reqs_ts = requirements_of_basic_patterns ti gs goal_type (possibly_accumulate_reqs_in_new_group bp_position (requirements_of_basic_pattern ti bp_expr goal_type) reqs_ts ) requirements_of_basic_pattern ti bp_expr goal_type reqs_ts # (res_type, opt_expr_ptr, (reqs, ts)) = requirements ti bp_expr reqs_ts ts_expr_heap = storeAttribute opt_expr_ptr res_type.at_attribute ts.ts_expr_heap = ({ reqs & req_type_coercions = [ { tc_demanded = goal_type, tc_offered = res_type, tc_position = CP_Expression bp_expr, tc_coercible = True } : reqs.req_type_coercions] }, { ts & ts_expr_heap = ts_expr_heap }) requirements_of_dynamic_patterns ti goal_type [] used_dyn_types reqs_ts = (used_dyn_types, reqs_ts) requirements_of_dynamic_patterns ti goal_type [dp=:{dp_position, dp_type} : dps] used_dyn_types (reqs, ts=:{ts_expr_heap}) # (EI_TempDynamicPattern _ _ _ _ dyn_type dyn_context dyn_expr_ptr type_code_symbol, ts_expr_heap) = readPtr dp_type ts_expr_heap (reqs_ts) = possibly_accumulate_reqs_in_new_group dp_position (requirements_of_dynamic_pattern dyn_type dyn_context dyn_expr_ptr type_code_symbol ti goal_type dp) (reqs, { ts & ts_expr_heap = ts_expr_heap}) = requirements_of_dynamic_patterns ti goal_type dps [ [dyn_type] : used_dyn_types ] reqs_ts requirements_of_dynamic_pattern dyn_type dyn_context dyn_expr_ptr type_code_symbol ti goal_type {dp_var={fv_info_ptr},dp_rhs} (reqs, ts=:{ts_expr_heap, ts_var_heap}) # ts_var_heap = ts_var_heap <:= (fv_info_ptr, VI_Type dyn_type No) (dp_rhs_type, opt_expr_ptr, (reqs, ts)) = requirements ti dp_rhs (reqs, { ts & ts_expr_heap = ts_expr_heap, ts_var_heap = ts_var_heap }) ts_expr_heap = storeAttribute opt_expr_ptr dp_rhs_type.at_attribute ts.ts_expr_heap type_coercion = { tc_demanded = goal_type, tc_offered = dp_rhs_type, tc_position = CP_Expression dp_rhs, tc_coercible = True } | isEmpty dyn_context # reqs = {reqs & req_type_coercions = [ type_coercion : reqs.req_type_coercions]} = (reqs, { ts & ts_expr_heap = ts_expr_heap }) # reqs = { reqs & req_type_coercions = [ type_coercion : reqs.req_type_coercions], req_overloaded_calls = [dyn_expr_ptr : reqs.req_overloaded_calls ]} = (reqs, { ts & ts_expr_heap = ts_expr_heap <:= (dyn_expr_ptr, EI_Overloaded { oc_symbol = type_code_symbol, oc_context = dyn_context, oc_specials = [] }) }) requirements_of_default ti (Yes expr) case_default_pos goal_type reqs_ts = possibly_accumulate_reqs_in_new_group case_default_pos (reqs_of_default ti expr goal_type) reqs_ts requirements_of_default ti No _ goal_type reqs_ts = reqs_ts reqs_of_default ti expr goal_type reqs_ts # (res_type, opt_expr_ptr, (reqs, ts)) = requirements ti expr reqs_ts ts_expr_heap = storeAttribute opt_expr_ptr res_type.at_attribute ts.ts_expr_heap = ({ reqs & req_type_coercions = [ { tc_demanded = goal_type, tc_offered = res_type, tc_position = CP_Expression expr, tc_coercible = True } : reqs.req_type_coercions] }, { ts & ts_expr_heap = ts_expr_heap }) instance requirements Let where requirements ti {let_lazy_binds, let_strict_binds, let_expr, let_info_ptr, let_expr_position } (reqs, ts) # let_binds = let_strict_binds ++ let_lazy_binds (rev_var_types, ts) = make_base let_binds [] ts var_types = reverse rev_var_types (reqs, ts) = requirements_of_binds NoPos ti let_binds var_types (reqs, ts) (res_type, opt_expr_ptr, (reqs, ts)) = requirements_of_let_expr let_expr_position ti let_expr (reqs, ts) ts_expr_heap = writePtr let_info_ptr (EI_LetType var_types) ts.ts_expr_heap = ( res_type, opt_expr_ptr, ({ reqs & req_case_and_let_exprs = [let_info_ptr : reqs.req_case_and_let_exprs]},{ ts & ts_expr_heap = ts_expr_heap })) where make_base [{lb_src, lb_dst={fv_name, fv_info_ptr}}:bs] var_types ts=:{ts_var_heap} # (v, ts) = freshAttributedVariable ts optional_position = if (is_rare_name fv_name) (Yes (CP_Expression lb_src)) No = make_base bs [v:var_types] { ts & ts_var_heap = writePtr fv_info_ptr (VI_Type v optional_position) ts.ts_var_heap } make_base [] var_types ts = (var_types, ts) requirements_of_binds _ _ [] _ reqs_ts = reqs_ts requirements_of_binds last_position ti [{lb_src, lb_position}:bs] [b_type:bts] reqs_ts # position = if (is_a_new_position lb_position last_position) lb_position NoPos reqs_ts = possibly_accumulate_reqs_in_new_group position (requirements_of_bind b_type ti lb_src) reqs_ts = requirements_of_binds lb_position ti bs bts reqs_ts where is_a_new_position (LinePos _ line_nr1) (LinePos _ line_nr2) = line_nr1<>line_nr2 is_a_new_position (FunPos _ line_nr1 _) (FunPos _ line_nr2 _) = line_nr1<>line_nr2 is_a_new_position _ _ = True requirements_of_bind b_type ti lb_src reqs_ts # (exp_type, opt_expr_ptr, (reqs, ts)) = requirements ti lb_src reqs_ts ts_expr_heap = storeAttribute opt_expr_ptr b_type.at_attribute ts.ts_expr_heap req_type_coercions = [ { tc_demanded = b_type, tc_offered = exp_type, tc_position = CP_Expression lb_src, tc_coercible = True } : reqs.req_type_coercions ] = ({ reqs & req_type_coercions = req_type_coercions }, { ts & ts_expr_heap = ts_expr_heap }) requirements_of_let_expr NoPos ti let_expr reqs_ts = requirements ti let_expr reqs_ts requirements_of_let_expr let_expr_position ti let_expr (reqs=:{req_type_coercions=old_req_type_coercions}, ts) # reqs_with_empty_accu = { reqs & req_type_coercions = [] } (res_type, opt_expr_ptr, (reqs_with_new_group_in_accu, ts)) = requirements ti let_expr (reqs_with_empty_accu, ts) new_group = { tcg_type_coercions = reqs_with_new_group_in_accu.req_type_coercions, tcg_position = let_expr_position } reqs_with_new_group = { reqs_with_new_group_in_accu & req_type_coercion_groups = [new_group:reqs_with_new_group_in_accu.req_type_coercion_groups], req_type_coercions = old_req_type_coercions } = (res_type, opt_expr_ptr, (reqs_with_new_group, ts)) instance requirements DynamicExpr where requirements ti {dyn_expr,dyn_info_ptr} (reqs, ts=:{ts_expr_heap}) # (EI_TempDynamicType _ dyn_type dyn_context dyn_expr_ptr type_code_symbol, ts_expr_heap) = readPtr dyn_info_ptr ts_expr_heap (dyn_expr_type, opt_expr_ptr, (reqs, ts)) = requirements ti dyn_expr (reqs, { ts & ts_expr_heap = ts_expr_heap }) ts_expr_heap = storeAttribute opt_expr_ptr dyn_expr_type.at_attribute ts.ts_expr_heap type_coercion = { tc_demanded = dyn_type, tc_offered = dyn_expr_type, tc_position = CP_Expression dyn_expr, tc_coercible = True } | isEmpty dyn_context = ({ at_type = TB BT_Dynamic, at_attribute = TA_Multi, at_annotation = AN_None }, No, ({reqs & req_type_coercions = [ type_coercion : reqs.req_type_coercions]}, { ts & ts_expr_heap = ts_expr_heap })) = ({ at_type = TB BT_Dynamic, at_attribute = TA_Multi, at_annotation = AN_None }, No, ({ reqs & req_type_coercions = [ type_coercion : reqs.req_type_coercions], req_overloaded_calls = [dyn_expr_ptr : reqs.req_overloaded_calls ]}, { ts & ts_expr_heap = ts_expr_heap <:= (dyn_expr_ptr, EI_Overloaded { oc_symbol = type_code_symbol, oc_context = dyn_context, oc_specials = []}) })) instance requirements Expression where requirements ti (Var var) reqs_ts = requirements ti var reqs_ts requirements ti (App app) reqs_ts = requirements ti app reqs_ts requirements ti (function @ args) reqs_ts # (off_fun_type, opt_fun_expr_ptr, reqs_ts) = requirements ti function reqs_ts (rev_off_arg_types, (reqs, ts)) = requirements_of_list ti args [] reqs_ts (alpha, ts) = freshAttributedVariable ts (fun_type, req_type_coercions, ts) = apply_type rev_off_arg_types alpha reqs.req_type_coercions function ts ts_expr_heap = storeAttribute opt_fun_expr_ptr fun_type.at_attribute ts.ts_expr_heap = (alpha, No, ({ reqs & req_type_coercions = [{ tc_demanded = fun_type, tc_offered = off_fun_type, tc_position = CP_Expression function, tc_coercible = True } : req_type_coercions ]}, { ts & ts_expr_heap = ts_expr_heap })) where requirements_of_list _ [] rev_list_types reqs_ts = (rev_list_types, reqs_ts) requirements_of_list ti [expr:exprs] rev_list_types reqs_ts # (e_type, opt_expr_ptr, reqs_ts) = requirements ti expr reqs_ts = requirements_of_list ti exprs [(opt_expr_ptr,e_type) : rev_list_types] reqs_ts apply_type [] res_type type_coercions function ts = (res_type, type_coercions, ts) apply_type [(opt_expr_ptr,type) : types] res_type type_coercions function ts # (type, type_coercions, ts) = determine_demanded_type type opt_expr_ptr type_coercions function ts (u, ts) = freshAttribute ts = apply_type types { at_annotation = AN_None, at_attribute = u, at_type = type --> res_type } type_coercions function ts determine_demanded_type :: !AType !(Optional ExprInfoPtr) ![TypeCoercion] !Expression !*TypeState -> (!AType, ![TypeCoercion], !*TypeState) determine_demanded_type type (Yes expr_ptr) type_coercions expr ts # (dem_type, ts) = freshAttributedVariable ts ts_expr_heap = writePtr expr_ptr (EI_Attribute (toInt dem_type.at_attribute)) ts.ts_expr_heap = (dem_type, [ { tc_demanded = dem_type, tc_offered = type, tc_position = CP_Expression expr, tc_coercible = True } : type_coercions ], { ts & ts_expr_heap = ts_expr_heap }) determine_demanded_type type No type_coercions expr ts = (type, type_coercions, ts) requirements ti (Case kees) reqs_ts = requirements ti kees reqs_ts requirements ti (Let lad) reqs_ts = requirements ti lad reqs_ts requirements ti (DynamicExpr dienamic) reqs_ts = requirements ti dienamic reqs_ts requirements ti (Selection result_type_symb expr selectors) reqs_ts # (expr_type, opt_expr_ptr, (reqs, ts)) = requirements ti expr reqs_ts = case result_type_symb of Yes {glob_object={ds_ident,ds_index,ds_arity}, glob_module} # (var, ts) = freshAttributedVariable ts (result_type, (reqs, ts)) = requirementsOfSelectors ti No expr selectors False var expr (reqs, ts) tuple_type = MakeTypeSymbIdent { glob_object = ds_index, glob_module = glob_module } ds_ident ds_arity non_unique_type_var = { at_attribute = TA_Multi, at_annotation = AN_None, at_type = TempV ts.ts_var_store } req_type_coercions = [ { tc_demanded = non_unique_type_var, tc_offered = result_type, tc_position = CP_Expression expr, tc_coercible = False }, { tc_demanded = var, tc_offered = expr_type, tc_position = CP_Expression expr, tc_coercible = True } : reqs.req_type_coercions] result_type = { at_type = TA tuple_type [non_unique_type_var,var], at_attribute = TA_Unique, at_annotation = AN_None } -> (result_type, No, ({ reqs & req_type_coercions = req_type_coercions }, {ts & ts_var_store = inc ts.ts_var_store, ts_expr_heap = storeAttribute opt_expr_ptr TA_Multi ts.ts_expr_heap})) _ # (result_type, reqs_ts) = requirementsOfSelectors ti No expr selectors True expr_type expr (reqs, ts) -> (result_type, opt_expr_ptr, reqs_ts) requirements ti (Update composite_expr selectors elem_expr) reqs_ts # (composite_expr_type, opt_composite_expr_ptr, reqs_ts) = requirements ti composite_expr reqs_ts (result_type, reqs_ts) = requirementsOfSelectors ti (Yes elem_expr) composite_expr selectors True composite_expr_type composite_expr reqs_ts = (composite_expr_type, opt_composite_expr_ptr, reqs_ts) requirements ti (RecordUpdate {glob_module,glob_object={ds_index,ds_arity}} expression expressions) (reqs, ts) # (lhs, ts) = standardLhsConstructorType ds_index glob_module ds_arity ti ts (rhs, ts) = standardRhsConstructorType ds_index glob_module ds_arity ti ts (expression_type, opt_expr_ptr, reqs_ts) = requirements ti expression (reqs, ts) (reqs, ts) = requirements_of_fields ti expression expressions rhs.tst_args lhs.tst_args reqs_ts ts = { ts & ts_expr_heap = storeAttribute opt_expr_ptr lhs.tst_result.at_attribute ts.ts_expr_heap } coercion = { tc_demanded = lhs.tst_result, tc_offered = expression_type, tc_position = CP_Expression expression, tc_coercible = True } = (rhs.tst_result, No, ({ reqs & req_attr_coercions = rhs.tst_attr_env ++ lhs.tst_attr_env ++ reqs.req_attr_coercions, req_type_coercions = [ coercion : reqs.req_type_coercions ]}, ts)) where requirements_of_fields ti expression [] _ _ reqs_ts = reqs_ts requirements_of_fields ti expression [field : fields] [dem_type : dem_types] [off_type : off_types] reqs_ts # reqs_ts = requirements_of_field ti expression field dem_type off_type reqs_ts = requirements_of_fields ti expression fields dem_types off_types reqs_ts requirements_of_field ti expression {bind_src=NoBind expr_ptr} dem_field_type off_field_type (reqs=:{req_type_coercions}, ts) # ts = { ts & ts_expr_heap = ts.ts_expr_heap <:= (expr_ptr, EI_Attribute (toInt dem_field_type.at_attribute)) } coercion = { tc_demanded = dem_field_type, tc_offered = off_field_type, tc_position = CP_Expression expression, tc_coercible = True } = ({ reqs & req_type_coercions = [ coercion : req_type_coercions ]}, ts) requirements_of_field ti _ {bind_src} dem_field_type _ reqs_ts # (expr_type, opt_expr_ptr, (reqs, ts)) = requirements ti bind_src reqs_ts ts = { ts & ts_expr_heap = storeAttribute opt_expr_ptr dem_field_type.at_attribute ts.ts_expr_heap } coercion = { tc_demanded = dem_field_type, tc_offered = expr_type, tc_position = CP_Expression bind_src, tc_coercible = True } = ({ reqs & req_type_coercions = [ coercion : reqs.req_type_coercions ]}, ts) requirements ti (TupleSelect tuple_symbol arg_nr expr) (reqs=:{req_attr_coercions}, ts) # ({tst_args = [argtype:_], tst_result, tst_attr_env}, ts) = standardTupleSelectorType tuple_symbol arg_nr ti ts (e_type, opt_expr_ptr, (reqs, ts)) = requirements ti expr ({ reqs & req_attr_coercions = tst_attr_env ++ req_attr_coercions }, ts) (position, ts_var_heap) = getPositionOfExpr expr ts.ts_var_heap req_type_coercions = [{ tc_demanded = argtype, tc_offered = e_type, tc_position = position, tc_coercible = True } : reqs.req_type_coercions ] ts_expr_heap = storeAttribute opt_expr_ptr argtype.at_attribute ts.ts_expr_heap = (tst_result, No, ({ reqs & req_type_coercions = req_type_coercions }, { ts & ts_expr_heap = ts_expr_heap, ts_var_heap = ts_var_heap })) requirements _ (BasicExpr basic_val basic_type) (reqs, ts) # (type, ts) = attributedBasicType basic_type ts = (type, No, (reqs, ts)) requirements ti (MatchExpr opt_tuple_type {glob_object={ds_arity, ds_index},glob_module} expr) (reqs, ts) # ({tst_result,tst_args,tst_attr_env}, ts) = standardLhsConstructorType ds_index glob_module ds_arity ti ts (e_type, opt_expr_ptr, (reqs, ts)) = requirements ti expr (reqs, ts) reqs = { reqs & req_attr_coercions = tst_attr_env ++ reqs.req_attr_coercions, req_type_coercions = [{ tc_demanded = tst_result, tc_offered = e_type, tc_position = CP_Expression expr, tc_coercible = True } : reqs.req_type_coercions ] } ts = { ts & ts_expr_heap = storeAttribute opt_expr_ptr tst_result.at_attribute ts.ts_expr_heap } = case opt_tuple_type of Yes {glob_object={ds_ident,ds_index,ds_arity}, glob_module} # tuple_type = MakeTypeSymbIdent { glob_object = ds_index, glob_module = glob_module } ds_ident ds_arity -> ({ at_type = TA tuple_type tst_args, at_attribute = TA_Unique, at_annotation = AN_None }, No, (reqs, ts)) No -> ( hd tst_args, No, (reqs, ts)) requirements _ (AnyCodeExpr _ _ _) (reqs, ts) # (fresh_v, ts) = freshAttributedVariable ts = (fresh_v, No, (reqs, ts)) requirements _ (ABCCodeExpr _ _) (reqs, ts) # (fresh_v, ts) = freshAttributedVariable ts = (fresh_v, No, (reqs, ts)) requirements _ expr reqs_ts = (abort ("Error in requirements\n" ---> expr), No, reqs_ts) requirementsOfSelectors ti opt_expr expr [selector] tc_coercible sel_expr_type sel_expr reqs_ts = requirementsOfSelector ti opt_expr expr selector tc_coercible sel_expr_type sel_expr reqs_ts requirementsOfSelectors ti opt_expr expr [selector : selectors] tc_coercible sel_expr_type sel_expr reqs_ts # (result_type, reqs_ts) = requirementsOfSelector ti No expr selector tc_coercible sel_expr_type sel_expr reqs_ts = requirementsOfSelectors ti opt_expr expr selectors tc_coercible result_type sel_expr reqs_ts /* requirementsOfSelectors ti opt_expr expr [selector] tc_coercible sel_expr_type sel_expr opt_expr_ptr (reqs, ts) # ts_expr_heap = storeAttribute opt_expr_ptr sel_expr_type.at_attribute ts.ts_expr_heap = requirementsOfSelector ti opt_expr expr selector tc_coercible sel_expr_type sel_expr (reqs, { ts & ts_expr_heap = ts_expr_heap }) requirementsOfSelectors ti opt_expr expr [selector : selectors] tc_coercible sel_expr_type sel_expr opt_expr_ptr (reqs, ts) # ts_expr_heap = storeAttribute opt_expr_ptr sel_expr_type.at_attribute ts.ts_expr_heap (result_type, reqs_ts) = requirementsOfSelector ti No expr selector tc_coercible sel_expr_type sel_expr (reqs, { ts & ts_expr_heap = ts_expr_heap }) = requirements_of_remaining_selectors ti opt_expr expr selectors tc_coercible result_type expr reqs_ts where requirements_of_remaining_selectors ti opt_expr expr [selector] tc_coercible sel_expr_type sel_expr reqs_ts = requirementsOfSelector ti opt_expr expr selector tc_coercible sel_expr_type sel_expr reqs_ts requirements_of_remaining_selectors ti opt_expr expr [selector : selectors] tc_coercible sel_expr_type sel_expr reqs_ts # (result_type, reqs_ts) = requirementsOfSelector ti No expr selector tc_coercible sel_expr_type sel_expr reqs_ts = requirements_of_remaining_selectors ti opt_expr expr selectors tc_coercible result_type sel_expr reqs_ts */ requirementsOfSelector ti _ expr (RecordSelection field _) tc_coercible sel_expr_type sel_expr (reqs, ts ) # ({tst_args, tst_result, tst_attr_env}, ts) = standardFieldSelectorType field ti ts req_type_coercions = [{ tc_demanded = hd tst_args, tc_offered = sel_expr_type, tc_position = CP_Expression sel_expr, tc_coercible = tc_coercible } : reqs.req_type_coercions ] = (tst_result, ({ reqs & req_type_coercions = req_type_coercions }, ts)) requirementsOfSelector ti opt_expr expr (ArraySelection {glob_object = {ds_ident,ds_index,ds_arity},glob_module} expr_ptr index_expr) tc_coercible sel_expr_type sel_expr (reqs, ts) # {me_type} = ti.ti_common_defs.[glob_module].com_member_defs.[ds_index] ({tst_attr_env,tst_args,tst_result,tst_context}, cons_variables, ts) = freshSymbolType cWithFreshContextVars me_type ti.ti_common_defs ts (dem_array_type, dem_index_type, rest_type) = array_and_index_type tst_args reqs ={ reqs & req_attr_coercions = tst_attr_env ++ reqs.req_attr_coercions, req_cons_variables = [ cons_variables : reqs.req_cons_variables ]} (index_type, opt_expr_ptr, (reqs, ts)) = requirements ti index_expr (reqs, ts) ts_expr_heap = storeAttribute opt_expr_ptr dem_index_type.at_attribute ts.ts_expr_heap reqs = { reqs & req_type_coercions = [{ tc_demanded = dem_index_type, tc_offered = index_type, tc_position = CP_Expression expr, tc_coercible = True }, { tc_demanded = dem_array_type, tc_offered = sel_expr_type, tc_position = CP_Expression sel_expr, tc_coercible = tc_coercible } : reqs.req_type_coercions ]} (reqs, ts) = requirements_of_update ti opt_expr rest_type (reqs, { ts & ts_expr_heap = ts_expr_heap }) | isEmpty tst_context = (tst_result, (reqs, ts)) = (tst_result, ({ reqs & req_overloaded_calls = [expr_ptr : reqs.req_overloaded_calls ]}, { ts & ts_expr_heap = ts.ts_expr_heap <:= (expr_ptr, EI_Overloaded { oc_symbol = { symb_name = ds_ident, symb_kind = SK_OverloadedFunction {glob_module = glob_module, glob_object = ds_index}, symb_arity = ds_arity }, oc_context = tst_context, oc_specials = [] })})) where array_and_index_type [array_type, index_type : rest_type ] = (array_type, index_type, rest_type) requirements_of_update ti No _ reqs_ts = reqs_ts requirements_of_update ti (Yes elem_expr) [ elem_type : _ ] reqs_ts # (elem_expr_type, opt_elem_expr_ptr, (reqs, ts)) = requirements ti elem_expr reqs_ts ts = { ts & ts_expr_heap = storeAttribute opt_elem_expr_ptr elem_type.at_attribute ts.ts_expr_heap } reqs = { reqs & req_type_coercions = [{ tc_demanded = elem_type, tc_offered = elem_expr_type, tc_position = CP_Expression elem_expr, tc_coercible = True } : reqs.req_type_coercions ]} = (reqs, ts) possibly_accumulate_reqs_in_new_group position state_transition reqs_ts :== possibly_accumulate_reqs position reqs_ts where possibly_accumulate_reqs NoPos reqs_ts = state_transition reqs_ts possibly_accumulate_reqs position (reqs=:{req_type_coercions=old_req_type_coercions}, ts) # reqs_with_empty_accu = { reqs & req_type_coercions = [] } (reqs_with_new_group_in_accu, ts) = state_transition (reqs_with_empty_accu, ts) new_group = { tcg_type_coercions = reqs_with_new_group_in_accu.req_type_coercions, tcg_position = position } reqs_with_new_group = { reqs_with_new_group_in_accu & req_type_coercion_groups = [new_group:reqs_with_new_group_in_accu.req_type_coercion_groups], req_type_coercions = old_req_type_coercions } = (reqs_with_new_group, ts) makeBase _ _ [] [] ts_var_heap = ts_var_heap makeBase fun_or_cons_ident arg_nr [{fv_name, fv_info_ptr}:vars] [type:types] ts_var_heap # optional_position = if (is_rare_name fv_name) (Yes (CP_FunArg fun_or_cons_ident arg_nr)) No ts_var_heap = ts_var_heap <:= (fv_info_ptr, VI_Type type optional_position) = makeBase fun_or_cons_ident (arg_nr+1) vars types ts_var_heap attributedBasicType (BT_String string_type) ts=:{ts_attr_store} = ({ at_annotation = AN_None, at_attribute = TA_TempVar ts_attr_store, at_type = string_type}, {ts & ts_attr_store = inc ts_attr_store}) attributedBasicType bas_type ts=:{ts_attr_store} = ({ at_annotation = AN_None, at_attribute = TA_TempVar ts_attr_store, at_type = TB bas_type}, {ts & ts_attr_store = inc ts_attr_store}) unify_coercions [{tc_demanded,tc_offered,tc_position}:coercions] modules subst heaps err # (subst, heaps, err) = unify_coercions coercions modules subst heaps err (subst_demanded, subst) = arraySubst tc_demanded subst (subst_offered, subst) = arraySubst tc_offered subst (succ, subst, heaps) = unify subst_demanded subst_offered modules subst heaps | succ = (subst, heaps, err) = (subst, heaps, cannotUnify subst_demanded subst_offered tc_position err) unify_coercions [] modules subst heaps err = (subst, heaps, err) InitFunEnv :: !Int -> *{! FunctionType} InitFunEnv nr_of_fun_defs = createArray nr_of_fun_defs EmptyFunctionType CreateInitialSymbolTypes start_index common_defs [] defs_and_state = defs_and_state CreateInitialSymbolTypes start_index common_defs [fun : funs] (fun_defs, pre_def_symbols, req_cons_variables, ts) # (fd, fun_defs) = fun_defs![fun] (pre_def_symbols, req_cons_variables, ts) = initial_symbol_type (start_index == fun) common_defs fd (pre_def_symbols, req_cons_variables, ts) = CreateInitialSymbolTypes start_index common_defs funs (fun_defs, pre_def_symbols, req_cons_variables, ts) where initial_symbol_type is_start_rule common_defs {fun_symb, fun_type = Yes ft=:{st_arity,st_args,st_result,st_attr_vars,st_attr_env},fun_lifted, fun_info = {fi_dynamics}, fun_pos } (pre_def_symbols, req_cons_variables, ts=:{ts_type_heaps,ts_expr_heap,ts_td_infos,ts_error}) # fe_location = newPosition fun_symb fun_pos ts_error = setErrorAdmin fe_location ts_error (st_args, ps) = addPropagationAttributesToATypes common_defs st_args { prop_type_heaps = ts_type_heaps, prop_td_infos = ts_td_infos, prop_attr_vars = st_attr_vars, prop_attr_env = st_attr_env, prop_error = Yes ts_error} (st_result, _, {prop_type_heaps,prop_td_infos,prop_attr_vars,prop_error = Yes ts_error,prop_attr_env}) = addPropagationAttributesToAType common_defs st_result ps ft_with_prop = { ft & st_args = st_args, st_result = st_result, st_attr_vars = prop_attr_vars, st_attr_env = prop_attr_env } (th_vars, ts_expr_heap) = clear_dynamics fi_dynamics (prop_type_heaps.th_vars, ts.ts_expr_heap) (fresh_fun_type, cons_variables, ts) = freshSymbolType cWithoutFreshContextVars ft_with_prop common_defs { ts & ts_type_heaps = { prop_type_heaps & th_vars = th_vars }, ts_expr_heap = ts_expr_heap, ts_td_infos = prop_td_infos, ts_error = ts_error } (lifted_args, ts) = fresh_non_unique_type_variables fun_lifted [] ts (ts_var_store, ts_type_heaps, ts_var_heap, ts_expr_heap, pre_def_symbols) = fresh_dynamics fi_dynamics (ts.ts_var_store, ts.ts_type_heaps, ts.ts_var_heap, ts.ts_expr_heap, pre_def_symbols) = (pre_def_symbols, [ cons_variables : req_cons_variables], { ts & ts_fun_env = { ts.ts_fun_env & [fun] = SpecifiedType ft_with_prop lifted_args { fresh_fun_type & tst_arity = st_arity + fun_lifted, tst_args = lifted_args ++ fresh_fun_type.tst_args, tst_lifted = fun_lifted }}, ts_var_heap = ts_var_heap, ts_var_store = ts_var_store, ts_expr_heap = ts_expr_heap, ts_type_heaps = ts_type_heaps }) initial_symbol_type is_start_rule common_defs {fun_arity, fun_lifted, fun_info = {fi_dynamics}} (pre_def_symbols, req_cons_variables, ts) # (st_gen, ts) = create_general_symboltype is_start_rule fun_arity fun_lifted ts ts_type_heaps = ts.ts_type_heaps (th_vars, ts_expr_heap) = clear_dynamics fi_dynamics (ts_type_heaps.th_vars, ts.ts_expr_heap) (ts_var_store, ts_type_heaps, ts_var_heap, ts_expr_heap, pre_def_symbols) = fresh_dynamics fi_dynamics (ts.ts_var_store, { ts_type_heaps & th_vars = th_vars }, ts.ts_var_heap, ts_expr_heap, pre_def_symbols) = (pre_def_symbols, req_cons_variables, { ts & ts_fun_env = { ts.ts_fun_env & [fun] = UncheckedType st_gen }, ts_var_store = ts_var_store, ts_expr_heap = ts_expr_heap, ts_type_heaps = ts_type_heaps, ts_var_heap = ts_var_heap}) create_general_symboltype :: !Bool !Int !Int !*TypeState -> (!TempSymbolType, !*TypeState) create_general_symboltype is_start_rule nr_of_args nr_of_lifted_args ts | is_start_rule && nr_of_args > 0 # (tst_args, ts) = fresh_attributed_type_variables (nr_of_args - 1) [{at_attribute = TA_Unique, at_annotation = AN_Strict, at_type = TB BT_World }] ts (tst_result, ts) = freshAttributedVariable ts = ({ tst_args = tst_args, tst_arity = 1, tst_result = tst_result, tst_context = [], tst_attr_env = [], tst_lifted = 0 }, ts) # (tst_args, ts) = fresh_attributed_type_variables nr_of_args [] ts (tst_args, ts) = fresh_attributed_type_variables nr_of_lifted_args tst_args ts (tst_result, ts) = freshAttributedVariable ts = ({ tst_args = tst_args, tst_arity = nr_of_args + nr_of_lifted_args, tst_result = tst_result, tst_context = [], tst_attr_env = [], tst_lifted = 0 }, ts) fresh_attributed_type_variables :: !Int ![AType] !*TypeState -> (![AType], !*TypeState) fresh_attributed_type_variables n vars ts | n == 0 = (vars, ts) # (var, ts) = freshAttributedVariable ts = fresh_attributed_type_variables (dec n) [var : vars] ts fresh_non_unique_type_variables :: !Int ![AType] !*TypeState -> (![AType], !*TypeState) fresh_non_unique_type_variables n vars ts | n == 0 = (vars, ts) # (var, ts) = freshNonUniqueVariable ts = fresh_non_unique_type_variables (dec n) [var : vars] ts fresh_dynamics dyn_ptrs state = foldSt fresh_dynamic dyn_ptrs state fresh_dynamic dyn_ptr (var_store, type_heaps, var_heap, expr_heap, predef_symbols) # (dyn_info, expr_heap) = readPtr dyn_ptr expr_heap = case dyn_info of EI_Dynamic opt_dyn_type=:(Yes {dt_uni_vars,dt_type,dt_global_vars}) # (th_vars, var_store) = fresh_existential_attributed_variables dt_uni_vars (type_heaps.th_vars, var_store) (th_vars, var_store) = fresh_type_variables dt_global_vars (th_vars, var_store) (tdt_type, {copy_heaps}) = freshCopy dt_type { copy_heaps = { type_heaps & th_vars = th_vars }} (contexts, expr_ptr, type_code_symbol, (var_heap, expr_heap, type_var_heap, predef_symbols)) = determine_context_and_expr_ptr dt_global_vars (var_heap, expr_heap, copy_heaps.th_vars, predef_symbols) -> (var_store, { copy_heaps & th_vars = type_var_heap }, var_heap, expr_heap <:= (dyn_ptr, EI_TempDynamicType opt_dyn_type tdt_type contexts expr_ptr type_code_symbol), predef_symbols) EI_Dynamic No # fresh_var = TempV var_store tdt_type = { at_attribute = TA_Multi, at_annotation = AN_None, at_type = fresh_var } # ({pds_ident,pds_module,pds_def},predef_symbols) = predef_symbols![PD_TypeCodeClass] tc_class_symb = {glob_module = pds_module, glob_object = {ds_ident = pds_ident, ds_arity = 1, ds_index = pds_def }} (pds, predef_symbols) = predef_symbols![PD_TypeCodeMember] ({pds_ident,pds_module,pds_def},predef_symbols) = predef_symbols![PD_TypeCodeMember] tc_member_symb = { symb_name = pds_ident, symb_kind = SK_OverloadedFunction {glob_module = pds_module, glob_object = pds_def }, symb_arity = 0} (new_var_ptr, var_heap) = newPtr VI_Empty var_heap context = {tc_class = tc_class_symb, tc_types = [fresh_var], tc_var = new_var_ptr} (expr_ptr, expr_heap) = newPtr EI_Empty expr_heap //---> ("^EI_Dynamic No=" +++ toString var_store) -> (inc var_store, type_heaps, var_heap, expr_heap <:= (dyn_ptr, EI_TempDynamicType No tdt_type [context] expr_ptr tc_member_symb), predef_symbols) EI_DynamicTypeWithVars loc_type_vars dt=:{dt_type,dt_global_vars} loc_dynamics # (fresh_vars, (th_vars, var_store)) = fresh_existential_variables loc_type_vars (type_heaps.th_vars, var_store) (th_vars, var_store) = fresh_type_variables dt_global_vars (th_vars, var_store) (tdt_type, {copy_heaps}) = freshCopy dt_type { copy_heaps = { type_heaps & th_vars = th_vars }} (contexts, expr_ptr, type_code_symbol, (var_heap, expr_heap, type_var_heap, predef_symbols)) = determine_context_and_expr_ptr dt_global_vars (var_heap, expr_heap, copy_heaps.th_vars, predef_symbols) -> fresh_local_dynamics loc_dynamics (var_store, { copy_heaps & th_vars = type_var_heap }, var_heap, expr_heap <:= (dyn_ptr, EI_TempDynamicPattern loc_type_vars dt loc_dynamics fresh_vars tdt_type contexts expr_ptr type_code_symbol), predef_symbols) fresh_local_dynamics loc_dynamics state = foldSt fresh_dynamic loc_dynamics state clear_dynamics dyn_ptrs heaps = foldSt clear_dynamic dyn_ptrs heaps clear_dynamic dyn_ptr (var_heap, expr_heap) # (dyn_info, expr_heap) = readPtr dyn_ptr expr_heap = case dyn_info of EI_Dynamic (Yes {dt_global_vars}) -> (clear_type_vars dt_global_vars var_heap, expr_heap) EI_Dynamic No -> (var_heap, expr_heap) EI_DynamicTypeWithVars loc_type_vars {dt_global_vars} loc_dynamics -> clear_local_dynamics loc_dynamics (clear_type_vars dt_global_vars var_heap, expr_heap) clear_local_dynamics loc_dynamics state = foldSt clear_dynamic loc_dynamics state clear_type_vars type_vars var_heap = foldSt (\{tv_info_ptr} -> writePtr tv_info_ptr TVI_Empty) type_vars var_heap fresh_existential_attributed_variables type_variables state = foldSt (\{atv_variable={tv_info_ptr}} (var_heap, var_store) -> (var_heap <:= (tv_info_ptr, TVI_Type (TempQV var_store)), inc var_store)) type_variables state fresh_existential_variables type_variables state = mapSt (\{tv_info_ptr} (var_heap, var_store) -> (var_store, (var_heap <:= (tv_info_ptr, TVI_Type (TempQV var_store)), inc var_store))) type_variables state fresh_type_variables type_variables state = foldSt fresh_type_variable type_variables state fresh_type_variable {tv_info_ptr} (var_heap, var_store) # (var_info, var_heap) = readPtr tv_info_ptr var_heap = case var_info of TVI_Empty -> (var_heap <:= (tv_info_ptr, TVI_Type (TempV var_store)), inc var_store) _ -> (var_heap, var_store) determine_context_and_expr_ptr global_vars (var_heap, expr_heap, type_var_heap, predef_symbols) # ({pds_ident,pds_module,pds_def},predef_symbols) = predef_symbols![PD_TypeCodeClass] tc_class_symb = {glob_module = pds_module, glob_object = {ds_ident = pds_ident, ds_arity = 1, ds_index = pds_def }} ({pds_ident,pds_module,pds_def},predef_symbols) = predef_symbols![PD_TypeCodeMember] tc_member_symb = { symb_name = pds_ident, symb_kind = SK_TypeCode, symb_arity = 0} (contexts, (var_heap, type_var_heap)) = mapSt (build_type_context tc_class_symb) global_vars (var_heap, type_var_heap) (expr_ptr, expr_heap) = newPtr EI_Empty expr_heap = (contexts, expr_ptr, tc_member_symb, (var_heap, expr_heap, type_var_heap, predef_symbols)) build_type_context tc_class_symb {tv_info_ptr} (var_heap, type_var_heap) # (TVI_Type fresh_var, type_var_heap) = readPtr tv_info_ptr type_var_heap (new_var_ptr, var_heap) = newPtr VI_Empty var_heap = ({tc_class = tc_class_symb, tc_types = [fresh_var], tc_var = new_var_ptr}, (var_heap, type_var_heap)) specification_error type type1 err # err = errorHeading "Type error" err format = { form_properties = cAttributed, form_attr_position = No} = { err & ea_file = err.ea_file <<< " specified type " <:: (format, type1, Yes initialTypeVarBeautifulizer) <<< "conflicts with derived type " <:: (format, type, Yes initialTypeVarBeautifulizer) <<< '\n' } cleanUpAndCheckFunctionTypes [] _ _ start_index _ defs type_contexts coercion_env attr_partition type_var_env attr_var_env (fun_defs, ts) = (fun_defs, ts) cleanUpAndCheckFunctionTypes [fun : funs] [ {fe_requirements = {req_case_and_let_exprs}} : reqs] dict_types start_index list_inferred_types defs type_contexts coercion_env attr_partition type_var_env attr_var_env (fun_defs, ts) # (fd, fun_defs) = fun_defs![fun] dict_ptrs = get_dict_ptrs fun dict_types (type_var_env, attr_var_env, ts) = clean_up_and_check_function_type fd fun (start_index == fun) list_inferred_types defs type_contexts (dict_ptrs ++ req_case_and_let_exprs) coercion_env attr_partition type_var_env attr_var_env ts = cleanUpAndCheckFunctionTypes funs reqs dict_types start_index list_inferred_types defs type_contexts coercion_env attr_partition type_var_env attr_var_env (fun_defs, ts) where get_dict_ptrs fun_index [] = [] get_dict_ptrs fun_index [(index, ptrs) : dict_types] | fun_index == index = ptrs = get_dict_ptrs fun_index dict_types clean_up_and_check_function_type {fun_symb,fun_pos,fun_type = opt_fun_type} fun is_start_rule list_inferred_types defs type_contexts type_ptrs coercion_env attr_partition type_var_env attr_var_env ts # (env_type, ts) = ts!ts_fun_env.[fun] # ts = { ts & ts_error = setErrorAdmin (newPosition fun_symb fun_pos) ts.ts_error} = case env_type of ExpandedType fun_type tmp_fun_type exp_fun_type # (clean_fun_type, type_var_env, attr_var_env, ts_type_heaps, ts_var_heap, ts_expr_heap, ts_error) = cleanUpSymbolType is_start_rule cSpecifiedType exp_fun_type type_contexts type_ptrs coercion_env attr_partition type_var_env attr_var_env ts.ts_type_heaps ts.ts_var_heap ts.ts_expr_heap ts.ts_error | ts_error.ea_ok # (ts_fun_env, attr_var_env, ts_type_heaps, ts_expr_heap, ts_error) = check_function_type fun_type tmp_fun_type clean_fun_type type_ptrs defs ts.ts_fun_env attr_var_env ts_type_heaps ts_expr_heap ts_error -> (type_var_env, attr_var_env, { ts & ts_type_heaps = ts_type_heaps, ts_var_heap = ts_var_heap, ts_expr_heap = ts_expr_heap, ts_fun_env = ts_fun_env, ts_error = ts_error }) -> (type_var_env, attr_var_env, { ts & ts_type_heaps = ts_type_heaps, ts_var_heap = ts_var_heap, ts_expr_heap = ts_expr_heap, ts_error = ts_error }) UncheckedType exp_fun_type # (clean_fun_type, type_var_env, attr_var_env, ts_type_heaps, ts_var_heap, ts_expr_heap, ts_error) = cleanUpSymbolType is_start_rule cDerivedType exp_fun_type type_contexts type_ptrs coercion_env attr_partition type_var_env attr_var_env ts.ts_type_heaps ts.ts_var_heap ts.ts_expr_heap ts.ts_error ts_out = ts.ts_out th_attrs = ts_type_heaps.th_attrs (ts_out, th_attrs) = case list_inferred_types of No -> (ts_out, th_attrs) Yes show_attributes # form = { form_properties = if show_attributes cAttributed cNoProperties, form_attr_position = No } // ts_out = ts_out <<< show_attributes <<< "\n" (printable_type, th_attrs) = case show_attributes of True -> beautifulizeAttributes clean_fun_type th_attrs _ -> (clean_fun_type, th_attrs) -> (ts_out <<< fun_symb <<< " :: " <:: (form, printable_type, Yes initialTypeVarBeautifulizer) <<< '\n', th_attrs) ts_fun_env = { ts.ts_fun_env & [fun] = CheckedType clean_fun_type } -> (type_var_env, attr_var_env, { ts & ts_type_heaps = { ts_type_heaps & th_attrs = th_attrs }, ts_var_heap = ts_var_heap, ts_expr_heap = ts_expr_heap, ts_fun_env = ts_fun_env, ts_error = ts_error, ts_out = ts_out }) check_function_type fun_type tmp_fun_type=:{tst_lifted} clean_fun_type=:{st_arity, st_args, st_vars, st_attr_vars, st_context} type_ptrs defs fun_env attr_var_env type_heaps expr_heap error # (equi, attr_var_env, type_heaps) = equivalent clean_fun_type tmp_fun_type (length fun_type.st_context) defs attr_var_env type_heaps | equi # type_with_lifted_arg_types = addLiftedArgumentsToSymbolType fun_type tst_lifted st_args st_vars st_attr_vars st_context (type_heaps, expr_heap) = updateExpressionTypes clean_fun_type type_with_lifted_arg_types type_ptrs type_heaps expr_heap = ({ fun_env & [fun] = CheckedType type_with_lifted_arg_types}, attr_var_env, type_heaps, expr_heap, error) // ---> ("check_function_type", clean_fun_type, fun_type, type_with_lifted_arg_types) # (printable_type, th_attrs) = beautifulizeAttributes clean_fun_type type_heaps.th_attrs # (printable_type1, th_attrs) = beautifulizeAttributes fun_type th_attrs = (fun_env, attr_var_env, { type_heaps & th_attrs = th_attrs }, expr_heap, specification_error printable_type printable_type1 error) where add_lifted_arg_types arity_diff args1 args2 | arity_diff > 0 = take arity_diff args2 ++ args1 = args1 addLiftedArgumentsToSymbolType st=:{st_arity,st_args,st_vars,st_attr_vars,st_context} nr_of_lifted_arguments new_args new_vars new_attrs new_context = { st & st_args = take nr_of_lifted_arguments new_args ++ st_args, st_vars = st_vars ++ drop (length st_vars) new_vars, st_attr_vars = st_attr_vars ++ take (length new_attrs - length st_attr_vars) new_attrs, st_arity = st_arity + nr_of_lifted_arguments, st_context = take (length new_context - length st_context) new_context ++ st_context } :: FunctionRequirements = { fe_requirements :: !Requirements , fe_context :: !Optional [TypeContext] , fe_index :: !Index , fe_location :: !IdentPos } /* ste_kind_to_string s = case s of (STE_FunctionOrMacro _) -> "STE_FunctionOrMacro" STE_Type -> "STE_Type" STE_Constructor -> "STE_Constructor" (STE_Selector _) -> "STE_Selector" STE_Class -> "STE_Class" (STE_Field _) -> "STE_Field" STE_Member -> "STE_Member" (STE_Instance _) -> "STE_Instance" (STE_Variable _) -> "STE_Variable" (STE_TypeVariable _) -> "STE_TypeVariable" (STE_TypeAttribute _) -> "STE_TypeAttribute" (STE_BoundTypeVariable _) -> "STE_BoundTypeVariable" (STE_Imported a b) -> "STE_Imported "+++ ste_kind_to_string a STE_DclFunction -> "STE_DclFunction" (STE_Module _) -> "STE_Module" STE_ClosedModule -> "STE_ClosedModule" STE_Empty -> "STE_Empty" _ -> "STE_???" */ typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*TypeDefInfos !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule} -> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !*TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File) typeProgram comps main_dcl_module_n fun_defs specials list_inferred_types icl_defs imports modules used_module_numbers td_infos heaps=:{hp_var_heap, hp_expression_heap, hp_type_heaps} predef_symbols file out dcl_modules //typeProgram ::!{! Group} !Int !*{# FunDef} !IndexRange !(Optional Bool) !CommonDefs ![Declaration] !{# DclModule} !NumberSet !*Heaps !*PredefinedSymbols !*File !*File !{# DclModule} // -> (!Bool, !*{# FunDef}, !IndexRange, {! GlobalTCType}, !{# CommonDefs}, !{# {# FunType} }, !.TypeDefInfos, !*Heaps, !*PredefinedSymbols, !*File, !*File) //typeProgram comps main_dcl_module_n fun_defs specials list_inferred_types icl_defs imports modules used_module_numbers heaps=:{hp_var_heap, hp_expression_heap, hp_type_heaps} predef_symbols file out dcl_modules #! fun_env_size = size fun_defs # ts_error = {ea_file = file, ea_loc = [], ea_ok = True } ti_common_defs = {{dcl_common \\ {dcl_common} <-: modules } & [main_dcl_module_n] = icl_defs } ti_functions = {dcl_functions \\ {dcl_functions} <-: modules } type_def_sizes = [ size com_type_defs \\ {com_type_defs} <-: ti_common_defs ] class_def_sizes = [ size com_class_defs \\ {com_class_defs} <-: ti_common_defs ] class_instances = { { IT_Empty \\ i <- [0 .. dec size] } \\ size <- class_def_sizes } /* (td_infos, hp_type_heaps, ts_error) = analTypeDefs ti_common_defs used_module_numbers hp_type_heaps ts_error | not ts_error.ea_ok = (ts_error.ea_ok, fun_defs, { ir_from = 0, ir_to = 0 }, {}, ti_common_defs, ti_functions, icl_defs, td_infos, { heaps & hp_type_heaps = hp_type_heaps }, predef_symbols, hash_table, ts_error.ea_file, out) */ // AA.. /* # ti_common_defs = {x \\ x <-: ti_common_defs } # (ti_common_defs, comps, fun_defs, td_infos, hp_type_heaps, hp_var_heap, hash_table, predef_symbols, modules, ts_error) = convertGenerics main_dcl_module_n ti_common_defs comps fun_defs td_infos hp_type_heaps hp_var_heap hash_table predef_symbols modules ts_error | not ts_error.ea_ok = (ts_error.ea_ok, fun_defs, { ir_from = 0, ir_to = 0 }, {}, ti_common_defs, ti_functions, icl_defs, td_infos, { heaps & hp_type_heaps = hp_type_heaps, hp_var_heap = hp_var_heap}, predef_symbols, hash_table, ts_error.ea_file, out) # icl_defs = ti_common_defs.[main_dcl_module_n] #! fun_env_size = size fun_defs # ti_functions = {dcl_functions \\ {dcl_functions} <-: modules } # (td_infos, hp_type_heaps, ts_error) = analTypeDefs ti_common_defs used_module_numbers hp_type_heaps ts_error # class_def_sizes = [ size com_class_defs \\ {com_class_defs} <-: ti_common_defs ] # class_instances = { { IT_Empty \\ i <- [0 .. dec size] } \\ size <- class_def_sizes } */ // ..AA # state = collect_imported_instances imports ti_common_defs {} ts_error class_instances hp_type_heaps.th_vars td_infos (_, ts_error, class_instances, th_vars, td_infos) = collect_and_check_instances (size icl_defs.com_instance_defs) ti_common_defs state ts = { ts_fun_env = InitFunEnv fun_env_size, ts_var_heap = hp_var_heap, ts_expr_heap = hp_expression_heap, ts_var_store = 0, ts_attr_store = FirstAttrVar, ts_type_heaps = { hp_type_heaps & th_vars = th_vars }, ts_td_infos = td_infos, ts_error = ts_error, ts_out = out } ti = { ti_common_defs = ti_common_defs, ti_functions = ti_functions,ti_main_dcl_module_n=main_dcl_module_n } special_instances = { si_next_array_member_index = fun_env_size, si_array_instances = [], si_next_TC_member_index = 0, si_TC_instances = [] } # (type_error, fun_defs, predef_symbols, special_instances, ts) = type_components list_inferred_types 0 comps class_instances ti (False, fun_defs, predef_symbols, special_instances, ts) (fun_defs,ts_fun_env) = update_function_types 0 comps ts.ts_fun_env fun_defs (type_error, fun_defs, predef_symbols, special_instances, {ts_td_infos,ts_fun_env,ts_error,ts_var_heap, ts_expr_heap, ts_type_heaps, ts_out}) = type_instances list_inferred_types specials.ir_from specials.ir_to class_instances ti (type_error, fun_defs, predef_symbols, special_instances, { ts & ts_fun_env = ts_fun_env }) {si_array_instances, si_next_array_member_index, si_next_TC_member_index, si_TC_instances}= special_instances (fun_defs, predef_symbols, ts_type_heaps) = convert_array_instances si_array_instances ti_common_defs fun_defs predef_symbols ts_type_heaps type_code_instances = {createArray si_next_TC_member_index GTT_Function & [gtci_index] = gtci_type \\ {gtci_index, gtci_type} <- si_TC_instances} = (not type_error, fun_defs, { ir_from = fun_env_size, ir_to = si_next_array_member_index }, type_code_instances, ti_common_defs, ti_functions, ts_td_infos, {hp_var_heap = ts_var_heap, hp_expression_heap = ts_expr_heap, hp_type_heaps = ts_type_heaps }, predef_symbols, ts_error.ea_file, ts_out) // ---> ("typeProgram", array_inst_types) where collect_imported_instances imports common_defs dummy error class_instances type_var_heap td_infos = foldSt (collect_imported_instance common_defs) imports (dummy, error, class_instances, type_var_heap, td_infos) collect_imported_instance common_defs (Declaration {decl_kind = STE_Imported (STE_Instance _) mod_index, decl_index }) state = update_instances_of_class common_defs mod_index decl_index state collect_imported_instance common_defs _ state = state collect_and_check_instances nr_of_instances common_defs state = iFoldSt (update_instances_of_class common_defs main_dcl_module_n) 0 nr_of_instances state update_instances_of_class common_defs mod_index ins_index (dummy, error, class_instances, type_var_heap, td_infos) #!{ins_class={glob_object={ds_ident={id_name}, ds_index},glob_module},ins_type={it_types},ins_pos} = common_defs.[mod_index].com_instance_defs.[ins_index] id_name = id_name ---> ("update_instances_of_class" +++ id_name +++ " " +++ (toString glob_module) +++ " " +++ toString (size class_instances)) (mod_instances, class_instances) = replace class_instances glob_module dummy id_name = id_name ---> "done" (instances, mod_instances) = replace mod_instances ds_index IT_Empty (error, instances) = insert it_types ins_index mod_index common_defs error instances (_, mod_instances) = replace mod_instances ds_index instances (dummy, class_instances) = replace class_instances glob_module mod_instances (error, type_var_heap, td_infos) = check_types_of_instances ins_pos common_defs glob_module ds_index it_types (error, type_var_heap, td_infos) = (dummy, error, class_instances, type_var_heap, td_infos) check_types_of_instances ins_pos common_defs class_module class_index types state # {class_arity,class_cons_vars} = common_defs.[class_module].com_class_defs.[class_index] = check_instances_of_constructor_variables ins_pos common_defs class_cons_vars (dec class_arity) types state where check_instances_of_constructor_variables ins_pos common_defs cons_vars arg_nr [type : types] state | cons_vars bitand (1 << arg_nr) <> 0 # state = check_type_of_constructor_variable ins_pos common_defs type state = check_instances_of_constructor_variables ins_pos common_defs cons_vars (dec arg_nr) types state = check_instances_of_constructor_variables ins_pos common_defs cons_vars (dec arg_nr) types state check_instances_of_constructor_variables ins_pos common_defs cons_vars arg_nr [] state = state check_type_of_constructor_variable ins_pos common_defs type=:(TA {type_index={glob_module,glob_object},type_arity} types) (error, type_var_heap, td_infos) # {td_arity} = common_defs.[glob_module].com_type_defs.[glob_object] ({tdi_properties,tdi_cons_vars}, td_infos) = td_infos![glob_module].[glob_object] | tdi_properties bitand cIsNonCoercible == 0 # ({sc_neg_vect}, type_var_heap, td_infos) = signClassification glob_object glob_module [TopSignClass \\ cv <- tdi_cons_vars ] common_defs type_var_heap td_infos = (check_sign type (sc_neg_vect >> type_arity) (td_arity - type_arity) error, type_var_heap, td_infos) = (checkErrorWithIdentPos (newPosition empty_id ins_pos) " instance type should be coercible" error, type_var_heap, td_infos) where check_sign type neg_signs arg_nr error | arg_nr == 0 = error | neg_signs bitand 1 == 0 = check_sign type (neg_signs >> 1) (dec arg_nr) error = checkError type " all arguments of an instance type should have a non-negative sign" error check_type_of_constructor_variable ins_pos common_defs type=:(arg_type --> result_type) (error, type_var_heap, td_infos) = (checkErrorWithIdentPos (newPosition empty_id ins_pos) " instance type should be coercible" error, type_var_heap, td_infos) check_type_of_constructor_variable ins_pos common_defs type=:(cv :@: types) (error, type_var_heap, td_infos) = (checkError (newPosition empty_id ins_pos) " instance type should be coercible" error, type_var_heap, td_infos) check_type_of_constructor_variable ins_pos common_defs type state = state insert :: ![Type] !Index !Index !{# CommonDefs } !*ErrorAdmin !*InstanceTree -> (!*ErrorAdmin, !*InstanceTree) insert ins_types new_ins_index new_ins_module modules error IT_Empty = (error, IT_Node {glob_object = new_ins_index,glob_module = new_ins_module} IT_Empty IT_Empty) insert ins_types new_ins_index new_ins_module modules error (IT_Node ins=:{glob_object,glob_module} it_less it_greater) #! {ins_type={it_types}} = modules.[glob_module].com_instance_defs.[glob_object] # cmp = ins_types =< it_types | cmp == Smaller # (error, it_less) = insert ins_types new_ins_index new_ins_module modules error it_less = (error, IT_Node ins it_less it_greater) | cmp == Greater # (error, it_greater) = insert ins_types new_ins_index new_ins_module modules error it_greater = (error, IT_Node ins it_less it_greater) = (checkError ins_types " instance is overlapping" error, IT_Node ins it_less it_greater) type_instances list_inferred_types ir_from ir_to class_instances ti funs_and_state | ir_from == ir_to = funs_and_state # funs_and_state = type_component list_inferred_types [ir_from] class_instances ti funs_and_state = type_instances list_inferred_types (inc ir_from) ir_to class_instances ti funs_and_state type_components list_inferred_types group_index comps class_instances ti funs_and_state | group_index == size comps = funs_and_state #! comp = comps.[group_index] # funs_and_state = type_component list_inferred_types comp.group_members class_instances ti funs_and_state = type_components list_inferred_types (inc group_index) comps class_instances ti funs_and_state show_component comp fun_defs = foldSt show_fun comp ([], fun_defs) where show_fun fun_index (names, fun_defs) # ({fun_symb}, fun_defs) = fun_defs![fun_index] = ([fun_symb : names], fun_defs) get_index_of_start_rule predef_symbols # ({pds_def, pds_module}, predef_symbols) = predef_symbols![PD_Start] | pds_def <> NoIndex && pds_module == main_dcl_module_n = (pds_def, predef_symbols) = (NoIndex, predef_symbols) type_component list_inferred_types comp class_instances ti=:{ti_common_defs} (type_error, fun_defs, predef_symbols, special_instances, ts) # (start_index, predef_symbols) = get_index_of_start_rule predef_symbols // # (functions, fun_defs) = show_component comp fun_defs # (fun_defs, predef_symbols, cons_variables, ts) = CreateInitialSymbolTypes start_index ti_common_defs comp (fun_defs, predef_symbols, [], ts) | not ts.ts_error.ea_ok // ---> ("typing", functions) = (True, fun_defs, predef_symbols, special_instances, create_erroneous_function_types comp { ts & ts_var_store = 0, ts_attr_store = FirstAttrVar, ts_error = { ts.ts_error & ea_ok = True } }) # (fun_reqs, (cons_variables, fun_defs, ts)) = type_functions comp ti cons_variables fun_defs ts #! nr_of_type_variables = ts.ts_var_store # (subst, ts_type_heaps, ts_error) = unify_requirements_of_functions fun_reqs ti (createArray nr_of_type_variables TE) ts.ts_type_heaps ts.ts_error | not ts_error.ea_ok = (True, fun_defs, predef_symbols, special_instances, create_erroneous_function_types comp { ts & ts_type_heaps = ts_type_heaps, ts_error = { ts_error & ea_ok = True }, ts_var_store = 0, ts_attr_store = FirstAttrVar}) # {ts_attr_store,ts_var_heap,ts_var_store,ts_expr_heap,ts_td_infos} = ts (cons_var_vects, subst) = determine_cons_variables cons_variables (createArray (inc (BITINDEX nr_of_type_variables)) 0, subst) (subst, nr_of_attr_vars, th_vars, ts_td_infos) = liftSubstitution subst ti_common_defs cons_var_vects ts_attr_store ts_type_heaps.th_vars ts_td_infos coer_demanded ={{ CT_Empty \\ i <- [0 .. nr_of_attr_vars - 1] } & [AttrUni] = CT_Unique } coer_offered = {{ CT_Empty \\ i <- [0 .. nr_of_attr_vars - 1] } & [AttrMulti] = CT_NonUnique } coercion_env = build_initial_coercion_env fun_reqs {coer_demanded = coer_demanded, coer_offered = coer_offered } (over_info, (subst, ts_expr_heap)) = collect_and_expand_overloaded_calls fun_reqs [] (subst, ts_expr_heap) (contexts, coercion_env, local_pattern_variables, dict_types, { os_type_heaps, os_var_heap, os_symbol_heap, os_predef_symbols, os_special_instances, os_error }) = tryToSolveOverloading over_info main_dcl_module_n ti_common_defs class_instances coercion_env { os_type_heaps = {ts_type_heaps & th_vars = th_vars}, os_var_heap = ts_var_heap, os_symbol_heap = ts_expr_heap, os_predef_symbols = predef_symbols, os_error = ts_error, os_special_instances = special_instances } modules | not os_error.ea_ok = (True, fun_defs, os_predef_symbols, os_special_instances, create_erroneous_function_types comp { ts & ts_type_heaps = os_type_heaps, ts_error = { os_error & ea_ok = True }, ts_var_store = 0, ts_attr_store = FirstAttrVar, ts_td_infos = ts_td_infos, ts_expr_heap = os_symbol_heap, ts_var_heap = os_var_heap }) # (fun_defs, coercion_env, subst, ts_td_infos, os_var_heap, os_symbol_heap, os_error) = makeSharedReferencesNonUnique comp fun_defs coercion_env subst ts_td_infos os_var_heap os_symbol_heap os_error (subst, {coer_offered,coer_demanded}, ts_td_infos, ts_type_heaps, ts_error) = build_coercion_env fun_reqs subst coercion_env ti_common_defs cons_var_vects ts_td_infos os_type_heaps os_error (attr_partition, coer_demanded) = partitionateAttributes coer_offered coer_demanded (subst, ts_fun_env) = expand_function_types comp subst ts.ts_fun_env attr_var_env = createArray nr_of_attr_vars TA_None var_env = { subst & [i] = TE \\ i <- [0..dec ts_var_store]} (fun_defs, ts) = cleanUpAndCheckFunctionTypes comp fun_reqs dict_types start_index list_inferred_types ti_common_defs contexts coer_demanded attr_partition var_env attr_var_env (fun_defs, { ts & ts_error = ts_error, ts_fun_env = ts_fun_env, ts_type_heaps = ts_type_heaps, ts_td_infos = ts_td_infos, ts_var_heap = os_var_heap, ts_expr_heap = os_symbol_heap }) | not ts.ts_error.ea_ok = (True, fun_defs, os_predef_symbols, os_special_instances, create_erroneous_function_types comp { ts & ts_var_store = 0, ts_attr_store = FirstAttrVar, ts_error = { ts.ts_error & ea_ok = True } }) | isEmpty over_info # ts_type_heaps = ts.ts_type_heaps type_code_info = { tci_next_index = os_special_instances.si_next_TC_member_index, tci_instances = os_special_instances.si_TC_instances, tci_type_var_heap = ts_type_heaps.th_vars, tci_dcl_modules = dcl_modules } (fun_defs, ts_fun_env, ts_expr_heap, {tci_next_index,tci_instances,tci_type_var_heap}, ts_var_heap, ts_error, os_predef_symbols) = updateDynamics comp local_pattern_variables main_dcl_module_n fun_defs ts.ts_fun_env ts.ts_expr_heap type_code_info ts.ts_var_heap ts.ts_error os_predef_symbols = ( type_error || not ts_error.ea_ok, fun_defs, os_predef_symbols, { os_special_instances & si_next_TC_member_index = tci_next_index, si_TC_instances = tci_instances }, { ts & ts_var_store = 0, ts_attr_store = FirstAttrVar, ts_expr_heap = ts_expr_heap, ts_error = { ts_error & ea_ok = True }, ts_var_heap = ts_var_heap, ts_type_heaps = { ts_type_heaps & th_vars = tci_type_var_heap }, ts_fun_env = ts_fun_env}) # ts_type_heaps = ts.ts_type_heaps type_code_info = { tci_next_index = os_special_instances.si_next_TC_member_index, tci_instances = os_special_instances.si_TC_instances, tci_type_var_heap = ts_type_heaps.th_vars, tci_dcl_modules = dcl_modules } (fun_defs, ts_fun_env, ts_expr_heap, {tci_next_index,tci_instances,tci_type_var_heap}, ts_var_heap, ts_error, os_predef_symbols) = removeOverloadedFunctions comp local_pattern_variables main_dcl_module_n fun_defs ts.ts_fun_env ts.ts_expr_heap type_code_info ts.ts_var_heap ts.ts_error os_predef_symbols = ( type_error || not ts_error.ea_ok, fun_defs, os_predef_symbols, { os_special_instances & si_next_TC_member_index = tci_next_index, si_TC_instances = tci_instances }, { ts & ts_var_store = 0, ts_attr_store = FirstAttrVar, ts_expr_heap = ts_expr_heap, ts_error = { ts_error & ea_ok = True }, ts_var_heap = ts_var_heap, ts_type_heaps = { ts_type_heaps & th_vars = tci_type_var_heap }, ts_fun_env = ts_fun_env}) unify_requirements_of_functions :: ![FunctionRequirements] !TypeInput !*{!Type} !*TypeHeaps !*ErrorAdmin -> (!*{!Type},!*TypeHeaps,!*ErrorAdmin) unify_requirements_of_functions [{fe_requirements={req_type_coercion_groups},fe_location={ip_ident}} : reqs_list] ti subst heaps ts_error # (subst, heaps, ts_error) = foldSt (unify_requirements_within_one_position ip_ident ti) req_type_coercion_groups (subst, heaps, ts_error) = unify_requirements_of_functions reqs_list ti subst heaps ts_error unify_requirements_of_functions [] ti subst heaps ts_error = (subst, heaps, ts_error) unify_requirements_within_one_position :: !Ident !TypeInput !TypeCoercionGroup !(*{!Type}, !*TypeHeaps, !*ErrorAdmin) -> (*{!Type}, !*TypeHeaps, !*ErrorAdmin) unify_requirements_within_one_position _ ti {tcg_type_coercions, tcg_position=NoPos} (subst, heaps, ts_error) = unify_coercions tcg_type_coercions ti subst heaps ts_error unify_requirements_within_one_position fun_symb ti {tcg_type_coercions, tcg_position} (subst, heaps, ts_error) # ts_error = setErrorAdmin (newPosition fun_symb tcg_position) ts_error = unify_coercions tcg_type_coercions ti subst heaps ts_error build_initial_coercion_env [{fe_requirements={req_attr_coercions},fe_location} : reqs_list] coercion_env = build_initial_coercion_env reqs_list (add_to_initial_coercion_env req_attr_coercions coercion_env) build_initial_coercion_env [] coercion_env = coercion_env add_to_initial_coercion_env [{ac_offered,ac_demanded} : attr_coercions] coercion_env = add_to_initial_coercion_env attr_coercions (newInequality ac_offered ac_demanded coercion_env) add_to_initial_coercion_env [] coercion_env = coercion_env determine_cons_variables variables vect_and_subst = foldSt (foldSt determine_cons_variable) variables vect_and_subst determine_cons_variable tv_number (bitvects, subst) # (type, subst) = subst![tv_number] = case type of TE -> (set_bit tv_number bitvects, subst) // ---> ("determine_cons_variable1", tv_number) TempV var_number -> (set_bit var_number bitvects, subst) // ---> ("determine_cons_variable2", var_number) _ -> (bitvects, subst) build_coercion_env :: [.FunctionRequirements] v:{!Type} *Coercions {#CommonDefs} {#Int} *{#*{#TypeDefInfo}} *TypeHeaps !*ErrorAdmin -> (!w:{!Type},!.Coercions,!u:{#u:{#TypeDefInfo}},!.TypeHeaps,!.ErrorAdmin), [v <= w]; build_coercion_env [{fe_requirements={req_type_coercion_groups},fe_location={ip_ident}} : reqs_list] subst coercion_env common_defs cons_var_vects type_signs type_var_heap error # (subst, coercion_env, type_signs, type_var_heap, error) = foldSt (build_coercion_env_for_alternative ip_ident common_defs cons_var_vects) req_type_coercion_groups (subst, coercion_env, type_signs, type_var_heap, error) = build_coercion_env reqs_list subst coercion_env common_defs cons_var_vects type_signs type_var_heap error build_coercion_env [] subst coercion_env common_defs cons_var_vects type_signs type_var_heap error = (subst, coercion_env, type_signs, type_var_heap, error) build_coercion_env_for_alternative fun_symb common_defs cons_var_vects {tcg_position, tcg_type_coercions} (subst, coercion_env, type_signs, type_var_heap, error) # error = setErrorAdmin (newPosition fun_symb tcg_position) error = add_to_coercion_env tcg_type_coercions subst coercion_env common_defs cons_var_vects type_signs type_var_heap error add_to_coercion_env [{tc_offered,tc_demanded,tc_coercible,tc_position} : attr_coercions] subst coercion_env common_defs cons_var_vects type_signs type_var_heap error # (opt_error_info, subst, coercion_env, type_signs, type_var_heap) = determineAttributeCoercions tc_offered tc_demanded tc_coercible subst coercion_env common_defs cons_var_vects type_signs type_var_heap (coercion_env, error) = case opt_error_info of No -> (coercion_env, error) Yes (positions, exp_off_type) # (error=:{ea_file}) = errorHeading "Uniqueness error" error (coercion_env, copy_coercion_env) = uniqueCopy coercion_env format = { form_properties = cMarkAttribute, form_attr_position = Yes (reverse positions, copy_coercion_env) } ea_file = case tc_position of CP_FunArg _ _ -> ea_file <<< "\"" <<< tc_position <<< "\" " _ -> ea_file ea_file = ea_file <<< "attribute at indicated position could not be coerced " <:: (format, exp_off_type, Yes initialTypeVarBeautifulizer) <<< '\n' -> (coercion_env, { error & ea_file = ea_file }) = add_to_coercion_env attr_coercions subst coercion_env common_defs cons_var_vects type_signs type_var_heap error add_to_coercion_env [] subst coercion_env common_defs cons_var_vects type_signs type_var_heap error = (subst, coercion_env, type_signs, type_var_heap, error) collect_and_expand_overloaded_calls [] calls subst_and_heap = (calls, subst_and_heap) collect_and_expand_overloaded_calls [{ fe_context=Yes context, fe_requirements={req_overloaded_calls,req_case_and_let_exprs}, fe_location, fe_index}:reqs] calls (subst, expr_heap) # (context, subst) = arraySubst context subst subst_expr_heap = expand_case_or_let_types req_case_and_let_exprs (subst, expr_heap) = collect_and_expand_overloaded_calls reqs [(Yes context, req_overloaded_calls, fe_location, fe_index) : calls] (foldSt expand_type_contexts req_overloaded_calls subst_expr_heap) collect_and_expand_overloaded_calls [{fe_context, fe_requirements={req_overloaded_calls,req_case_and_let_exprs}, fe_location, fe_index}:reqs] calls subst_expr_heap # subst_expr_heap = expand_case_or_let_types req_case_and_let_exprs subst_expr_heap = collect_and_expand_overloaded_calls reqs [(fe_context, req_overloaded_calls, fe_location, fe_index) : calls] (foldSt expand_type_contexts req_overloaded_calls subst_expr_heap) expand_type_contexts over_info_ptr (subst, expr_heap) # (EI_Overloaded info, expr_heap) = readPtr over_info_ptr expr_heap (oc_context, subst) = arraySubst info.oc_context subst = (subst, expr_heap <:= (over_info_ptr, EI_Overloaded { info & oc_context = oc_context })) //---> oc_context expand_case_or_let_types info_ptrs subst_expr_heap = foldSt expand_case_or_let_type info_ptrs subst_expr_heap expand_case_or_let_type info_ptr (subst, expr_heap) = case (readPtr info_ptr expr_heap) of (EI_CaseType case_type, expr_heap) # (case_type, subst) = arraySubst case_type subst -> (subst, expr_heap <:= (info_ptr, EI_CaseType case_type)) (EI_LetType let_type, expr_heap) # (let_type, subst) = arraySubst let_type subst -> (subst, expr_heap <:= (info_ptr, EI_LetType let_type)) expand_function_types :: ![Int] !*{!Type} *{! FunctionType} -> (!*{!Type}, *{! FunctionType}) expand_function_types [fun : funs] subst ts_fun_env # (fun_type, ts_fun_env) = ts_fun_env![fun] = case fun_type of UncheckedType tst # (exp_tst, subst) = arraySubst tst subst -> expand_function_types funs subst { ts_fun_env & [fun] = UncheckedType exp_tst} SpecifiedType ft _ tst # (exp_tst, subst) = arraySubst tst subst -> expand_function_types funs subst { ts_fun_env & [fun] = ExpandedType ft tst exp_tst} expand_function_types [] subst ts_fun_env = (subst, ts_fun_env) update_function_types :: !Index !{!Group} !*{!FunctionType} !*{#FunDef} -> (!*{#FunDef}, !*{!FunctionType}) update_function_types group_index comps fun_env fun_defs | group_index == size comps = (fun_defs, fun_env) #! comp = comps.[group_index] # (fun_defs, fun_env) = update_function_types_in_component comp.group_members fun_env fun_defs = update_function_types (inc group_index) comps fun_env fun_defs where update_function_types_in_component :: ![Index] !*{!FunctionType} !*{#FunDef} -> (!*{#FunDef}, !*{!FunctionType}) update_function_types_in_component [ fun_index : funs ] fun_env fun_defs # (CheckedType checked_fun_type, fun_env) = fun_env![fun_index] # (fd, fun_defs) = fun_defs![fun_index] = case fd.fun_type of No -> update_function_types_in_component funs fun_env { fun_defs & [fun_index] = { fd & fun_type = Yes checked_fun_type }} Yes fun_type # nr_of_lifted_arguments = checked_fun_type.st_arity - fun_type.st_arity | nr_of_lifted_arguments > 0 # fun_type = addLiftedArgumentsToSymbolType fun_type nr_of_lifted_arguments checked_fun_type.st_args checked_fun_type.st_vars checked_fun_type.st_attr_vars checked_fun_type.st_context -> update_function_types_in_component funs fun_env { fun_defs & [fun_index] = { fd & fun_type = Yes fun_type }} -> update_function_types_in_component funs fun_env fun_defs update_function_types_in_component [] fun_env fun_defs = (fun_defs, fun_env) type_functions group ti cons_variables fun_defs ts = mapSt (type_function ti) group (cons_variables, fun_defs, ts) // ((cons_variables, fun_defs, ts) ---> "[(") ---> ")]" type_function ti fun_index (cons_variables, fun_defs, ts=:{ts_fun_env, ts_var_heap, ts_expr_heap, ts_error}) # (fd, fun_defs) = fun_defs![fun_index] (type, ts_fun_env) = ts_fun_env![fun_index] {fun_symb,fun_arity,fun_body=TransformedBody {tb_args,tb_rhs},fun_pos, fun_info, fun_type} = fd temp_fun_type = type_of type ts_var_heap = makeBase fun_symb 1 tb_args temp_fun_type.tst_args ts_var_heap fe_location = newPosition fun_symb fun_pos ts_error = setErrorAdmin fe_location ts_error reqs = { req_overloaded_calls = [], req_type_coercion_groups = [], req_type_coercions = [], req_attr_coercions = [], req_case_and_let_exprs = [], req_cons_variables = cons_variables } ( rhs_type, rhs_expr_ptr, (rhs_reqs, ts)) = requirements ti tb_rhs (reqs, { ts & ts_var_heap = ts_var_heap, ts_expr_heap = ts_expr_heap, ts_error = ts_error, ts_fun_env = ts_fun_env }) req_type_coercions = [{tc_demanded = temp_fun_type.tst_result,tc_offered = rhs_type, tc_position = CP_Expression tb_rhs, tc_coercible = True} : rhs_reqs.req_type_coercions ] ts_expr_heap = storeAttribute rhs_expr_ptr temp_fun_type.tst_result.at_attribute ts.ts_expr_heap type_coercion_group_from_accu = { tcg_type_coercions = req_type_coercions, tcg_position = fun_pos } req_type_coercion_groups = [type_coercion_group_from_accu:rhs_reqs.req_type_coercion_groups] = ( { fe_location = fe_location, fe_context = if (has_option fun_type) (Yes temp_fun_type.tst_context) No, fe_index = fun_index, fe_requirements = { rhs_reqs & req_type_coercions = [], req_type_coercion_groups = req_type_coercion_groups, req_cons_variables = [] } }, (rhs_reqs.req_cons_variables, fun_defs, { ts & ts_expr_heap = ts_expr_heap })) // ---> ("type_function", fun_symb, tb_args, tb_rhs, fun_info.fi_local_vars) where has_option (Yes _) = True has_option No = False type_of (UncheckedType tst) = tst type_of (SpecifiedType _ _ tst) = tst convert_array_instances si_array_instances common_defs fun_defs predef_symbols type_heaps | isEmpty si_array_instances = (fun_defs, predef_symbols, type_heaps) # ({pds_ident,pds_module,pds_def},predef_symbols) = predef_symbols![PD_UnboxedArrayType] unboxed_array_type = TA (MakeTypeSymbIdent { glob_object = pds_def, glob_module = pds_module } pds_ident 0) [] ({pds_module,pds_def},predef_symbols) = predef_symbols![PD_ArrayClass] {class_members} = common_defs.[pds_module].com_class_defs.[pds_def] array_members = common_defs.[pds_module].com_member_defs (offset_table, _, predef_symbols) = arrayFunOffsetToPD_IndexTable array_members predef_symbols (instances, type_heaps) = foldSt (convert_array_instance class_members array_members unboxed_array_type offset_table) si_array_instances ([], type_heaps) = (arrayPlusList fun_defs instances, predef_symbols, type_heaps) where convert_array_instance class_members array_members unboxed_array_type offset_table {ai_record} funs_and_heaps = create_instance_types class_members array_members unboxed_array_type offset_table (TA ai_record []) (size class_members) funs_and_heaps where create_instance_types members array_members unboxed_array_type offset_table record_type member_index funs_and_heaps | member_index == 0 = funs_and_heaps # member_index = dec member_index funs_and_heaps = create_instance_type members array_members unboxed_array_type offset_table record_type member_index funs_and_heaps = create_instance_types members array_members unboxed_array_type offset_table record_type member_index funs_and_heaps create_instance_type members array_members unboxed_array_type offset_table record_type member_index (array_defs, type_heaps) # {me_type,me_symb,me_class_vars,me_pos} = array_members.[members.[member_index].ds_index] (instance_type, _, type_heaps, _) = determineTypeOfMemberInstance me_type me_class_vars {it_vars = [], it_attr_vars = [], it_context = [], it_types = [unboxed_array_type, record_type]} SP_None type_heaps No instance_type = makeElemTypeOfArrayFunctionStrict instance_type member_index offset_table fun = { fun_symb = me_symb , fun_arity = me_type.st_arity , fun_priority = NoPrio , fun_body = NoBody , fun_type = Yes instance_type , fun_pos = me_pos , fun_index = member_index , fun_kind = FK_DefOrImpUnknown , fun_lifted = 0 , fun_info = EmptyFunInfo } = ([fun : array_defs], type_heaps) create_erroneous_function_types group ts = foldSt create_erroneous_function_type group ts create_erroneous_function_type fun ts # (env_type, ts) = ts!ts_fun_env.[fun] = case env_type of ExpandedType fun_type tmp_fun_type exp_fun_type # (fun_type, ts_type_heaps) = extendSymbolType fun_type tmp_fun_type.tst_lifted ts.ts_type_heaps -> { ts & ts_type_heaps = ts_type_heaps, ts_fun_env = { ts.ts_fun_env & [fun] = CheckedType fun_type }} UncheckedType tmp_fun_type # (clean_fun_type, ts_type_heaps) = cleanSymbolType tmp_fun_type.tst_arity ts.ts_type_heaps -> { ts & ts_type_heaps = ts_type_heaps, ts_fun_env = { ts.ts_fun_env & [fun] = CheckedType clean_fun_type }} SpecifiedType fun_type _ tmp_fun_type # (fun_type, ts_type_heaps) = extendSymbolType fun_type tmp_fun_type.tst_lifted ts.ts_type_heaps -> { ts & ts_type_heaps = ts_type_heaps, ts_fun_env = { ts.ts_fun_env & [fun] = CheckedType fun_type }} CheckedType _ -> ts is_rare_name {id_name} = id_name.[0]=='_' getPositionOfExpr expr=:(Var {var_info_ptr}) var_heap # (VI_Type _ opt_position, var_heap) = readPtr var_info_ptr var_heap = (case opt_position of Yes position -> position No -> CP_Expression expr, var_heap) getPositionOfExpr expr var_heap = (CP_Expression expr, var_heap) empty_id =: { id_name = "", id_info = nilPtr } instance <<< AttrCoercion where (<<<) file {ac_demanded,ac_offered} = file <<< "AttrCoercion: " <<< ac_demanded <<< '~' <<< ac_offered instance <<< TypeCoercion where (<<<) file {tc_demanded,tc_offered} = file <<< "TypeCoercion: " <<< tc_demanded <<< '~' <<< tc_offered instance <<< TypeContext where (<<<) file co = file <<< "TypeContext: (tc_class)=" <<< co.tc_class <<< " (tc_var)=" <<< ptrToInt co.tc_var <<< " (tc_types)=" <<< " " <<< co.tc_types instance <<< DefinedSymbol where (<<<) file {ds_ident} = file <<< "DefinedSymbol: " <<< ds_ident instance <<< FunctionType where (<<<) file (CheckedType _) = file <<< "CheckedType" (<<<) file (SpecifiedType _ _ _) = file <<< "SpecifiedType" (<<<) file (UncheckedType _) = file <<< "UncheckedType" (<<<) file (ExpandedType _ _ _) = file <<< "ExpandedType" (<<<) file EmptyFunctionType = file <<< "EmptyFunctionType"