(byte-compile-callargs-warn): Handle function defnition

that is not a lambda expression or byte code function.
(byte-compile-arglist-warn): Likewise.
(byte-compile-defalias): New function, used to compile defalias.
(byte-compile-defalias-warn): New function.

lisp/emacs-lisp/bytecomp.el

@@ -834,7 +834,7 @@ otherwise pop it")
 (defun byte-compile-fdefinition (name macro-p)
   (let* ((list (if macro-p
 		   byte-compile-macro-environment
-		   byte-compile-function-environment))
+		 byte-compile-function-environment))
 	 (env (cdr (assq name list))))
     (or env
 	(let ((fn name))
@@ -899,7 +899,9 @@ otherwise pop it")
 	 (sig (and def (byte-compile-arglist-signature
 			 (if (eq 'lambda (car-safe def))
 			     (nth 1 def)
-			     (aref def 0)))))
+			   (if (compiled-function-p def)
+			       (aref def 0)
+			     '(&rest def))))))
 	 (ncall (length (cdr form))))
     (if sig
 	(if (or (< ncall (car sig))
@@ -932,7 +934,9 @@ otherwise pop it")
 	(let ((sig1 (byte-compile-arglist-signature
 		      (if (eq 'lambda (car-safe old))
 			  (nth 1 old)
-			  (aref old 0))))
+			(if (compiled-function-p old)
+			    (aref old 0)
+			  '(&rest def)))))
 	      (sig2 (byte-compile-arglist-signature (nth 2 form))))
 	  (or (byte-compile-arglist-signatures-congruent-p sig1 sig2)
 	      (byte-compile-warn "%s %s used to take %s %s, now takes %s"
@@ -2771,6 +2775,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
 (byte-defop-compiler-1 defconst byte-compile-defvar)
 (byte-defop-compiler-1 autoload)
 (byte-defop-compiler-1 lambda byte-compile-lambda-form)
+(byte-defop-compiler-1 defalias)
 
 (defun byte-compile-defun (form)
   ;; This is not used for file-level defuns with doc strings.
@@ -2827,6 +2832,34 @@ If FORM is a lambda or a macro, byte-compile it as a function."
 (defun byte-compile-lambda-form (form)
   (error "`lambda' used as function name is invalid"))
 
+;; Compile normally, but deal with warnings for the function being defined.
+(defun byte-compile-defalias (form)
+  (if (and (consp (cdr form)) (consp (nth 1 form))
+	   (eq (car (nth 1 form)) 'quote)
+	   (consp (cdr (nth 1 form)))
+	   (symbolp (nth 1 (nth 1 form)))
+	   (consp (nthcdr 2 form))
+	   (consp (nth 2 form))
+	   (eq (car (nth 2 form)) 'quote)
+	   (consp (cdr (nth 2 form)))
+	   (symbolp (nth 1 (nth 2 form))))
+      (progn
+	(byte-compile-defalias-warn (nth 1 (nth 1 form))
+				    (nth 1 (nth 2 form)))
+	(setq byte-compile-function-environment
+	      (cons (cons (nth 1 (nth 1 form))
+			  (nth 1 (nth 2 form)))
+		    byte-compile-function-environment))))
+  (byte-compile-normal-call form)))
+
+;; Turn off warnings about prior calls to the function being defalias'd.
+;; This could be smarter and compare those calls with
+;; the function it is being aliased to.
+(defun byte-compile-defalias-warn (new alias)
+  (let ((calls (assq new byte-compile-unresolved-functions)))
+    (if calls
+	(setq byte-compile-unresolved-functions
+	      (delq calls byte-compile-unresolved-functions)))))
 
 ;;; tags