Makes the new Proofview.tactic the basic type of Ltac.

On the compilation of Coq, we can see an increase of ~20% compile time on
my completely non-scientific tests. Hopefully this can be fixed.

There are a lot of low hanging fruits, but this is an iso-functionality commit.
With a few exceptions which were not necessary for the compilation of the theories:
- The declarative mode is not yet ported
- The timeout tactical is currently deactivated because it needs some subtle
I/O. The framework is ready to handle it, but I haven't done it yet.
-  For much the same reason, the ltac debugger is unplugged. It will be more
difficult, but will eventually be back.

A few comments:
I occasionnally used a coercion from [unit Proofview.tactic] to the old
[Prooftype.tactic]. It should work smoothely, but loses any backtracking
information: the coerced tactics has at most one success.
- It is used in autorewrite (it shouldn't be a problem there). Autorewrite's
code is fairly old and tricky
- It is used in eauto, mostly for "Hint Extern". It may be an issue as time goes
as we might want to have various success in a "Hint Extern". But it would
require a heavy port of eauto.ml4
- It is used in typeclass eauto, but with a little help from Matthieu, it should
be easy to port the whole thing to the new tactic engine, actually simplifying
the code.
- It is used in fourier. I believe it to be inocuous.
- It is used in firstorder and congruence. I think it's ok. Their code is
somewhat intricate and I'm not sure they would be easy to actually port.
- It is used heavily in Function. And honestly, I have no idea whether it can do
harm or not.

Updates:
(11 June 2013) Pierre-Marie Pédrot contributed the rebase over his new stream based
architecture for Ltac matching (r16533), which avoid painfully and expensively
working around the exception-throwing control flow of the previous API.
(11 October 2013) Rebasing over recent commits (somewhere in r16721-r16730)
rendered a major bug in my implementation of Tacticals.New.tclREPEAT_MAIN
apparent. It caused Field_theory.v to loop. The bug made rewrite !lemma,
rewrite ?lemma and autorewrite incorrect (tclREPEAT_MAIN was essentially
tclREPEAT, causing rewrites to be tried in the side-conditions of conditional
rewrites as well). The new implementation makes Coq faster, but it is
pretty much impossible to tell if it is significant at all.

git-svn-id: svn+ssh://scm.gforge.inria.fr/svn/coq/trunk@16967 85f007b7-540e-0410-9357-904b9bb8a0f7

1 files changed, 15 insertions, 11 deletions

diff --git a/tactics/leminv.ml b/tactics/leminv.ml
index 19e7153b5..00cf4e997 100644
--- a/tactics/leminv.ml
+++ b/tactics/leminv.ml
@@ -28,6 +28,7 @@ open Declare
 open Tacticals
 open Tactics
 open Decl_kinds
+open Proofview.Notations
 
 let no_inductive_inconstr env constr =
   (str "Cannot recognize an inductive predicate in " ++
@@ -196,8 +197,10 @@ let inversion_scheme env sigma t sort dep_option inv_op =
     (str"Computed inversion goal was not closed in initial signature.");
   *)
   let pf = Proof.start [invEnv,invGoal] in
-  let pf = Proof.run_tactic env 
-    (Proofview.V82.tactic (tclTHEN intro (onLastHypId inv_op))) pf in
+  let pf =
+    Proof.run_tactic env (
+      Tacticals.New.tclTHEN intro (Tacticals.New.onLastHypId inv_op)) pf
+  in
   let pfterm = List.hd (Proof.partial_proof pf) in
   let global_named_context = Global.named_context () in
   let ownSign = ref begin
@@ -278,19 +281,20 @@ let lemInv id c gls =
 	   (str "Cannot refine current goal with the lemma " ++
 	      pr_lconstr_env (Global.env()) c)
 
-let lemInv_gen id c = try_intros_until (fun id -> lemInv id c) id
+let lemInv_gen id c = try_intros_until (fun id -> Proofview.V82.tactic (lemInv id c)) id
 
-let lemInvIn id c ids gls =
-  let hyps = List.map (pf_get_hyp gls) ids in
-  let intros_replace_ids gls =
-    let nb_of_new_hyp  = nb_prod (pf_concl gls) - List.length ids in
+let lemInvIn id c ids =
+  Goal.sensitive_list_map Tacmach.New.pf_get_hyp ids >>- fun hyps ->
+  let intros_replace_ids =
+    Goal.concl >>- fun concl ->
+    let nb_of_new_hyp  = nb_prod concl - List.length ids in
     if nb_of_new_hyp < 1  then
-      intros_replacing ids gls
+      intros_replacing ids
     else
-      (tclTHEN (tclDO nb_of_new_hyp intro) (intros_replacing ids)) gls
+      (Tacticals.New.tclTHEN (Tacticals.New.tclDO nb_of_new_hyp intro) (intros_replacing ids))
   in
-  ((tclTHEN (tclTHEN (bring_hyps hyps) (lemInv id c))
-    (intros_replace_ids)) gls)
+  ((Tacticals.New.tclTHEN (Proofview.V82.tactic (tclTHEN (bring_hyps hyps) (lemInv id c)))
+    (intros_replace_ids)))
 
 let lemInvIn_gen id c l = try_intros_until (fun id -> lemInvIn id c l) id