src/HOL/Tools/Ctr_Sugar/ctr_sugar.ML

 
   val disc_of_ctr_spec: ('c, 'a) ctr_spec -> binding
   val ctr_of_ctr_spec: ('c, 'a) ctr_spec -> 'c
   val args_of_ctr_spec: ('c, 'a) ctr_spec -> 'a list
 
+  val fake_local_theory_for_sel_defaults: (binding * typ) list -> Proof.context -> Proof.context
   val free_constructors: ({prems: thm list, context: Proof.context} -> tactic) list list ->
     (((bool * bool) * binding) * (term, binding) ctr_spec list) * term list -> local_theory ->
     ctr_sugar * local_theory
   val parse_bound_term: (binding * string) parser
   val parse_ctr_options: (bool * bool) parser

       ((ctr, sel), fold_rev Term.lambda vars rhs)
     else
       malformed ()
   end;
 
+(* Ideally, we would enrich the context with constants rather than free variables. *)
+fun fake_local_theory_for_sel_defaults sel_bTs =
+  Proof_Context.allow_dummies
+  #> Proof_Context.add_fixes (map (fn (b, T) => (b, SOME T, NoSyn)) sel_bTs)
+  #> snd;
+
 type ('c, 'a) ctr_spec = (binding * 'c) * 'a list;
 
 fun disc_of_ctr_spec ((disc, _), _) = disc;
 fun ctr_of_ctr_spec ((_, ctr), _) = ctr;
 fun args_of_ctr_spec (_, args) = args;

     val (all_sels_distinct, discs, selss, disc_defs, sel_defs, sel_defss, lthy') =
       if no_discs_sels then
         (true, [], [], [], [], [], lthy')
       else
         let
-          val sel_bindings = flat sel_bindingss;
-          val uniq_sel_bindings = distinct Binding.eq_name sel_bindings;
-          val all_sels_distinct = (length uniq_sel_bindings = length sel_bindings);
+          val all_sel_bindings = flat sel_bindingss;
+          val num_all_sel_bindings = length all_sel_bindings;
+          val uniq_sel_bindings = distinct Binding.eq_name all_sel_bindings;
+          val all_sels_distinct = (length uniq_sel_bindings = num_all_sel_bindings);
 
           val sel_binding_index =
-            if all_sels_distinct then 1 upto length sel_bindings
-            else map (fn b => find_index (curry Binding.eq_name b) uniq_sel_bindings) sel_bindings;
-
-          val all_proto_sels = flat (map3 (fn k => fn xs => map (fn x => (k, (xs, x)))) ks xss xss);
+            if all_sels_distinct then
+              1 upto num_all_sel_bindings
+            else
+              map (fn b => find_index (curry Binding.eq_name b) uniq_sel_bindings) all_sel_bindings;
+
+          val all_proto_sels = flat (map3 (fn k => fn xs => map (pair k o pair xs)) ks xss xss);
           val sel_infos =
             AList.group (op =) (sel_binding_index ~~ all_proto_sels)
             |> sort (int_ord o pairself fst)
             |> map snd |> curry (op ~~) uniq_sel_bindings;
           val sel_bindings = map fst sel_infos;
-          val sel_Ts = map (curry (op -->) fcT o fastype_of o snd o snd o hd o snd) sel_infos;
-
-          val sel_default_lthy = no_defs_lthy
-            |> Proof_Context.allow_dummies
-            |> Proof_Context.add_fixes
-              (map2 (fn b => fn T => (b, SOME T, NoSyn)) sel_bindings sel_Ts)
-            |> snd;
 
           val sel_defaults =
-            map (extract_sel_default sel_default_lthy o prep_term sel_default_lthy) sel_default_eqs;
+            if null sel_default_eqs then
+              []
+            else
+              let
+                val sel_Ts = map (curry (op -->) fcT o fastype_of o snd o snd o hd o snd) sel_infos;
+                val fake_lthy =
+                  fake_local_theory_for_sel_defaults (sel_bindings ~~ sel_Ts) no_defs_lthy;
+              in
+                map (extract_sel_default fake_lthy o prep_term fake_lthy) sel_default_eqs
+              end;
 
           fun disc_free b = Free (Binding.name_of b, mk_pred1T fcT);
 
           fun disc_spec b exist_xs_u_eq_ctr = mk_Trueprop_eq (disc_free b $ u, exist_xs_u_eq_ctr);