[Guile-commits] GNU Guile branch, master, updated. release_1-9-6-136-g4113134

[Ludovic Courtès]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "GNU Guile".

http://git.savannah.gnu.org/cgit/guile.git/commit/?id=411313403cac04d1b1b1c7f579da32eaaaf4d80d

The branch, master has been updated
       via  411313403cac04d1b1b1c7f579da32eaaaf4d80d (commit)
       via  628ddb80aa5b33185e7eff81e72d158936079d91 (commit)
      from  c5661d2860da05b4666c9f4764509034aa7da693 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit 411313403cac04d1b1b1c7f579da32eaaaf4d80d
Author: Ludovic Courtès <address@hidden>
Date:   Mon Jan 11 18:30:13 2010 +0100

    Evaluate the `export' and `re-export' forms at compile-time.
    
    * module/ice-9/boot-9.scm (export, re-export): Evaluate at compile-time
      in addition to load/eval.
    
    * test-suite/tests/tree-il.test ("warnings")["unused-toplevel"]("unused
      but define-public"): Remove throw to `unresolved'.

commit 628ddb80aa5b33185e7eff81e72d158936079d91
Author: Ludovic Courtès <address@hidden>
Date:   Mon Jan 11 18:28:19 2010 +0100

    The reference graph in `-Wunused-toplevel' may contain cycles.
    
    * module/language/tree-il/analyze.scm (<reference-graph>,
      dag-reachable-nodes, dag-reachable-nodes*, unused-toplevel-analysis):
      Replace occurrences of "dag" by "graph".

-----------------------------------------------------------------------

Summary of changes:
 module/ice-9/boot-9.scm             |   16 ++++---
 module/language/tree-il/analyze.scm |   88 +++++++++++++++++-----------------
 test-suite/tests/tree-il.test       |    4 --
 3 files changed, 53 insertions(+), 55 deletions(-)

diff --git a/module/ice-9/boot-9.scm b/module/ice-9/boot-9.scm
index a32e2b6..af09be8 100644
--- a/module/ice-9/boot-9.scm
+++ b/module/ice-9/boot-9.scm
@@ -1,6 +1,6 @@
 ;;; -*- mode: scheme; coding: utf-8; -*-
 
-;;;; Copyright (C) 
1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009
+;;;; Copyright (C) 
1995,1996,1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010
 ;;;; Free Software Foundation, Inc.
 ;;;;
 ;;;; This library is free software; you can redistribute it and/or
@@ -3119,14 +3119,16 @@ module '(ice-9 q) '(make-q q-length))}."
               names)))
 
 (defmacro export names
-  `(call-with-deferred-observers
-    (lambda ()
-      (module-export! (current-module) ',names))))
+  `(eval-when (eval load compile)
+     (call-with-deferred-observers
+      (lambda ()
+        (module-export! (current-module) ',names)))))
 
 (defmacro re-export names
-  `(call-with-deferred-observers
-    (lambda ()
-      (module-re-export! (current-module) ',names))))
+  `(eval-when (eval load compile)
+     (call-with-deferred-observers
+       (lambda ()
+         (module-re-export! (current-module) ',names)))))
 
 (defmacro export-syntax names
   `(export ,@names))
diff --git a/module/language/tree-il/analyze.scm 
b/module/language/tree-il/analyze.scm
index f9e5b2f..122b880 100644
--- a/module/language/tree-il/analyze.scm
+++ b/module/language/tree-il/analyze.scm
@@ -642,20 +642,20 @@ accurate information is missing from a given `tree-il' 
element."
 ;;; Unused top-level variable analysis.
 ;;;
 
-;; <reference-dag> record top-level definitions that are made, references to
+;; <reference-graph> record top-level definitions that are made, references to
 ;; top-level definitions and their context (the top-level definition in which
 ;; the reference appears), as well as the current context (the top-level
 ;; definition we're currently in).  The second part (`refs' below) is
-;; effectively a DAG from which we can determine unused top-level definitions.
-(define-record-type <reference-dag>
-  (make-reference-dag refs defs toplevel-context)
-  reference-dag?
-  (defs             reference-dag-defs) ;; ((NAME . LOC) ...)
-  (refs             reference-dag-refs) ;; ((REF-CONTEXT REF ...) ...)
-  (toplevel-context reference-dag-toplevel-context)) ;; NAME | #f
-
-(define (dag-reachable-nodes root refs)
-  ;; Return the list of nodes reachable from ROOT in DAG REFS.  REFS is an 
alist
+;; effectively a graph from which we can determine unused top-level 
definitions.
+(define-record-type <reference-graph>
+  (make-reference-graph refs defs toplevel-context)
+  reference-graph?
+  (defs             reference-graph-defs) ;; ((NAME . LOC) ...)
+  (refs             reference-graph-refs) ;; ((REF-CONTEXT REF ...) ...)
+  (toplevel-context reference-graph-toplevel-context)) ;; NAME | #f
+
+(define (graph-reachable-nodes root refs)
+  ;; Return the list of nodes reachable from ROOT in graph REFS.  REFS is an 
alist
   ;; representing edges: ((A B C) (B A) (C)) corresponds to
   ;;
   ;;  ,-------.
@@ -681,26 +681,26 @@ accurate information is missing from a given `tree-il' 
element."
                               result
                               children))))))))
 
-(define (dag-reachable-nodes* roots refs)
+(define (graph-reachable-nodes* roots refs)
   ;; Return the list of nodes in REFS reachable from the nodes listed in ROOTS.
   ;; FIXME: Choose a more efficient algorithm.
   (apply lset-union eq?
          (map (lambda (node)
-                (cons node (dag-reachable-nodes node refs)))
+                (cons node (graph-reachable-nodes node refs)))
               roots)))
 
 (define unused-toplevel-analysis
   ;; Report unused top-level definitions that are not exported.
   (let ((add-ref-from-context
-         (lambda (dag name)
-           ;; Add an edge CTX -> NAME in DAG.
-           (let* ((refs     (reference-dag-refs dag))
-                  (defs     (reference-dag-defs dag))
-                  (ctx      (reference-dag-toplevel-context dag))
+         (lambda (graph name)
+           ;; Add an edge CTX -> NAME in GRAPH.
+           (let* ((refs     (reference-graph-refs graph))
+                  (defs     (reference-graph-defs graph))
+                  (ctx      (reference-graph-toplevel-context graph))
                   (ctx-refs (or (assoc-ref refs ctx) '())))
-             (make-reference-dag (alist-cons ctx (cons name ctx-refs)
-                                             (alist-delete ctx refs eq?))
-                                 defs ctx)))))
+             (make-reference-graph (alist-cons ctx (cons name ctx-refs)
+                                               (alist-delete ctx refs eq?))
+                                   defs ctx)))))
     (define (macro-variable? name env)
       (and (module? env)
            (let ((var (module-variable env name)))
@@ -708,44 +708,44 @@ accurate information is missing from a given `tree-il' 
element."
                   (macro? (variable-ref var))))))
 
     (make-tree-analysis
-     (lambda (x dag env locs)
+     (lambda (x graph env locs)
        ;; X is a leaf.
-       (let ((ctx (reference-dag-toplevel-context dag)))
+       (let ((ctx (reference-graph-toplevel-context graph)))
          (record-case x
            ((<toplevel-ref> name src)
-            (add-ref-from-context dag name))
-           (else dag))))
+            (add-ref-from-context graph name))
+           (else graph))))
 
-     (lambda (x dag env locs)
+     (lambda (x graph env locs)
        ;; Going down into X.
-       (let ((ctx  (reference-dag-toplevel-context dag))
-             (refs (reference-dag-refs dag))
-             (defs (reference-dag-defs dag)))
+       (let ((ctx  (reference-graph-toplevel-context graph))
+             (refs (reference-graph-refs graph))
+             (defs (reference-graph-defs graph)))
          (record-case x
            ((<toplevel-define> name src)
             (let ((refs refs)
                   (defs (alist-cons name (or src (find pair? locs))
                                     defs)))
-              (make-reference-dag refs defs name)))
+              (make-reference-graph refs defs name)))
            ((<toplevel-set> name src)
-            (add-ref-from-context dag name))
-           (else dag))))
+            (add-ref-from-context graph name))
+           (else graph))))
 
-     (lambda (x dag env locs)
+     (lambda (x graph env locs)
        ;; Leaving X's scope.
        (record-case x
          ((<toplevel-define>)
-          (let ((refs (reference-dag-refs dag))
-                (defs (reference-dag-defs dag)))
-            (make-reference-dag refs defs #f)))
-         (else dag)))
+          (let ((refs (reference-graph-refs graph))
+                (defs (reference-graph-defs graph)))
+            (make-reference-graph refs defs #f)))
+         (else graph)))
 
-     (lambda (dag env)
-       ;; Process the resulting reference DAG: determine all private 
definitions
+     (lambda (graph env)
+       ;; Process the resulting reference graph: determine all private 
definitions
        ;; not reachable from any public definition.  Macros
        ;; (syntax-transformers), which are globally bound, never considered
        ;; unused since we can't tell whether a macro is actually used; in
-       ;; addition, macros are considered roots of the DAG since they may use
+       ;; addition, macros are considered roots of the graph since they may use
        ;; private bindings.  FIXME: The `make-syntax-transformer' calls don't
        ;; contain any literal `toplevel-ref' of the global bindings they use so
        ;; this strategy fails.
@@ -759,10 +759,10 @@ accurate information is missing from a given `tree-il' 
element."
                                   (let ((name (car name+src)))
                                     (or (exported? name)
                                         (macro-variable? name env))))
-                                (reference-dag-defs dag))))
+                                (reference-graph-defs graph))))
          (let* ((roots     (cons #f (map car public-defs)))
-                (refs      (reference-dag-refs dag))
-                (reachable (dag-reachable-nodes* roots refs))
+                (refs      (reference-graph-refs graph))
+                (reachable (graph-reachable-nodes* roots refs))
                 (unused    (filter (lambda (name+src)
                                      ;; FIXME: This is inefficient when
                                      ;; REACHABLE is large (e.g., boot-9.scm);
@@ -775,7 +775,7 @@ accurate information is missing from a given `tree-il' 
element."
                          (warning 'unused-toplevel loc name)))
                      (reverse unused)))))
 
-     (make-reference-dag '() '() #f))))
+     (make-reference-graph '() '() #f))))
 
 
 ;;;
diff --git a/test-suite/tests/tree-il.test b/test-suite/tests/tree-il.test
index fb875cc..539540c 100644
--- a/test-suite/tests/tree-il.test
+++ b/test-suite/tests/tree-il.test
@@ -661,10 +661,6 @@
                                       #:opts %opts-w-unused-toplevel))))))
 
      (pass-if "unused but define-public"
-       ;; FIXME: We don't handle this case for now because `define-public'
-       ;; expands to a relatively complex statement that's hard to match.
-       (throw 'unresolved)
-
        (null? (call-with-warnings
                 (lambda ()
                   (compile '(define-public foo 2)


hooks/post-receive
-- 
GNU Guile