Index: depend.ml
===================================================================
--- depend.ml	(revision 12879)
+++ depend.ml	(working copy)
@@ -110,27 +110,33 @@
 
 let rec add_pattern bv pat =
   match pat.ppat_desc with
-    Ppat_any -> ()
-  | Ppat_var _ -> ()
+    Ppat_any -> bv
+  | Ppat_var _ -> bv
   | Ppat_alias(p, _) -> add_pattern bv p
-  | Ppat_constant _ -> ()
-  | Ppat_tuple pl -> List.iter (add_pattern bv) pl
-  | Ppat_construct(c, op, _) -> add bv c; add_opt add_pattern bv op
+  | Ppat_constant _ -> bv
+  | Ppat_tuple pl -> List.fold_left add_pattern bv pl
+  | Ppat_construct(c, None, _) -> add bv c; bv
+  | Ppat_construct(c, Some p, _) -> add bv c; add_pattern bv p
   | Ppat_record(pl, _) ->
-      List.iter (fun (lbl, p) -> add bv lbl; add_pattern bv p) pl
-  | Ppat_array pl -> List.iter (add_pattern bv) pl
-  | Ppat_or(p1, p2) -> add_pattern bv p1; add_pattern bv p2
-  | Ppat_constraint(p, ty) -> add_pattern bv p; add_type bv ty
-  | Ppat_variant(_, op) -> add_opt add_pattern bv op
-  | Ppat_type li -> add bv li
+      List.fold_left (fun bv (lbl, p) -> add bv lbl; add_pattern bv p) bv pl
+  | Ppat_array pl ->
+    List.fold_left add_pattern bv pl
+  | Ppat_or(p1, p2) ->
+    ignore (add_pattern bv p1 : StringSet.t);
+    add_pattern bv p2
+  | Ppat_constraint(p, ty) -> add_type bv ty; add_pattern bv p
+  | Ppat_variant(_, None) -> bv
+  | Ppat_variant(_, Some p) -> add_pattern bv p
+  | Ppat_type li -> add bv li; bv
   | Ppat_lazy p -> add_pattern bv p
-  | Ppat_unpack id -> add bv (mkloc (Lident id.txt) id.loc)
+  | Ppat_unpack { txt = s } -> StringSet.add s bv
 
 let rec add_expr bv exp =
   match exp.pexp_desc with
     Pexp_ident l -> add bv l
   | Pexp_constant _ -> ()
-  | Pexp_let(_, pel, e) -> add_pat_expr_list bv pel; add_expr bv e
+  | Pexp_let(rec_flag, pel, e) ->
+    let bv = add_bindings rec_flag bv pel in add_expr bv e
   | Pexp_function (_, opte, pel) ->
       add_opt add_expr bv opte; add_pat_expr_list bv pel
   | Pexp_apply(e, el) ->
@@ -168,12 +174,26 @@
   | Pexp_lazy (e) -> add_expr bv e
   | Pexp_poly (e, t) -> add_expr bv e; add_opt add_type bv t
   | Pexp_object { pcstr_pat = pat; pcstr_fields = fieldl } ->
-      add_pattern bv pat; List.iter (add_class_field bv) fieldl
+    let bv = add_pattern bv pat in List.iter (add_class_field bv) fieldl
   | Pexp_newtype (_, e) -> add_expr bv e
   | Pexp_pack m -> add_module bv m
   | Pexp_open (m, e) -> addmodule bv m; add_expr bv e
+
+(* scope of variables bound in patterns are expressions only if recursive *)
+and add_bindings recflag bv pel =
+  let bv' = List.fold_left
+    (fun bv (p, e) -> add_pattern bv p) bv pel in
+  let bv'' =
+    match recflag with
+        Recursive -> bv'
+      | Nonrecursive | Default -> bv
+  in
+  List.iter (fun (_, e) -> add_expr bv'' e) pel;
+  bv'
+
+(* scope of variables bound in patterns are expressions *)
 and add_pat_expr_list bv pel =
-  List.iter (fun (p, e) -> add_pattern bv p; add_expr bv e) pel
+  List.iter (fun (p, e) -> let bv = add_pattern bv p in add_expr bv e) pel
 
 and add_modtype bv mty =
   match mty.pmty_desc with
@@ -245,8 +265,8 @@
   match item.pstr_desc with
     Pstr_eval e ->
       add_expr bv e; bv
-  | Pstr_value(id, pel) ->
-      add_pat_expr_list bv pel; bv
+  | Pstr_value(rec_flag, pel) ->
+      let bv = add_bindings rec_flag bv pel in bv
   | Pstr_primitive(id, vd) ->
       add_type bv vd.pval_type; bv
   | Pstr_type dcls ->
@@ -291,13 +311,14 @@
     Pcl_constr(l, tyl) ->
       add bv l; List.iter (add_type bv) tyl
   | Pcl_structure { pcstr_pat = pat; pcstr_fields = fieldl } ->
-      add_pattern bv pat; List.iter (add_class_field bv) fieldl
+    let bv = add_pattern bv pat in List.iter (add_class_field bv) fieldl
   | Pcl_fun(_, opte, pat, ce) ->
-      add_opt add_expr bv opte; add_pattern bv pat; add_class_expr bv ce
+      add_opt add_expr bv opte;
+      let bv = add_pattern bv pat in add_class_expr bv ce
   | Pcl_apply(ce, exprl) ->
       add_class_expr bv ce; List.iter (fun (_,e) -> add_expr bv e) exprl
-  | Pcl_let(_, pel, ce) ->
-      add_pat_expr_list bv pel; add_class_expr bv ce
+  | Pcl_let(rec_flag, pel, ce) ->
+    let bv = add_bindings rec_flag bv pel in add_class_expr bv ce
   | Pcl_constraint(ce, ct) ->
       add_class_expr bv ce; add_class_type bv ct