Clear Mismatch and PrintNotImpl

Summary: Fix bugs in `jump_targets`, `instruction_sequence`, `emit_statement` and add missing components to clear mismatches and 1 unimplemeted print

Reviewed By: shiqicao

Differential Revision: D20373730

fbshipit-source-id: 2cd7bdb4f4efad0916644f57e1453efca3839395

Author: Millie Chen

hphp/hack/src/hhbc/emit_statement.rs

@@ -314,17 +314,16 @@ pub fn emit_stmt(e: &mut Emitter, env: &mut Env, stmt: &tast::Stmt) -> Result {
             InstrSeq::make_throw(),
         ])),
         a::Stmt_::Try(x) => {
-            //TODO(hrust): Implement fail_if_goto_from_try_to_finally in tfr when visitor is updated
-            // if env.jump_targets_gen().get_function_has_goto() {
-            //     tfr::fail_if_goto_from_try_to_finally(&x.0, &x.2)
-            // }
+            if env.jump_targets_gen.get_function_has_goto() {
+                tfr::fail_if_goto_from_try_to_finally(&x.0, &x.2)?;
+            }
             let (try_block, catch_list, finally_block) = &**x;
             if catch_list.is_empty() {
                 emit_try_finally(e, env, pos, &try_block, &finally_block)
             } else if finally_block.is_empty() {
                 emit_try_catch(e, env, pos, &try_block, &catch_list[..])
             } else {
-                //TODO: avoid cloning block
+                //TODO(hrust): avoid cloning block
                 let try_catch_finally = tast::Stmt(
                     pos.clone(),
                     tast::Stmt_::mk_try(
@@ -498,7 +497,7 @@ fn emit_try_catch_(
     try_block: &tast::Block,
     catch_list: &[tast::Catch],
 ) -> Result {
-    if try_block.is_empty() {
+    if is_empty_block(&try_block) {
         return Ok(InstrSeq::Empty);
     };
     let end_label = e.label_gen_mut().next_regular();

hphp/hack/src/hhbc/instruction_sequence.rs

@@ -214,7 +214,6 @@ impl InstrSeq {
     pub fn make_iter_break(label: Label, itrs: Vec<IterId>) -> Self {
         let mut instrs = itrs
             .into_iter()
-            .rev()
             .map(|id| Instruct::IIterator(InstructIterator::IterFree(id)))
             .collect::<Vec<_>>();
         instrs.push(Instruct::IContFlow(InstructControlFlow::Jmp(label)));

hphp/hack/src/hhbc/jump_targets.rs

@@ -129,10 +129,13 @@ impl JumpTargets {
         //  }
         for r in self.0.iter().rev() {
             match r {
+                Region::Function(_) | Region::Finally(_) => return ResolvedJumpTarget::NotFound,
                 Region::Using(finally_label, _) | Region::TryFinally(finally_label, _) => {
                     // we need to jump out of try body in try/finally - in order to do this
                     // we should go through the finally block first
-                    skip_try_finally = Some(finally_label);
+                    if skip_try_finally.is_none() {
+                        skip_try_finally = Some((finally_label, level, iters.clone()));
+                    }
                 }
                 Region::Switch(end_label, _) => {
                     if level == 1 {
@@ -165,10 +168,9 @@ impl JumpTargets {
                         level -= 1;
                     }
                 }
-                _ => (),
             }
         }
-        if let Some(finally_label) = skip_try_finally {
+        if let Some((finally_label, level, iters)) = skip_try_finally {
             if let Some(target_label) = label {
                 return ResolvedJumpTarget::ResolvedTryFinally(ResolvedTryFinally {
                     target_label: target_label.clone(),

hphp/hack/src/hhbc/print.rs

@@ -811,7 +811,7 @@ fn print_adata<W: Write>(ctx: &mut Context, w: &mut W, tv: &TypedValue) -> Resul
         TypedValue::VArray((values, loc)) => {
             print_adata_collection_argument(ctx, w, VARRAY_PREFIX, loc, values)
         }
-        TypedValue::HhasAdata(_) => not_impl!(),
+        TypedValue::HhasAdata(s) => not_impl!(),
     }
 }
 
@@ -2003,7 +2003,13 @@ fn print_expr<W: Write>(
     match expr {
         E_::Id(id) => w.write(adjust_id(env, &id.1)),
         E_::Lvar(lid) => w.write(escaper::escape(&(lid.1).1)),
-        E_::Float(f) => not_impl!(),
+        E_::Float(f) => {
+            w.write(if f.contains('E') || f.contains('e') {
+                format!("{:.1}E", f.parse::<f64>().map_err(|_| Error::fail(format!("ParseFloatError: {}", f)))?)
+            } else {
+                f.into()
+            })
+        }
         E_::Int(i) => {
             w.write(integer::to_decimal(i.as_str()).map_err(|_| Error::fail("ParseIntError"))?)
         }

hphp/hack/src/hhbc/try_finally_rewriter.rs

@@ -14,10 +14,14 @@ use emit_fatal_rust as emit_fatal;
 use emit_pos_rust::emit_pos;
 use env::{emitter::Emitter, iterator, jump_targets as jt, local, Env};
 use hhbc_ast_rust::{self as hhbc_ast, Instruct};
-use instruction_sequence_rust::{InstrSeq, Result};
+use instruction_sequence_rust::{Error, InstrSeq, Result};
 use label::Label;
 use label_rust as label;
-use oxidized::pos::Pos;
+use oxidized::{
+    aast_visitor::{visit, AstParams, Node, Visitor},
+    ast as tast,
+    pos::Pos,
+};
 
 use bitflags::bitflags;
 
@@ -184,6 +188,57 @@ pub fn emit_goto(
     }
 }
 
+pub fn fail_if_goto_from_try_to_finally(
+    try_block: &tast::Block,
+    finally_block: &tast::Block,
+) -> Result<()> {
+    fn find_gotos_in(block: &tast::Block) -> Vec<tast::Pstring> {
+        struct State(Vec<tast::Pstring>);
+        impl Visitor for State {
+            type P = AstParams<(), ()>;
+
+            fn object(&mut self) -> &mut dyn Visitor<P = Self::P> {
+                self
+            }
+
+            fn visit_stmt_(&mut self, c: &mut (), s: &tast::Stmt_) -> std::result::Result<(), ()> {
+                match s {
+                    tast::Stmt_::Goto(l) => Ok(self.0.push((&**l).clone())),
+                    _ => s.recurse(c, self),
+                }
+            }
+        }
+        let mut state = State(vec![]);
+        visit(&mut state, &mut (), block).unwrap();
+        state.0
+    };
+
+    struct GotoVisitor {};
+    impl Visitor for GotoVisitor {
+        type P = AstParams<Vec<tast::Pstring>, Error>;
+
+        fn object(&mut self) -> &mut dyn Visitor<P = Self::P> {
+            self
+        }
+
+        fn visit_stmt_(&mut self, c: &mut Vec<tast::Pstring>, s: &tast::Stmt_) -> Result<()> {
+            match s {
+                tast::Stmt_::GotoLabel(l) => match c.iter().rev().find(|label| label.1 == l.1) {
+                    Some((pos, _)) => Err(emit_fatal::raise_fatal_parse(
+                        pos,
+                        "'goto' into finally statement is disallowed",
+                    )),
+                    _ => Ok(()),
+                },
+                _ => s.recurse(c, self.object()),
+            }
+        }
+    }
+    let mut visitor = GotoVisitor {};
+    let mut goto_labels = find_gotos_in(try_block);
+    visit(&mut visitor, &mut goto_labels, finally_block)
+}
+
 pub(super) fn emit_return(e: &mut Emitter, in_finally_epilogue: bool, env: &mut Env) -> Result {
     // check if there are try/finally region
     let jt_gen = &env.jump_targets_gen;