Fix typos in docstrings and function names.

[sbcl.git] / src / compiler / ltn.lisp

diff --git a/src/compiler/ltn.lisp b/src/compiler/ltn.lisp
index b707b76..d2b162e 100644 (file)
--- a/src/compiler/ltn.lisp
+++ b/src/compiler/ltn.lisp
@@ -68,13 +68,14 @@
 ;;; return the leaf, otherwise return NIL.
 (defun lvar-delayed-leaf (lvar)
   (declare (type lvar lvar))
-  (let ((use (lvar-uses lvar)))
-    (and (ref-p use)
-         (let ((leaf (ref-leaf use)))
-           (etypecase leaf
-             (lambda-var (if (null (lambda-var-sets leaf)) leaf nil))
-             (constant leaf)
-             ((or functional global-var) nil))))))
+  (unless (lvar-dynamic-extent lvar)
+    (let ((use (lvar-uses lvar)))
+      (and (ref-p use)
+           (let ((leaf (ref-leaf use)))
+             (etypecase leaf
+               (lambda-var (if (null (lambda-var-sets leaf)) leaf nil))
+               (constant leaf)
+               ((or functional global-var) nil)))))))
 
 ;;; Annotate a normal single-value lvar. If its only use is a ref that
 ;;; we are allowed to delay the evaluation of, then we mark the lvar
@@ -366,7 +367,7 @@
     (unless (and (combination-p use)
                  (let ((info (basic-combination-info use)))
                    (and (template-p info)
-                        (eq (template-result-types info) :conditional))))
+                        (template-conditional-p info))))
       (annotate-ordinary-lvar test)))
   (values))
 
@@ -522,7 +523,7 @@
                    (if (and safe-p (template-args-ok template call nil))
                        :arg-check
                        :arg-types)))
-          ((eq (template-result-types template) :conditional)
+          ((template-conditional-p template)
            (let ((dest (lvar-dest lvar)))
              (if (and (if-p dest)
                       (immediately-used-p (if-test dest) call))
@@ -605,7 +606,7 @@
 
 (defvar *efficiency-note-cost-threshold* 5
   #!+sb-doc
-  "This is the minumum cost difference between the chosen implementation and
+  "This is the minimum cost difference between the chosen implementation and
   the next alternative that justifies an efficiency note.")
 (declaim (type index *efficiency-note-cost-threshold*))