optimised consequence checking for explicit imports

git-svn-id: https://svn.cs.ru.nl/repos/clean-compiler/trunk@183 1f8540f1-abd5-4d5b-9d24-4c5ce8603e2d

3 files changed, 421 insertions, 448 deletions

diff --git a/frontend/check.icl b/frontend/check.icl
index 975ebec..1ec64ca 100644
--- a/frontend/check.icl
+++ b/frontend/check.icl
@@ -2621,19 +2621,17 @@ checkModule {mod_type,mod_name,mod_imports,mod_imported_objects,mod_defs = cdefs
 
 	  (iinfo, heaps, cs) = check_dcl_module iinfo heaps cs
 
-	  (_, {ii_modules,ii_funs_and_macros = icl_functions}, heaps, cs) = checkImports mod_imports iinfo heaps cs
+	  (_, {ii_modules,ii_funs_and_macros = icl_functions}, heaps=:{hp_expression_heap}, cs) 
+	  		= checkImports mod_imports iinfo heaps cs
 
 	  cs = { cs & cs_needed_modules = 0 }
 	  
-	  (nr_of_modules, (f_consequences, ii_modules, icl_functions, hp_expression_heap, cs))
-	  	= check_completeness_of_all_dcl_modules ii_modules icl_functions heaps.hp_expression_heap cs
-
 	  (dcls_explicit, dcl_modules, cs)	= addImportsToSymbolTable mod_imports [] ii_modules cs
 	  cs			    				= addGlobalDefinitionsToSymbolTable local_defs cs
 
-	  (_, dcl_modules, icl_functions, hp_expression_heap, cs)
-		= check_completeness_of_module nr_of_modules dcls_explicit (mod_name.id_name+++".icl")
-							 (f_consequences, dcl_modules, icl_functions, hp_expression_heap, cs)
+	  (dcl_modules, icl_functions, hp_expression_heap, cs)
+		= checkExplicitImportCompleteness (mod_name.id_name+++".icl") dcls_explicit
+							 				dcl_modules icl_functions hp_expression_heap cs
 
 	  heaps	= { heaps & hp_expression_heap=hp_expression_heap }
 
@@ -2770,7 +2768,7 @@ checkModule {mod_type,mod_name,mod_imports,mod_imported_objects,mod_defs = cdefs
 			# cs = { cs & cs_symbol_table = cs_symbol_table <:= (id_info, { entry & ste_kind = STE_ClosedModule })}
 			  {ste_kind = STE_Module mod, ste_index} = entry
 			  (modules, macro_and_fun_defs, heaps, cs)
-			  		= checkDclModule mod ste_index modules macro_and_fun_defs heaps cs
+			  		= checkDclModule False mod ste_index modules macro_and_fun_defs heaps cs
 			  ({dcl_declared={dcls_import,dcls_local}}, modules) = modules![ste_index]
 			= (modules, macro_and_fun_defs, heaps, addDeclaredSymbolsToSymbolTable cIsADclModule ste_index dcls_local dcls_import cs)
 
@@ -3001,19 +2999,38 @@ checkImport module_id_info entry=:{ste_kind = STE_Module mod, ste_index} iinfo=:
 	| ii_next_num <= min_mod_num
 		# {ii_deps,ii_modules,ii_funs_and_macros} = iinfo
 		  (ii_deps, ii_modules, ii_funs_and_macros, heaps, cs)
-		  		= check_component module_id_info ii_deps ii_modules ii_funs_and_macros heaps cs
+		  		= check_component [] module_id_info ii_deps ii_modules ii_funs_and_macros heaps cs
 		#! max_mod_num = size ii_modules
 		= (max_mod_num, { iinfo & ii_deps = ii_deps, ii_modules = ii_modules, ii_funs_and_macros = ii_funs_and_macros }, heaps, cs) 
 		= (min_mod_num, iinfo, heaps, cs)
 	where
-		check_component lowest_mod_info [mod_info : ds] modules macro_and_fun_defs heaps cs=:{cs_symbol_table}
+		check_component component lowest_mod_info [mod_info : ds] modules macro_and_fun_defs heaps 
+						cs=:{cs_symbol_table}
 			# (entry, cs_symbol_table) = readPtr mod_info cs_symbol_table
-			# {ste_kind=STE_OpenModule _ mod,ste_index} = entry
-		  	  (modules, macro_and_fun_defs, heaps, cs) = checkDclModule mod ste_index modules macro_and_fun_defs heaps { cs & cs_symbol_table = cs_symbol_table }
+			  {ste_kind=STE_OpenModule _ mod,ste_index} = entry
+			  is_on_cycle = lowest_mod_info<>mod_info || not (isEmpty component)
+		  	  (modules, macro_and_fun_defs, heaps=:{hp_expression_heap}, cs)
+		  	  		= checkDclModule is_on_cycle mod ste_index modules macro_and_fun_defs heaps { cs & cs_symbol_table = cs_symbol_table }
 		  	  cs = { cs & cs_symbol_table = cs.cs_symbol_table <:= (mod_info, { entry & ste_kind = STE_ClosedModule })}
 			| lowest_mod_info == mod_info
+				| is_on_cycle
+					# (modules, macro_and_fun_defs, hp_expression_heap, cs)
+						= foldSt check_explicit_import_completeness [ste_index:component] 
+									(modules, macro_and_fun_defs, hp_expression_heap, cs)
+					= (ds, modules, macro_and_fun_defs, { heaps & hp_expression_heap = hp_expression_heap }, cs)
 				= (ds, modules, macro_and_fun_defs, heaps, cs)
-				= check_component lowest_mod_info ds modules macro_and_fun_defs heaps cs
+				= check_component [ste_index:component] lowest_mod_info ds modules macro_and_fun_defs heaps cs
+			
+		check_explicit_import_completeness mod_index (modules, macro_and_fun_defs, hp_expression_heap, cs)
+			# ({dcl_name, dcl_declared}, modules) = modules![mod_index]
+			  ({dcls_local, dcls_import, dcls_explicit}) = dcl_declared
+			  cs = addDeclaredSymbolsToSymbolTable cIsADclModule mod_index dcls_local dcls_import cs
+			  (modules, macro_and_fun_defs, hp_expression_heap, cs=:{cs_symbol_table})
+			  		= checkExplicitImportCompleteness (dcl_name.id_name+++".dcl") dcls_explicit
+														modules macro_and_fun_defs hp_expression_heap cs
+			  (_, cs_symbol_table) = retrieveAndRemoveImportsFromSymbolTable [(mod_index, dcl_declared)] [] cs_symbol_table
+			  // XXX optimise by using version that does not allocate the first result value
+			= (modules, macro_and_fun_defs, hp_expression_heap, { cs & cs_symbol_table = cs_symbol_table })
 
 initialDclModule ({mod_name, mod_defs=mod_defs=:{def_funtypes,def_macros}, mod_type}, sizes, all_defs)
 	# dcl_common= createCommonDefinitions mod_defs
@@ -3036,9 +3053,9 @@ initialDclModule ({mod_name, mod_defs=mod_defs=:{def_funtypes,def_macros}, mod_t
 								_			-> False
 		}
 
-checkDclModule :: !(Module (CollectedDefinitions ClassInstance IndexRange)) !Index !*{#DclModule} !*{#FunDef} !*Heaps !*CheckState
+checkDclModule :: !Bool !(Module (CollectedDefinitions ClassInstance IndexRange)) !Index !*{#DclModule} !*{#FunDef} !*Heaps !*CheckState
 	-> (!*{#DclModule}, !*{#FunDef}, !*Heaps, !*CheckState)
-checkDclModule {mod_name,mod_imports,mod_defs} mod_index modules icl_functions heaps=:{hp_var_heap, hp_type_heaps} cs
+checkDclModule is_on_cycle {mod_name,mod_imports,mod_defs} mod_index modules icl_functions heaps=:{hp_var_heap, hp_type_heaps} cs
 	# (dcl_mod, modules)			= modules![mod_index]
 	# dcl_defined 					= dcl_mod.dcl_declared.dcls_local
 	  dcl_common					= createCommonDefinitions mod_defs
@@ -3076,11 +3093,19 @@ checkDclModule {mod_name,mod_imports,mod_defs} mod_index modules icl_functions h
 	  			 ef_cons_defs = dcl_common.com_cons_defs, ef_member_defs = com_member_defs, ef_modules = modules,
 				 ef_is_macro_fun = False }
 
-	  (icl_functions, e_info, heaps, cs)
+	  (icl_functions, e_info=:{ef_modules=modules}, heaps=:{hp_expression_heap}, cs)
 			= checkMacros mod_index dcl_macros icl_functions e_info heaps cs
-
+	  
 	  cs = check_needed_modules_are_imported mod_name ".dcl" cs
 
+	  dcls_explicit	= flatten [dcls_explicit \\ (_,{dcls_explicit})<-imports]
+	  (modules, icl_functions, hp_expression_heap, cs)
+			= case is_on_cycle of
+				False 	-> checkExplicitImportCompleteness (mod_name.id_name+++".dcl") dcls_explicit
+											 				modules icl_functions hp_expression_heap cs
+				True	-> (modules, icl_functions, hp_expression_heap, cs)
+	  heaps = { heaps & hp_expression_heap = hp_expression_heap }
+
  	  first_special_class_index = size com_instance_defs
  	  last_special_class_index = first_special_class_index + length new_class_instances
 	  
@@ -3090,14 +3115,12 @@ checkDclModule {mod_name,mod_imports,mod_defs} mod_index modules icl_functions h
 	  (dcl_imported, cs_symbol_table) = retrieveAndRemoveImportsFromSymbolTable imports [] cs.cs_symbol_table
 	  cs_symbol_table = removeDeclarationsFromSymbolTable dcl_defined cModuleScope cs_symbol_table
 
-	  dcls_explicit	= flatten [dcls_explicit \\ (_,{dcls_explicit})<-imports]
-
 	  dcl_mod = { dcl_mod &  dcl_declared = { dcl_mod.dcl_declared & dcls_import = dcl_imported, dcls_explicit = dcls_explicit },
 	  			 dcl_common = dcl_common, dcl_functions = dcl_functions, 
 	  			 dcl_instances = { ir_from = nr_of_dcl_functions, ir_to = nr_of_dcl_functions_and_instances },
 	  			 dcl_specials = { ir_from = nr_of_dcl_functions_and_instances, ir_to = nr_of_dcl_funs_insts_and_specs },
 	  			 dcl_class_specials = { ir_from = first_special_class_index, ir_to = last_special_class_index }}
-	= ({ e_info.ef_modules & [ mod_index ] = dcl_mod }, icl_functions, heaps, { cs & cs_symbol_table = cs_symbol_table })
+	= ({ modules & [ mod_index ] = dcl_mod }, icl_functions, heaps, { cs & cs_symbol_table = cs_symbol_table })
 where
 	collect_imported_symbols [{import_module={id_info},import_symbols,import_file_position} : mods ] all_decls modules cs=:{cs_symbol_table}
 		# (entry, cs_symbol_table) = readPtr id_info cs_symbol_table
diff --git a/frontend/explicitimports.dcl b/frontend/explicitimports.dcl
index 3a1b1f9..15e346d 100644
--- a/frontend/explicitimports.dcl
+++ b/frontend/explicitimports.dcl
@@ -8,9 +8,8 @@ temporary_import_solution_XXX yes no :== yes
 // This feature will be removed, when all programs are ported to Clean 2.0. The last Constructors of AtomType
 // and StructureType should then be removed also
 
-::	FunctionConsequence
-
-possibly_filter_decls :: .[ImportDeclaration] u:[w:(.Index,y:Declarations)] (.FileName,.LineNr) *{#.DclModule} *CheckState -> (v:[x:(Index,z:Declarations)],.{#DclModule},.CheckState), [y <= z, w <= x, u <= v];
-check_completeness_of_module :: .Index [(.Declaration,.Int)] .String *(*{!.FunctionConsequence},*{#.DclModule},*{#FunDef},*ExpressionHeap,*CheckState) -> (.{!FunctionConsequence},.{#DclModule},.{#FunDef},.ExpressionHeap,.CheckState);
-check_completeness_of_all_dcl_modules	:: !*{#DclModule} !*{#FunDef} !*ExpressionHeap !*CheckState
-									-> (!Int, !(!*{!FunctionConsequence}, !*{#DclModule}, !*{#FunDef}, !*ExpressionHeap, !*CheckState))
+possibly_filter_decls :: ![ImportDeclaration] ![(!Index,!Declarations)] !(!FileName,!LineNr) !*{#DclModule} !*CheckState 
+						-> (![(!Index,!Declarations)],!.{#DclModule},!.CheckState)
+checkExplicitImportCompleteness :: !String ![(!Declaration,!Int)]
+									!*{#DclModule} !*{#FunDef} !*ExpressionHeap !*CheckState 
+								-> (!.{#DclModule},!.{#FunDef},!.ExpressionHeap,!.CheckState)
diff --git a/frontend/explicitimports.icl b/frontend/explicitimports.icl
index 958e385..2f046ee 100644
--- a/frontend/explicitimports.icl
+++ b/frontend/explicitimports.icl
@@ -1,4 +1,5 @@
 implementation module explicitimports
+// compile using the "reuse unique nodes" option
 
 import StdEnv
 
@@ -26,48 +27,11 @@ do_temporary_import_solution_XXX :== temporary_import_solution_XXX True False
 ::	StructureType	= ST_AlgType | ST_RecordType | ST_Class
 					| ST_stomm_stomm_stomm String
 ::	IdentWithKind	:==	(!Ident, !STE_Kind)
-::	IdentWithCKind	:==	(!Ident, !ConsequenceKind)
-
-::	OptimizeInfo	:==	(Optional !Index)
-
-::	ConsequenceKind	= CK_Function !(Global Index)
-					| CK_DynamicPatternType ExprInfoPtr
-					| CK_Macro
-					| CK_Constructor
-					| CK_Selector !(Global DefinedSymbol)
-					| CK_Type
-					| CK_Class
-
-::	FunctionConsequence	:==	Optional !(!Int, !Optional ![IdentWithCKind])
-	// Int i: The consequences of this function/macro have already been considered for all dcl modules with indices <= i
-
-check_completeness_of_all_dcl_modules	:: !*{#DclModule} !*{#FunDef} !*ExpressionHeap !*CheckState
-									-> (!Int, !(!*{!FunctionConsequence}, !*{#DclModule}, !*{#FunDef}, !*ExpressionHeap, !*CheckState))
-check_completeness_of_all_dcl_modules modules icl_functions expr_heap cs
-	#	(nr_modules, modules)	= usize modules
-		(nr_functions, icl_functions)	= usize icl_functions
-		f_consequences	= f_consequences nr_functions
-		result
-			= iFoldSt check_completeness_of_dcl_module 0 (nr_modules) (f_consequences, modules, icl_functions, expr_heap, cs)
-	= (nr_modules, result)
-  where
-	f_consequences :: !Int -> *{!FunctionConsequence}
-	f_consequences i = createArray i No
-
-check_completeness_of_dcl_module mod_index (f_consequences, modules, icl_functions, expr_heap, cs=:{cs_predef_symbols})
-	#	pre_mod = cs_predef_symbols.[PD_PredefinedModule]
-	|	pre_mod.pds_def == mod_index
-		= (f_consequences, modules, icl_functions, expr_heap, cs)	// predefined module should not be checked for completeness of explicit imports
-	#	(modul=:{ dcl_name, dcl_declared=dcl_declared=:{dcls_import,dcls_local, dcls_explicit}}, modules)
-			= modules![mod_index]
-		cs	= addDeclaredSymbolsToSymbolTable cIsADclModule mod_index dcls_local dcls_import cs
-		(f_consequences, modules, icl_functions, expr_heap, cs)
-			= check_completeness_of_module mod_index dcls_explicit (dcl_name.id_name+++".dcl") (f_consequences, modules, icl_functions, expr_heap, cs)
-		(_, cs_symbol_table) = retrieveAndRemoveImportsFromSymbolTable [(mod_index, dcl_declared)] [] cs.cs_symbol_table
-		cs	= { cs & cs_symbol_table=cs_symbol_table }
-	= (f_consequences, modules, icl_functions, expr_heap, cs)
 
-possibly_filter_decls :: .[ImportDeclaration] u:[w:(.Index,y:Declarations)] (.FileName,.LineNr) *{#.DclModule} *CheckState -> (v:[x:(Index,z:Declarations)],.{#DclModule},.CheckState), [y <= z, w <= x, u <= v];
+::	OptimizeInfo	:==	Optional Index
+
+possibly_filter_decls :: ![ImportDeclaration] ![(!Index,!Declarations)] !(!FileName,!LineNr) !*{#DclModule} !*CheckState 
+						-> (![(!Index,!Declarations)],!.{#DclModule},!.CheckState)
 possibly_filter_decls [] decls_of_imported_module	_ modules cs // implicit import can't go wrong
 	= (decls_of_imported_module, modules, cs)
 possibly_filter_decls listed_symbols decls_of_imported_module (file_name, line_nr) modules cs
@@ -233,23 +197,6 @@ instance toInt AtomType
 	toInt (AT_stomme_funktion_die_alle_symbolen_kann_importeren_omdat_niemand_zin_heft_oude_pragrammen_naar_de_nieuwe_syntax_te_vertalen _)
 						= 0
 
-instance == ConsequenceKind
-  where
-	(==) CK_Type		c = case c of	CK_Type	-> True
-										_		-> False
-	(==) CK_Constructor	c = case c of	CK_Constructor	-> True
-										_		-> False
-	(==) (CK_Selector globDefinedSymb1)
-						c = case c of	CK_Selector globDefinedSymb2 -> globDefinedSymb1==globDefinedSymb2
-										_		-> False
-	(==) CK_Class		c = case c of	CK_Class-> True
-										_		-> False
-	(==) (CK_Function globIndex1)
-						c = case c of	(CK_Function	globIndex2) -> globIndex1==globIndex2
-										_		-> False
-	(==) CK_Macro		c = case c of	CK_Macro-> True
-										_		-> False
-
 NoPosition :== -1
 
 filter_decl :: [.Declaration] ([(Ident,AtomType)],[(Ident,StructureInfo,StructureType,Optional Int)]) Int *{#DclModule} *CheckState -> (!(!.[Declaration],!([(Ident,AtomType)],![(Ident,StructureInfo,StructureType,Optional Int)])),!.{#DclModule},!.CheckState);
@@ -257,10 +204,11 @@ filter_decl [] unimported _ modules cs
 	= (([], unimported), modules, cs)
 filter_decl [decl:decls] unimported index modules cs
 	# ((appears,unimported), modules, cs) = decl_appears decl unimported index modules cs
-	  (r=:((recurs, unimported), modules, cs)) = filter_decl decls unimported index modules cs
 	| appears
+		# ((recurs, unimported), modules, cs) = filter_decl decls unimported index modules cs
+
 		= (([decl:recurs],unimported), modules, cs)
-	= r
+	= 	filter_decl decls unimported index modules cs
 	
 decl_appears :: !Declaration !ExplicitImports !Index !*{#DclModule} !*CheckState
 			 -> (!(!Bool, !ExplicitImports), !*{#DclModule}, !*CheckState)
@@ -307,6 +255,7 @@ decl_appears {dcl_ident, dcl_kind, dcl_index} unimported index modules cs
 	isAtom STE_Instance				= True
 
 
+elementAppears :: .StructureType Ident !.Int !(.a,![(Ident,.StructureInfo,.StructureType,Optional .Int)]) !.Int !*{#.DclModule} !*CheckState -> (!(!Bool,(!.a,![(Ident,StructureInfo,StructureType,Optional Int)])),!.{#DclModule},!.CheckState);
 elementAppears imported_st dcl_ident dcl_index (atomicImports, structureImports) index modules cs
 	#	((result, structureImports), modules, cs)
 			=  element_appears imported_st dcl_ident dcl_index structureImports structureImports 0 index modules cs
@@ -317,7 +266,7 @@ atomAppears dcl_ident dcl_index (atomicImports, structureImports) index modules
 			= atom_appears dcl_ident dcl_index atomicImports atomicImports 0 index modules cs
 	= ((result, (atomicImports, structureImports)), modules, cs)
 
-atom_appears :: Ident .Int [(Ident,.AtomType)] w:[y:(Ident,u1:AtomType)] !Int .Int !u:{#u3:DclModule} !*CheckState -> (!(.Bool,x:[z:(Ident,u2:AtomType)]),!v:{#DclModule},!.CheckState) , [u <= v, u1 <= u2, y <= z, w <= x, u <= u3];
+atom_appears :: Ident !.Int [(Ident,.AtomType)] w:[y:(Ident,u1:AtomType)] !Int !.Int !u:{#u3:DclModule} !*CheckState -> (!(.Bool,x:[z:(Ident,u2:AtomType)]),!v:{#DclModule},!.CheckState) , [u <= v, u1 <= u2, y <= z, w <= x, u <= u3];
 atom_appears _ _ [] atomic_imports _ _ modules cs
   	= ((False, atomic_imports), modules, cs)
 atom_appears ident dcl_index [h=:(import_ident, atomType):t] atomic_imports unimp_index index modules cs
@@ -357,12 +306,12 @@ instance == StructureType
 	(==) ST_Class		ST_Class		= True
 	(==) _ _							= False
 
-element_appears :: StructureType Ident Int [(Ident,.StructureInfo,u2:StructureType,z:Optional .Int)] u:[w:(Ident,u5:StructureInfo,u3:StructureType,y:Optional Int)] !Int Int !*{#DclModule} !*CheckState -> (!(Bool,v:[x:(Ident,u6:StructureInfo,u4:StructureType,u1:Optional Int)]),!.{#DclModule},!.CheckState), [y z <= u1, u3 <= u4, u5 <= u6, w <= x, u <= v, u2 <= u3];
+element_appears :: StructureType Ident !Int [(Ident,.StructureInfo,u2:StructureType,z:Optional .Int)] u:[w:(Ident,u5:StructureInfo,u3:StructureType,y:Optional Int)] !Int !Int !*{#DclModule} !*CheckState -> (!(!Bool,!v:[x:(Ident,u6:StructureInfo,u4:StructureType,u1:Optional Int)]),!.{#DclModule},!.CheckState), [y z <= u1, u3 <= u4, u5 <= u6, w <= x, u <= v, u2 <= u3];
 element_appears _ _ _ [] atomic_imports _ _ modules cs
 	= ((False, atomic_imports), modules, cs)
 // MW2 remove this later ..
 element_appears imported_st element_ident dcl_index
-				[h=:(_, SI_DotDot, ST_stomm_stomm_stomm type_name_string, optInfo):t] atomic_imports unimp_index
+				[(_, SI_DotDot, ST_stomm_stomm_stomm type_name_string, optInfo):t] atomic_imports unimp_index
 				index modules cs
 	| do_temporary_import_solution_XXX
 		#	(appears, modules, cs)
@@ -373,19 +322,19 @@ element_appears imported_st element_ident dcl_index
 	// otherwise go further with next alternative
 // ..MW2
 element_appears imported_st element_ident dcl_index
-				[h=:(_, _, st, _):t] atomic_imports unimp_index
+				[(_, _, st, _):t] atomic_imports unimp_index
 				index modules cs
 	|	imported_st<>st
 		= element_appears imported_st element_ident dcl_index t atomic_imports (inc unimp_index) index modules cs
 	// goes further with next alternative
 element_appears imported_st element_ident dcl_index
-				[h=:(_, _, _, (Yes notDefinedHere)):t] atomic_imports unimp_index
+				[(_, _, _, (Yes notDefinedHere)):t] atomic_imports unimp_index
 				index modules cs
 	|	notDefinedHere==dcl_index 
 		= element_appears imported_st element_ident dcl_index t atomic_imports (inc unimp_index) index modules cs
 	// goes further with next alternative
 element_appears	imported_st element_ident dcl_index
-				[h=:(struct_id, (SI_Elements elements explicit), st, optInfo):t] atomic_imports unimp_index
+				[(struct_id, (SI_Elements elements explicit), st, optInfo):t] atomic_imports unimp_index
 				index modules cs
 	| not (isMember element_ident elements)
 		= element_appears imported_st element_ident dcl_index t atomic_imports (inc unimp_index) index modules cs
@@ -406,7 +355,7 @@ element_appears	imported_st element_ident dcl_index
 		cs	= { cs & cs_error= checkError element_ident message  cs.cs_error}
 	= ((False, atomic_imports_1), modules, cs)
 element_appears imported_st element_ident dcl_index
-				[h=:(struct_id, SI_DotDot, st, optInfo):t] atomic_imports unimp_index
+				[(struct_id, SI_DotDot, st, optInfo):t] atomic_imports unimp_index
 				index modules cs
 	| (case st of
 			ST_stomm_stomm_stomm _
@@ -443,7 +392,7 @@ lookup_type dcl_index index modules cs
 		#	com_type_def	= dcl_module.dcl_common.com_type_defs.[dcl_index]
 		= (com_type_def.td_rhs, modules, cs)
 
-element_appears_in_stomm_struct :: .StructureType Ident .Int .Int .String *{#DclModule} *CheckState -> (!Bool,!.{#DclModule},!.CheckState)
+element_appears_in_stomm_struct :: .StructureType Ident .Int .Int .String *{#DclModule} !*CheckState -> (!Bool,!.{#DclModule},!.CheckState)
 // MW remove this later CCC
 element_appears_in_stomm_struct imported_st element_ident dcl_index index type_name_string modules cs
 	| not do_temporary_import_solution_XXX
@@ -489,43 +438,7 @@ element_appears_in_stomm_struct imported_st element_ident dcl_index index type_n
 		= appears
 	appears _ _ _
 		= False
-/*
-	continuation ST_RecordType (STE_OpenModule _ modul) _ modules cs
-		//	lookup the constructors/fields for the algebraic type/record
-		#	allTypes	= modul.mod_defs.def_types
-			search		= dropWhile (\{td_name} -> td_name.id_name<>type_name_string) allTypes
-		|	isEmpty search
-			= (False, modules, cs)
-		#	{td_rhs}	= hd search
-		|	not (isRecordType td_rhs)
-			= (False, modules, cs)
-		#	element_idents	= getElements td_rhs
-		= (isMember element_ident element_idents, modules, cs)
-	continuation ST_RecordType STE_ClosedModule dcl_module modules cs
-		// lookup the type of the constructor and compare
-		#	type_index		= dcl_module.dcl_common.com_selector_defs.[dcl_index].sd_type_index
-			com_type_def	= dcl_module.dcl_common.com_type_defs.[type_index]
-			appears	= com_type_def.td_name.id_name==type_name_string
-		= (appears, modules, cs)
-	continuation ST_Class (STE_OpenModule _ modul) _ modules cs
-		//	lookup the members for the class
-		#	allClasses	= modul.mod_defs.def_classes
-			search		= dropWhile (\{class_name} -> class_name.id_name<>type_name_string) allClasses
-		|	isEmpty search
-			= (False, modules, cs)
-		#	{class_members}	= hd search
-			element_idents	= [ ds_ident \\ {ds_ident} <-:class_members ]
-		= (isMember element_ident element_idents, modules, cs)
-	continuation ST_Class STE_ClosedModule dcl_module modules cs
-		// lookup the class and compare
-		#	com_member_def	= dcl_module.dcl_common.com_member_defs.[dcl_index]
-			{glob_object}	= com_member_def.me_class
-			com_class_def	= dcl_module.dcl_common.com_class_defs.[glob_object]
-			appears	= com_class_def.class_name.id_name==type_name_string
-		= (appears, modules, cs)
-	continuation _ _ _ modules cs
-		= (False, modules, cs)
-*/
+
 	getElements (RecordType {rt_fields})
 		= [ fs_name \\ {fs_name}<-:rt_fields ]
 	getElements _
@@ -593,329 +506,367 @@ element_appears_in_struct imported_st element_ident dcl_index struct_ident index
 	getElements _
 		= []
 
-check_completeness_of_module :: .Index [(.Declaration,.Int)] .String *(*{!.FunctionConsequence},*{#.DclModule},*{#FunDef},*ExpressionHeap,*CheckState) -> (.{!FunctionConsequence},.{#DclModule},.{#FunDef},.ExpressionHeap,.CheckState);
-check_completeness_of_module mod_index dcls_explicit file_name (f_consequences, modules, icl_functions, expr_heap, cs)
-//	#	dcls_imp	= [((dcl_ident, kind), (dcl_index, mod_index), (file_name, line_nr))
-//						\\ ({dcl_ident, dcl_index, dcl_kind=STE_Imported kind mod_index}, line_nr) <- dcls_explicit]
-	#	(conseqs, (f_consequences, modules, icl_functions, expr_heap))
-				= mapSt (consequences_of file_name mod_index) dcls_explicit (f_consequences, modules, icl_functions, expr_heap)
-		conseqs	= flatten conseqs
-	#!	(modules, cs)	= foldr checkConsequenceError (modules, cs) conseqs
-	= (f_consequences, modules, icl_functions, expr_heap, cs)
-
-consequences_of :: String !Index
-					!(!.Declaration,Int) !(!*{!FunctionConsequence}, !*{#DclModule}, !*{#FunDef}, !*ExpressionHeap)
- 				->	(![(!IdentWithKind, !IdentWithCKind, !(!String, !Int))], !(*{!FunctionConsequence}, !*{#DclModule}, !*{#FunDef}, !*ExpressionHeap))
-consequences_of file_name count ({dcl_ident, dcl_index, dcl_kind}, line_nr) (f_consequences, modules, icl_functions, expr_heap)
-	= case dcl_kind of
-			STE_FunctionOrMacro _
-				# (consequences, (f_consequences, icl_functions, expr_heap)) 
-						= consequences_of_macro count dcl_index f_consequences icl_functions expr_heap
-				-> (add_kind_and_error_info_to_consequences dcl_kind consequences, (f_consequences, modules, icl_functions, expr_heap))
-			STE_Imported expl_imp_kind mod_index
-				-> case expl_imp_kind of
-						STE_FunctionOrMacro _
-							# (consequences, (f_consequences, icl_functions, expr_heap))
-									= consequences_of_macro count dcl_index f_consequences icl_functions expr_heap
-							-> (add_kind_and_error_info_to_consequences expl_imp_kind consequences, (f_consequences, modules, icl_functions, expr_heap))
-						_
-							# (modul, modules)	= modules![mod_index]
-							-> (add_kind_and_error_info_to_consequences expl_imp_kind (consequences_of_simple_symbol expl_imp_kind modul dcl_index), (f_consequences, modules, icl_functions, expr_heap))
+:: CheckCompletenessState =
+	{	ccs_dcl_modules				:: !.{#DclModule}
+	,	ccs_icl_functions			:: !.{#FunDef}
+	,	ccs_set_of_visited_icl_funs	:: !.{#Bool}		// ccs_set_of_visited_icl_funs.[i] <=> function nr i has been considered
+	,	ccs_expr_heap				:: !.ExpressionHeap
+	,	ccs_symbol_table			:: !.SymbolTable
+	,	ccs_error					:: !.ErrorAdmin
+	,	ccs_heap_changes_accu		:: ![SymbolPtr]
+	}
+:: *CheckCompletenessStateBox = { box_ccs :: !*CheckCompletenessState }
+
+:: CheckCompletenessInput =
+	{	cci_line_nr				:: !Int
+	,	cci_filename			:: !String
+	,	cci_expl_imported_ident	:: !Ident
+	}
+:: CheckCompletenessInputBox = { box_cci :: !CheckCompletenessInput }
+
+checkExplicitImportCompleteness :: !String ![(!Declaration,!Int)]
+								!*{#DclModule} !*{#FunDef} !*ExpressionHeap !*CheckState 
+								-> (!.{#DclModule},!.{#FunDef},!.ExpressionHeap,!.CheckState)
+checkExplicitImportCompleteness filename dcls_explicit dcl_modules icl_functions expr_heap 
+								cs=:{cs_symbol_table, cs_error}
+	#! nr_icl_functions = size icl_functions
+	   box_ccs = { ccs_dcl_modules = dcl_modules, ccs_icl_functions = icl_functions,
+	   			ccs_set_of_visited_icl_funs = createArray nr_icl_functions False,
+				ccs_expr_heap = expr_heap, ccs_symbol_table = cs_symbol_table,
+				ccs_error = cs_error, ccs_heap_changes_accu = [] }
+	   ccs = foldSt (checkCompleteness filename) dcls_explicit { box_ccs = box_ccs }
+	   { ccs_dcl_modules, ccs_icl_functions, ccs_expr_heap, ccs_symbol_table, ccs_error, ccs_heap_changes_accu }
+	   		= ccs.box_ccs
+	// repair heap contents
+	   ccs_symbol_table = foldSt replace_ste_with_previous ccs_heap_changes_accu ccs_symbol_table
+	   cs = { cs & cs_symbol_table = ccs_symbol_table, cs_error = ccs_error }
+	= (ccs_dcl_modules, ccs_icl_functions, ccs_expr_heap, cs)
   where
-	errMsgInfo = (file_name, line_nr)
-	add_kind_and_error_info_to_consequences expl_imp_kind consequences
-		= [(expl_imp_ident_kind, conseq, errMsgInfo) \\ conseq<-removeDup consequences]
-	  where
-		expl_imp_ident_kind=(dcl_ident,expl_imp_kind)
+	checkCompleteness :: !String !(!Declaration, !Int) *CheckCompletenessStateBox -> *CheckCompletenessStateBox
+	checkCompleteness filename ({dcl_ident, dcl_index, dcl_kind=STE_FunctionOrMacro _}, line_nr) ccs 
+		= checkCompletenessOfMacro filename dcl_ident dcl_index line_nr ccs
+	checkCompleteness filename ({dcl_ident, dcl_index, dcl_kind=STE_Imported (STE_FunctionOrMacro _) mod_index}, line_nr) ccs 
+		= checkCompletenessOfMacro filename dcl_ident dcl_index line_nr ccs
+	checkCompleteness filename ({dcl_ident, dcl_index, dcl_kind=STE_Imported expl_imp_kind mod_index}, line_nr) ccs 
+		#! ({dcl_common,dcl_functions}, ccs) = ccs!box_ccs.ccs_dcl_modules.[mod_index]
+		   cci = { box_cci = { cci_line_nr = line_nr, cci_filename = filename, cci_expl_imported_ident = dcl_ident }}
+		= case expl_imp_kind of
+			STE_Type			-> check_completeness dcl_common.com_type_defs.[dcl_index] cci ccs
+			STE_Constructor		-> check_completeness dcl_common.com_cons_defs.[dcl_index] cci ccs
+			(STE_Field _)		-> check_completeness dcl_common.com_selector_defs.[dcl_index] cci ccs
+			STE_Class			-> check_completeness dcl_common.com_class_defs.[dcl_index] cci ccs
+			STE_Member			-> check_completeness dcl_common.com_member_defs.[dcl_index] cci ccs
+			STE_Instance		-> check_completeness dcl_common.com_instance_defs.[dcl_index] cci ccs
+			STE_DclFunction		-> check_completeness dcl_functions.[dcl_index] cci ccs
 	
-consequences_of_macro count dcl_index f_consequences icl_functions expr_heap
-	#	(icl_function, icl_functions)	= icl_functions![dcl_index]
-		{fun_body}	= icl_function
-		result = consequences fun_body
-	= expand_functions_and_dynamics result [] (f_consequences, icl_functions, expr_heap)
-  where
-	expand_functions_and_dynamics [] akku unique_stuff
-		= (akku, unique_stuff)
-	expand_functions_and_dynamics [(_,CK_DynamicPatternType exprInfoPtr):t] akku (f_consequences, icl_functions, expr_heap)
-		#	(conseqs, expr_heap)	= expand_dynamic exprInfoPtr expr_heap
-		= expand_functions_and_dynamics t (conseqs++akku) (f_consequences, icl_functions, expr_heap)
-	expand_functions_and_dynamics [(ident,(CK_Function globIndex)):t] akku unique_stuff
-		#	(conseqs, unique_stuff) = expand_function ident globIndex unique_stuff
-		= expand_functions_and_dynamics t (conseqs++akku) unique_stuff
-	expand_functions_and_dynamics [h:t] akku unique_stuff
-		= expand_functions_and_dynamics t [h:akku] unique_stuff
-
-	expand_dynamic :: ExprInfoPtr *ExpressionHeap -> ([IdentWithCKind], *ExpressionHeap)
-	expand_dynamic exprInfoPtr expr_heap
-	// it is assumed, that the pointer structure from the fi_dynamics field (of record FunInfo)
-	// is a tree
-		#	(exprInfo, expr_heap)	= readPtr exprInfoPtr expr_heap
-			(conseqs, expr_heap)
-			 	= case exprInfo of
-							(EI_Dynamic No)	
-								-> ([], expr_heap)
-							(EI_Dynamic (Yes dynamicType))
-								-> (consequences dynamicType, expr_heap)
-							(EI_DynamicType dynamicType further_dynamic_ptrs)
-								#	(further_conseqs, expr_heap)	= expand_dynamics further_dynamic_ptrs [] expr_heap
-								-> (further_conseqs++consequences dynamicType, expr_heap)
-							(EI_DynamicTypeWithVars _ dynamicType further_dynamic_ptrs)
-								#	(further_conseqs, expr_heap)	= expand_dynamics further_dynamic_ptrs [] expr_heap
-								-> (further_conseqs++consequences dynamicType, expr_heap)
-		= (conseqs, expr_heap)
+	checkCompletenessOfMacro :: !String !Ident !Index !Int *CheckCompletenessStateBox -> *CheckCompletenessStateBox
+	checkCompletenessOfMacro filename dcl_ident dcl_index line_nr ccs
+		#! ({fun_body}, ccs) = ccs!box_ccs.ccs_icl_functions.[dcl_index]
+		   ccs = { ccs & box_ccs.ccs_set_of_visited_icl_funs.[dcl_index] = True }
+		   cci = { box_cci = { cci_line_nr = line_nr, cci_filename = filename, cci_expl_imported_ident = dcl_ident }}
+		= check_completeness fun_body cci ccs
+
+	replace_ste_with_previous :: !SymbolPtr !*SymbolTable -> .SymbolTable
+	replace_ste_with_previous changed_ste_ptr symbol_table
+		#! ({ste_previous}, symbol_table) = readPtr changed_ste_ptr symbol_table
+		= writePtr changed_ste_ptr ste_previous symbol_table
 	
-	expand_dynamics [] akku expr_heap
-		= (akku, expr_heap)
-	expand_dynamics [h:t] akku expr_heap
-		#	(dyn, expr_heap)	= expand_dynamic h expr_heap
-		= expand_dynamics t (dyn++akku) expr_heap
-
-
-	expand_function ident globIndex=:{glob_object,glob_module} (f_consequences, icl_functions, expr_heap)
-		|	glob_module<>cIclModIndex	// the function that is referred from within a macro is a DclFunction
-										// -> must be global -> is a consequence
-			= ([(ident, CK_Function globIndex)], (f_consequences, icl_functions, expr_heap))
-		#	(fun_def, icl_functions)	= icl_functions![glob_object]
-		|	fun_def.fun_info.fi_def_level==cGlobalScope	// the function is defined in the icl module in the global scope
-														// -> it's not a consequence
-			= ([], (f_consequences, icl_functions, expr_heap))
-		// otherwise the function was defined locally in a macro and stored in the IclModule object.
-		// it is not a consequence, but it's type and body are consequences !
-		#	(opt_f_consequences, f_consequences)	= f_consequences![glob_object]
-		= case opt_f_consequences of
-			No 	#	type_consequences	= consequences fun_def.fun_type
-					body_consequences	= consequences fun_def.fun_body
-					dynamic_pointers	= fun_def.fun_info.fi_dynamics
-				#	(dynamic_consequences, expr_heap)
-										= expand_dynamics dynamic_pointers [] expr_heap
-					f_consequences		= { f_consequences & [glob_object]=Yes (count, No) }
-					(cons, (f_consequences, icl_functions, expr_heap))
-										= expand_functions_and_dynamics body_consequences [] (f_consequences, icl_functions,expr_heap)
-					cons_of_function	= type_consequences++cons++dynamic_consequences
-					f_consequences		= { f_consequences & [glob_object]=Yes (count, Yes cons_of_function) }
-				-> (cons_of_function, (f_consequences, icl_functions, expr_heap))
-			Yes (j, opt_consequences)
-				|	j==count	// the consequences of the function are already considered
-				-> ([], (f_consequences, icl_functions, expr_heap))
-			Yes (j, Yes cons)
-				|	j<count	// always True
-				-> (cons, (f_consequences, icl_functions, expr_heap))
-
-consequences_of_simple_symbol STE_Type {dcl_common} dcl_index
-	= consequences dcl_common.com_type_defs.[dcl_index]
-consequences_of_simple_symbol STE_Constructor {dcl_common} dcl_index
-	= consequences dcl_common.com_cons_defs.[dcl_index]
-consequences_of_simple_symbol STE_DclFunction {dcl_functions} dcl_index
-	= consequences dcl_functions.[dcl_index]
-consequences_of_simple_symbol (STE_Field _) {dcl_common} dcl_index
-	= consequences dcl_common.com_selector_defs.[dcl_index]
-consequences_of_simple_symbol STE_Class {dcl_common} dcl_index
-	= consequences dcl_common.com_class_defs.[dcl_index]
-consequences_of_simple_symbol STE_Member {dcl_common} dcl_index
-	= consequences dcl_common.com_member_defs.[dcl_index]
-consequences_of_simple_symbol STE_Instance {dcl_common} dcl_index
-	= consequences dcl_common.com_instance_defs.[dcl_index]
-
-checkConsequenceError :: !((Ident,.STE_Kind),!.(Ident,ConsequenceKind),!(.{#Char},.Int)) !*(*{#DclModule},!*CheckState) -> (!*{#DclModule},!.CheckState)
-checkConsequenceError (expl_imp_ident_kind, conseq_ident_kind=:(conseq_ident, conseq_kind), (file_name, line_nr))
-					 (modules, cs=:{cs_symbol_table, cs_error})
-	#	(c_ident, modules)
-			= case conseq_kind of
-				CK_Selector {glob_object,glob_module}				// if a selector is a consequence of an imported macro the
-					#	(modul, modules)	= modules![glob_module]	// it's FIELD has to be looked up
-						com_selector_def	= modul.dcl_common.com_selector_defs.[glob_object.ds_index]
-					-> (com_selector_def.sd_field, modules)
-				_	-> (conseq_ident, modules)
-		({ste_kind}, cs_symbol_table)				= readPtr c_ident.id_info cs_symbol_table
-		cs_error
-			= case ste_kind of
-				STE_Empty
-							-> cError expl_imp_ident_kind
-									  (   "explicitly imported without importing "
-									   +++cIdent_kind_to_string conseq_ident_kind)
-									  cs_error
-				_			-> cs_error
-	= (modules, { cs & cs_symbol_table=cs_symbol_table, cs_error=cs_error })
+instance toString STE_Kind where
+	toString (STE_FunctionOrMacro _)	= "function/macro"
+	toString STE_Type 					= "type"
+	toString STE_Constructor 			= "constructor"
+	toString (STE_Field _) 				= "field"
+	toString STE_Class 					= "class"
+	toString STE_Member 				= "class member"
+
+check_whether_ident_is_imported :: !Ident !STE_Kind !CheckCompletenessInputBox !*CheckCompletenessStateBox 
+								-> *CheckCompletenessStateBox
+check_whether_ident_is_imported ident wanted_ste_kind cci ccs=:{box_ccs=box_ccs=:{ccs_symbol_table}}
+	#! (ste=:{ste_kind}, ccs_symbol_table) = readPtr ident.id_info ccs_symbol_table
+	   ccs = { ccs & box_ccs = { box_ccs & ccs_symbol_table = ccs_symbol_table } }
+	| is_imported ste_kind wanted_ste_kind
+		= ccs
+	#! (ccs=:{box_ccs=box_ccs=:{ccs_symbol_table, ccs_error, ccs_heap_changes_accu}}) = ccs
+	   {box_cci={cci_line_nr, cci_filename, cci_expl_imported_ident}} = cci
+	   ident_pos = {ip_ident= { id_name="import", id_info=nilPtr }, ip_line=cci_line_nr, ip_file=cci_filename}
+	   ccs_error = checkErrorWithIdentPos ident_pos
+	  				(cci_expl_imported_ident.id_name+++" explicitly imported without importing "
+	  				 +++toString wanted_ste_kind+++" "+++ident.id_name)
+	  				ccs_error
+	   // pretend that the unimported symbol was imported to prevent doubling error mesages
+	   ccs_symbol_table = writePtr ident.id_info { ste & ste_kind = wanted_ste_kind, ste_previous = ste } ccs_symbol_table
+	= { ccs & box_ccs = { box_ccs & ccs_error = ccs_error, ccs_symbol_table = ccs_symbol_table, 
+									ccs_heap_changes_accu = [ident.id_info:ccs_heap_changes_accu] }}
   where
-	ident_kind_to_string ({id_name}, kind)
-		= kind_to_string kind+++" "+++id_name
-	cIdent_kind_to_string ({id_name}, cKind)
-		= cKind_to_string cKind+++" "+++id_name
-	cError expl_imp_ident_kind=:(expl_ident,_) s2 cs_error
-		#	identPos	= {	ip_ident = expl_ident, ip_line = line_nr, ip_file = file_name } 
-			cs_error	= pushErrorAdmin identPos cs_error
-			cs_error	= checkError (ident_kind_to_string expl_imp_ident_kind) s2 cs_error
-			cs_error	= popErrorAdmin cs_error
-		= cs_error
-
-kind_to_string (STE_FunctionOrMacro _)	= "function"
-kind_to_string STE_Type					= "type"
-kind_to_string STE_Constructor			= "constructor"
-kind_to_string (STE_Field _)			= "field"
-kind_to_string STE_Class				= "class"
-kind_to_string STE_Member				= "member"
-kind_to_string STE_Instance				= "instance"
-kind_to_string STE_DclFunction			= "function"
-
-cKind_to_string (CK_Function _)			= "function"
-cKind_to_string CK_Macro				= "macro"
-cKind_to_string CK_Type					= "type"
-cKind_to_string CK_Constructor			= "constructor"
-cKind_to_string (CK_Selector _)			= "appropriate record field"
-cKind_to_string CK_Class				= "class"
-
-class consequences x :: x -> [IdentWithCKind]
-
-instance consequences App
-  where consequences {app_symb, app_args}	= consequences app_symb++consequences app_args
-	
-instance consequences AlgebraicPattern
-  where consequences {ap_symbol, ap_expr} = [ (ap_symbol.glob_object.ds_ident, CK_Constructor) : consequences ap_expr]
+	is_imported (STE_Imported ste_kind _) wanted_ste_kind
+		= ste_kind==wanted_ste_kind
+	is_imported ste_kind wanted_ste_kind
+		= ste_kind==wanted_ste_kind
 
-instance consequences AType
-  where
-	consequences {at_type}	= consequences at_type
+class check_completeness x :: !x !CheckCompletenessInputBox !*CheckCompletenessStateBox -> *CheckCompletenessStateBox
 
-instance consequences BasicPattern
-  where consequences {bp_expr} = consequences bp_expr
-
-instance consequences Case
-  where	consequences { case_expr, case_guards, case_default, case_ident }
-		= consequences case_expr++consequences case_guards++consequences case_default
-
-instance consequences CasePatterns
-  where
-	consequences (AlgebraicPatterns _ algebraicPatterns)	= consequences algebraicPatterns
-	consequences (BasicPatterns _ basicPatterns)	= consequences basicPatterns
-	consequences (DynamicPatterns dynamicPatterns)	= consequences dynamicPatterns
-	consequences NoPattern	= []
-
-instance consequences CheckedBody
-  where consequences {cb_rhs} = consequences cb_rhs
-
-instance consequences ClassDef
-  where
-	consequences {class_context}	= consequences class_context	
-
-instance consequences ClassInstance
-  where
-	consequences {ins_type}	= consequences ins_type	
-
-instance consequences ConsDef
-  where
-	consequences {cons_type}	= consequences cons_type	
-
-instance consequences DynamicPattern // the types, that are found via dp_type are checked later
-  where	consequences { dp_rhs, dp_type } = [({ id_name="", id_info=nilPtr}, CK_DynamicPatternType dp_type): consequences dp_rhs]
-
-instance consequences DynamicExpr
-  where	consequences { dyn_expr, dyn_opt_type } = consequences dyn_expr++consequences dyn_opt_type
-
-instance consequences DynamicType
-  where	consequences { dt_type } = consequences dt_type
-
-instance consequences Expression
-  where
-	consequences (Var _)	= []
-	consequences (App app)	= consequences app
-	consequences (expression @ expressions)	= consequences expression++consequences expressions
-	consequences (Let let_)	= consequences let_
-	consequences (Case case_)	= consequences case_
-	consequences (Selection _ expression selections)	= consequences expression++consequences selections
-	consequences (TupleSelect _ _ expression)	= consequences expression
-	consequences (BasicExpr _ _)		= []
-	consequences (AnyCodeExpr _ _ _)	= []
-	consequences (ABCCodeExpr _ _)	= []
-	consequences (MatchExpr _ constructor expression)
-		= [(constructor.glob_object.ds_ident,CK_Constructor):consequences expression]
-	consequences (FreeVar _) 	= []
-	consequences (DynamicExpr dynamicExpr)	= consequences dynamicExpr
-	consequences EE	= []
-	consequences (Update expr1 selections expr2)	=  consequences expr1++consequences selections++consequences expr2
-	consequences expr	= abort "explicitimports:consequences (Expression) does not match" <<- expr
-
-instance consequences FunctionBody
-  where	consequences (CheckedBody body) = consequences body
-		consequences (TransformedBody body) = consequences body
-		consequences (RhsMacroBody body) = consequences body
-		
-instance consequences FunType
-  where
-	consequences {ft_type}	= consequences ft_type	
-
-instance consequences (Global x) | consequences x
-  where	consequences { glob_object } = consequences glob_object
-
-instance consequences InstanceType
-  where
-	consequences {it_types, it_context}	= consequences it_types++consequences it_context	
-
-instance consequences Let
-  where	consequences { let_strict_binds, let_lazy_binds, let_expr }
-  			= consequences let_expr++(flatten [consequences bind_src \\ {bind_src}<-let_strict_binds ++ let_lazy_binds] )
-
-instance consequences MemberDef
-  where
-	consequences {me_type}	= consequences me_type	
-
-instance consequences (Optional x) | consequences x
-  where	consequences (Yes x) = consequences x
-  		consequences No = []
-
-instance consequences Selection
-  where consequences (RecordSelection globDefinedSymbol=:{glob_object={ds_ident}} _)
-  			= [(ds_ident, CK_Selector globDefinedSymbol)]
-		consequences (ArraySelection {glob_object={ds_ident={id_name}}} _ _)
-  			= []
-
-instance consequences SelectorDef
-  where consequences {sd_type}	= consequences sd_type	
-
-instance consequences SymbIdent
-  where consequences {symb_name, symb_kind}
-  			= case symb_kind of
-  					SK_Constructor _		-> [(symb_name, CK_Constructor)]
-  			  		SK_Function	globalIndex	-> [(symb_name, CK_Function globalIndex)]
-  			  		SK_OverloadedFunction globalIndex
-  			  								-> [(symb_name, CK_Function globalIndex)]
-  			  		SK_Macro globalIndex	-> [(symb_name, CK_Macro)]
-  			  		_						-> []
-
-instance consequences SymbolType
-  where
-	consequences {st_args, st_result, st_context}
-		= consequences st_args++consequences st_result++consequences st_context
-
-instance consequences TransformedBody
-  where consequences {tb_rhs} = consequences tb_rhs
-
-instance consequences Type
-  where
-	consequences (TA {type_name} arguments)
-		= [(type_name, CK_Type):consequences arguments]
-	consequences (l --> r)
-		= consequences l++consequences r
-	consequences (_ :@: arguments)
-		= consequences arguments
-	consequences _
-		= []
-
-
-instance consequences TypeContext
-  where
-	consequences {tc_class= {glob_object={ds_ident}}, tc_types}
-		= [(ds_ident,CK_Class):consequences tc_types]
-
-instance consequences (TypeDef TypeRhs)  // ==CheckedTypeDef
-  where
-	consequences {td_rhs, td_context}	= consequences td_rhs++consequences td_context
-
-instance consequences TypeRhs
+instance check_completeness App where
+	check_completeness {app_symb, app_args}	cci ccs
+		= check_completeness app_symb cci
+		  (check_completeness app_args cci ccs)
+	
+instance check_completeness AlgebraicPattern where
+	check_completeness {ap_symbol, ap_expr} cci ccs
+		= check_completeness ap_expr cci
+		  (check_whether_ident_is_imported ap_symbol.glob_object.ds_ident STE_Constructor cci ccs)
+
+instance check_completeness AType where
+	check_completeness {at_type} cci ccs
+		= check_completeness at_type cci ccs
+
+instance check_completeness BasicPattern where
+	check_completeness {bp_expr} cci ccs
+		= check_completeness bp_expr cci ccs
+
+instance check_completeness (Bind Expression FreeVar) where
+	check_completeness {bind_src} cci ccs
+		= check_completeness bind_src cci ccs
+
+instance check_completeness Case where
+	check_completeness { case_expr, case_guards, case_default } cci ccs
+		= ( (check_completeness case_expr cci)
+		  o (check_completeness case_guards cci)
+		  o (check_completeness case_default cci)
+		  ) ccs
+
+instance check_completeness CasePatterns where
+	check_completeness (AlgebraicPatterns _ algebraicPatterns) cci ccs
+		= check_completeness algebraicPatterns cci ccs
+	check_completeness (BasicPatterns _ basicPatterns) cci ccs
+		= check_completeness basicPatterns cci ccs
+	check_completeness (DynamicPatterns dynamicPatterns) cci ccs
+		= check_completeness dynamicPatterns cci ccs
+	check_completeness NoPattern _ ccs
+		= ccs
+
+instance check_completeness CheckedBody where
+	check_completeness {cb_rhs} cci ccs
+		= check_completeness cb_rhs cci ccs
+
+instance check_completeness ClassDef where
+	check_completeness {class_context} cci ccs
+		= check_completeness class_context cci ccs
+
+instance check_completeness ClassInstance where
+	check_completeness {ins_type} cci ccs
+		= check_completeness ins_type cci ccs
+
+instance check_completeness ConsDef
   where
-	consequences (SynType aType)	= consequences aType
-	consequences _					= []
+	check_completeness {cons_type} cci ccs
+		= check_completeness cons_type cci ccs
 
-instance consequences [a]	| consequences a
+instance check_completeness DynamicPattern where
+	check_completeness { dp_rhs, dp_type } cci ccs
+		= check_completeness dp_rhs cci
+		  (check_completeness_of_dyn_expr_ptr dp_type cci ccs)
+	
+instance check_completeness DynamicExpr where
+	check_completeness { dyn_expr, dyn_opt_type } cci ccs
+		= check_completeness dyn_expr cci
+		  (check_completeness dyn_opt_type cci ccs)
+
+instance check_completeness DynamicType where
+	check_completeness { dt_type } cci ccs
+		= check_completeness dt_type cci ccs
+
+instance check_completeness Expression where
+	check_completeness (Var _) cci ccs
+		= ccs
+	check_completeness (App app) cci ccs
+		= check_completeness app cci ccs
+	check_completeness (expression @ expressions) cci ccs
+		= check_completeness expression cci
+		  (check_completeness expressions cci ccs)
+	check_completeness (Let lad) cci ccs
+		= check_completeness lad cci ccs
+	check_completeness (Case keesje) cci ccs
+		= check_completeness keesje cci ccs
+	check_completeness (Selection _ expression selections) cci ccs
+		= check_completeness expression cci
+		  (check_completeness selections cci ccs)
+	check_completeness (TupleSelect _ _ expression) cci ccs
+		= check_completeness expression cci ccs
+	check_completeness (BasicExpr _ _) _ ccs
+		= ccs
+	check_completeness (AnyCodeExpr _ _ _) _ ccs
+		= ccs
+	check_completeness (ABCCodeExpr _ _) _ ccs
+		= ccs
+	check_completeness (MatchExpr _ constructor expression) cci ccs
+		= check_completeness expression cci
+		  (check_whether_ident_is_imported constructor.glob_object.ds_ident STE_Constructor cci ccs)
+	check_completeness (FreeVar _) _ ccs
+		= ccs
+	check_completeness (DynamicExpr dynamicExpr) cci ccs
+		= check_completeness dynamicExpr cci ccs
+	check_completeness EE _ ccs
+		= ccs
+	check_completeness (Update expr1 selections expr2) cci ccs
+		= ( (check_completeness expr1 cci)
+		  o (check_completeness selections cci)
+		  o (check_completeness expr2) cci
+		  ) ccs
+	check_completeness expr _ _
+		= abort "explicitimports:check_completeness (Expression) does not match" <<- expr
+
+instance check_completeness FunctionBody where
+	check_completeness (CheckedBody body) cci ccs
+		= check_completeness body cci ccs
+	check_completeness (TransformedBody body) cci ccs
+		= check_completeness body cci ccs
+	check_completeness (RhsMacroBody body) cci ccs
+		= check_completeness body cci ccs
+			
+instance check_completeness FunDef where
+	check_completeness {fun_type, fun_body, fun_info} cci ccs
+		= ( (check_completeness fun_type cci)
+		  o (check_completeness fun_body cci)
+		  o (foldSt (flipM check_completeness_of_dyn_expr_ptr cci) fun_info.fi_dynamics)
+		  ) ccs
+
+instance check_completeness FunType where
+	check_completeness {ft_type} cci ccs
+		= check_completeness ft_type cci ccs
+
+instance check_completeness (Global x) | check_completeness x where
+	check_completeness { glob_object } cci ccs
+		= check_completeness glob_object cci ccs
+
+instance check_completeness InstanceType where
+	check_completeness {it_types, it_context} cci ccs
+		= check_completeness it_types cci
+		  (check_completeness it_context cci ccs)
+
+instance check_completeness Let where
+	check_completeness { let_strict_binds, let_lazy_binds, let_expr } cci ccs
+  		= ( (check_completeness let_expr cci)
+  		  o (check_completeness let_strict_binds cci)
+  		  o (check_completeness let_lazy_binds cci)
+  		  ) ccs
+
+instance check_completeness MemberDef where
+  	check_completeness {me_type} cci ccs 
+  		= check_completeness me_type cci ccs
+
+instance check_completeness (Optional x) | check_completeness x where
+	check_completeness (Yes x) cci ccs
+		= check_completeness x cci ccs
+	check_completeness No _ ccs
+		= ccs
+
+instance check_completeness Selection where
+	check_completeness (RecordSelection {glob_object,glob_module} _) cci ccs
+		#! ({dcl_common}, ccs)	= ccs!box_ccs.ccs_dcl_modules.[glob_module]	// the selector's filed has to be looked up
+		   ({sd_field}) = dcl_common.com_selector_defs.[glob_object.ds_index]
+		= check_whether_ident_is_imported sd_field ste_field cci ccs
+	check_completeness (ArraySelection _ _ index_expr) cci ccs
+		= check_completeness index_expr cci ccs
+	check_completeness (DictionarySelection _ selections _ index_expr) cci ccs
+		= check_completeness selections cci
+		  (check_completeness index_expr cci ccs)
+
+instance check_completeness SelectorDef where
+	check_completeness {sd_type} cci ccs
+		= check_completeness sd_type cci ccs
+
+instance check_completeness SymbIdent where
+	check_completeness {symb_name, symb_kind} cci ccs
+		= case symb_kind of
+			SK_Constructor _
+				-> check_whether_ident_is_imported symb_name STE_Constructor cci ccs
+			SK_Function global_index
+				-> check_completeness_for_function symb_name global_index ste_fun_or_macro cci ccs
+			SK_OverloadedFunction global_index
+				-> check_completeness_for_function symb_name global_index STE_Member cci ccs
+  			SK_Macro global_index
+  				-> check_completeness_for_function symb_name global_index ste_fun_or_macro cci ccs
+  	  where
+		check_completeness_for_function symb_name {glob_object,glob_module} wanted_ste_kind cci ccs
+			| glob_module<>cIclModIndex	
+				// the function that is referred from within a macro is a DclFunction
+				// -> must be global -> has to be imported
+				= check_whether_ident_is_imported symb_name wanted_ste_kind cci ccs
+			#! (fun_def, ccs)	= ccs!box_ccs.ccs_icl_functions.[glob_object]
+			// otherwise the function was defined locally in a macro
+			// it is not a consequence, but it's type and body are consequences !
+			#! (already_visited, ccs) = ccs!box_ccs.ccs_set_of_visited_icl_funs.[glob_object]
+			| already_visited
+				= ccs
+			#! ccs = { ccs & box_ccs.ccs_set_of_visited_icl_funs.[glob_object] = True }
+			= check_completeness fun_def cci ccs
+
+instance check_completeness SymbolType where
+	check_completeness {st_args, st_result, st_context} cci ccs
+		= ( (check_completeness st_args cci)
+		  o (check_completeness st_result cci)
+		  o (check_completeness st_context cci)
+		  ) ccs
+
+instance check_completeness TransformedBody where
+	check_completeness {tb_rhs} cci ccs
+		= check_completeness tb_rhs cci ccs
+
+instance check_completeness Type where
+	check_completeness (TA {type_name} arguments) cci ccs
+		= check_completeness arguments cci
+		  (check_whether_ident_is_imported type_name STE_Type cci ccs)
+	check_completeness (l --> r) cci ccs
+		= check_completeness l cci
+		  (check_completeness r cci ccs)
+	check_completeness (_ :@: arguments) cci ccs
+		= check_completeness arguments cci ccs
+	check_completeness _ _ ccs
+		= ccs
+
+instance check_completeness TypeContext where
+	check_completeness {tc_class, tc_types} cci ccs
+		= check_completeness tc_types cci
+		  (check_whether_ident_is_imported tc_class.glob_object.ds_ident STE_Class cci ccs)
+
+instance check_completeness (TypeDef TypeRhs) where
+	check_completeness {td_rhs, td_context}	cci ccs
+		= check_completeness td_rhs cci 
+		  (check_completeness td_context cci ccs)
+
+instance check_completeness TypeRhs where
+	check_completeness (SynType aType) cci ccs
+		= check_completeness aType cci ccs
+	check_completeness _ _ ccs
+		= ccs
+
+instance check_completeness [a]	| check_completeness a
   where
-	consequences l	= flatten (map consequences l)
-  
+	check_completeness [] _ ccs
+		= ccs
+	check_completeness [h:t] cci ccs
+		= check_completeness h cci
+		  (check_completeness t cci ccs)
+
+check_completeness_of_dyn_expr_ptr :: !ExprInfoPtr !CheckCompletenessInputBox !*CheckCompletenessStateBox
+								-> *CheckCompletenessStateBox 
+check_completeness_of_dyn_expr_ptr dyn_expr_ptr cci ccs=:{box_ccs=box_ccs=:{ccs_expr_heap}}
+	#! (expr_info, ccs_expr_heap) = readPtr dyn_expr_ptr ccs_expr_heap
+	   ccs = { ccs & box_ccs = { box_ccs & ccs_expr_heap = ccs_expr_heap }}
+ 	= case expr_info of
+		(EI_Dynamic No)	
+			-> ccs
+		(EI_Dynamic (Yes dynamic_type))
+			-> check_completeness dynamic_type cci ccs
+		(EI_DynamicType dynamic_type further_dynamic_ptrs)
+			-> check_completeness dynamic_type cci
+			   (foldSt (flipM check_completeness_of_dyn_expr_ptr cci) further_dynamic_ptrs ccs)
+		(EI_DynamicTypeWithVars _ dynamic_type further_dynamic_ptrs)
+			-> check_completeness dynamic_type cci
+			   (foldSt (flipM check_completeness_of_dyn_expr_ptr cci) further_dynamic_ptrs ccs)
+
+flipM f a b :== f b a
+
+// STE_Kinds just for comparision
+ste_field =: STE_Field { id_name="", id_info=nilPtr }
+ste_fun_or_macro =: STE_FunctionOrMacro []