Byte-compilation of a multi-file package: "the function is not known to be defined"

Question

Imagine that I have the following files in my (ridiculous) package:

File test1.el:

;;; test1.el ---                                   

;;; Code:

(defvar test-var1)

(defun test-fun1 (test)
  nil)

(require 'test2 "./test2.el)

(provide 'test1)
;;; test1.el ends here

File test2.el:

;;; test2.el ---  

;;; Code:

(defun test-fun2 ()
  (let ((test test-var1))
    (test-fun1 test)))

(provide 'test2)
;;; test2.el ends here

If then I run:

emacs -batch -f batch-byte-compile *.el

I get the following result:

Compiling .../test1.el...
Wrote .../test1.elc
Compiling .../test2.el...

In test-fun2:
test2.el:9:15:Warning: reference to free variable `test-var1'

In end of data:
test2.el:14:1:Warning: the function `test-fun1' is not known to be defined.
Wrote .../test2.elc

I understand why these warnings appear, and I understand that they are only warnings. However, it would be easy to miss a typo in a function name by dismissing all warnings of this kind.

I somehow thought that adding a (require 'test2) line in test2.el should fix it. However, in this case I get:

Compiling .../test1.el...

In toplevel form:
test1.el:10:1:Error: Recursive `require' for feature `test2'
Compiling .../test2.el...

In toplevel form:
test2.el:5:1:Error: Recursive `require' for feature `test1'

This is cryptic, because I thought that the point of require was precisely to avoid recursive loading. I assume that require is behaving like load during compilation time.

What is a good (and safe) way to get rid of these warnings?

The manual gives a work-around (I post it as a better-than-nothing answer below), but ultimately, I'd like the solution to be rather automatic (not requiring me to list all functions and variables that I will need in every file).

The ideal solution would be built-in in emacs or provided with Cask. If it doesn't exist, I will take what is available of course.

Answer 1

About require

require is not meant to avoid recusive loading, it is meant to avoid repetitive loading. So no, it does not solve you problem here.

About the problem

The right way to approach this (in my opinion) would be to avoid the mutual dependency.

The test1 file in your example has no reason to require test2. Even if that's not true for your actual package, maybe you can redesign how you're delegating code between the files. It is in general possible to avoid mutual dependency between your files.

Work arounds

1. If the mutual dependency cannot be avoided, the manual mentions a solution. You'll have to add lines like the following for each function/variable you need.

   (declare-function test-fun1 "./test1.el")
   (defvar test-var1)
   

2. Another option is to require the files only conditionally. Add something like this to file 1:

   (defvar test1-is-loading t)
   (unless (and (boundp 'test2-is-loading)
                test2-is-loading)
     (require 'test2))
   

   And something like this to file 2:

   (defvar test2-is-loading t)
   (unless (and (boundp 'test1-is-loading)
                test1-is-loading)
     (require 'test1))
   

Answer 2

Your example is weird:

• You require test2 at the end of test1, whereas require should "always" be at the beginning of a file.
• Your test1 does not call any test2 functions, so it doesn't need test2 to work (hence it requires it, unnecessarily), and OTOH your test2 does call test1 functions, so it does need test1, yet it fails to require it.

IOW, you have your requires backward.

Answer 3

The manual suggests adding declare-function and defvar lines.

The resulting test2 file is:

;;; test2.el ---  

;;; Code:

(declare-function test-fun1 "./test1.el")
(defvar test-var1)

(defun test-fun2 ()
  (let ((test test-var1))
    (test-fun1 test)))

(provide 'test2)
;;; test2.el ends here

However, this needs to be done for all functions and all variables defined in "parent" files.