;;; Error checks & calls for the import-export code
 
 ;;; this is called at the end of import-export to look for
 ;;;  a) exported entities that were never found
 ;;;  b) imported entities that were never found
 ;;;  c) renamed entities that were never found
 ;;;  d) hidden entities that were never found
 
 (define (check-missing-names)
   (dolist (export (module-exports *module*))
     (remember-context export
       (signal-missing-export export)))
   (dolist (import-decl (module-imports *module*))
     (remember-context import-decl
       (with-slots import-decl (mode specs renamings) import-decl
         ;; *** I'm confused.  Aren't these errors already detected
 	;; *** by import-all-entities and import-named-entities?
 	;; jcp: no - a final check is needed after all symbols have moved.
         (cond ((eq? mode 'all)
 	       (dolist (entity specs)
 		 (signal-unused-hiding
 		   (entity-name entity)
 		   (import-decl-module-name import-decl))))
 	      (else
 	       (dolist (entity specs)
 		 (signal-entity-not-found
 		   (entity-name entity)
 		   (import-decl-module-name import-decl)))))
 	(find-unused-renamings renamings import-decl)))))
 
 (define (find-unused-renamings renamings import-decl)
   (dolist (r renamings)
     (when (not (renaming-referenced? r))
       (remember-context r
 	(signal-unused-renaming (renaming-from r)
 				(import-decl-module-name import-decl))))))
 
 (define (check-duplicates l entity)
   (when (not (null? (find-duplicates l)))
     (signal-duplicate-names-in-entity entity)))
 
 ;;; There are a ton of possible errors in import-export.  All error
 ;;; calls are found here:
 
 (define (signal-missing-export export)
   (recoverable-error 'missing-export
     "Module ~A exports ~A, but provides no definition for it."
     *module-name* export))
 
 (define (signal-unused-renaming name module-name)
   (recoverable-error 'unused-renaming
     "The name ~a is included in the renaming list of an import declaration,~%~
      but is not among the entities being imported from module ~a."
     name module-name))
 
 (define (signal-unused-hiding name module-name)
   (recoverable-error 'unused-hiding
     "The name ~a is included in the hiding list of an import declaration,~%~
      but is not among the entities exported from module ~a."
     name module-name))
 
 (define (signal-multiple-name-conflict name old-local-name def)
   (recoverable-error 'multiple-name-conflict
     "In module ~A, the symbol ~A from module ~A is known as both ~A and ~A."
     *module-name* (def-name def) (def-module def) name old-local-name))
 
 
 (define (signal-undefined-module-import name)
   (fatal-error 'undefined-module-import
 	       "Cannot find module ~A, imported by module ~A."
 	       name *module-name*))
 
 
 (define (signal-undefined-module-export name)		
   (fatal-error 'undefined-module-export
 	       "Cannot find module ~A, exported by module ~A."
 	       name *module-name*))
 
 
 (define (signal-self-import name)
   (fatal-error 'self-import
 	       "Module ~A cannot import itself."
 	       name))
 
 (define (signal-missing-prelude)
   (fatal-error 'missing-prelude "Can't find module Prelude."))
 
 (define (signal-missing-prelude-core)
   (fatal-error 'missing-prelude "Can't find module PreludeCore."))
 
 (define (signal-export-not-imported name)
   (recoverable-error 'export-not-imported
     "Module ~A is exported from ~A,~%~
      but is not also imported into that module."
     name *module-name*))
 
 (define (signal-entity-not-found name module-name)
   (fatal-error 'entity-not-found
     "The entity ~a is not exported from module ~a." name module-name))
 
 (define (signal-synonym-needs-dots name module-name)
   (declare (ignore module-name))
   (fatal-error 'synonym-needs-dots
     "The entity ~a is a type synonym; to name it in an import or export~%~
      list, you must use `~a(..)' as the entity."
     name name))
 
 (define (signal-wrong-definition expected name module-name)
   (fatal-error 'wrong-definition
     "The entity ~a does not name a ~a in module ~a."
     name expected module-name))
 
 (define (signal-abstract-type name module-name)
   (fatal-error 'abstract-type
     "The entity ~a names an abstract type in module ~a;~%~
      you cannot import or export its constructors."
     name module-name))
 
 (define (signal-extra-constituent entity name what)
   (fatal-error 'extra-constituent
     "The entity specification ~a includes the ~a name ~a,~%~
      which is not present in its definition."
     entity what name))
 
 (define (signal-missing-constituent entity name what)
   (fatal-error 'missing-constituent
     "The entity specification ~a does not include the ~a name ~a,~%~
      which is part of its definition."
     entity what name))
 
 (define (signal-duplicate-names-in-entity entity)
   (fatal-error 'duplicate-names-in-entity
     "The entity specification ~a includes duplicate names."
     entity))
 
 (define (signal-export-method-var name)
   (fatal-error 'export-method-var
     "You can't export the method ~a like an ordinary variable."
     name))
 
 (define (signal-prelude-renaming def name)
   (recoverable-error 'cant-rename-core
      "Names in PreludeCore cannot be renamed: ~a was renamed to ~a"
      (def-name def) name))
 
 (define (signal-non-local-fixity op)
   (recoverable-error 'fixity-must-be-local
      "The fixity for ~A will be ignored since it is not defined in this module"
      op))
 
 (define (signal-fixity-not-var/con op)
   (recoverable-error 'fixity-requires-var-or-con
      "The fixity for ~A will be ignored since it is not a value or constructor"
      op))