Bail out of HIR translation if we can't handle a param flag

Author: tekknolagi

zjit/src/hir.rs

@@ -1664,12 +1664,23 @@ pub enum CallType {
     Forwarding,
 }
 
+#[derive(Debug, PartialEq)]
+pub enum ArgType {
+    Opt,
+    Rest,
+    Post,
+    Kw,
+    KwRest,
+    Block,
+}
+
 #[derive(Debug, PartialEq)]
 pub enum ParseError {
     StackUnderflow(FrameState),
     UnknownOpcode(String),
     UnknownNewArraySend(String),
     UnhandledCallType(CallType),
+    UnhandledArgType(ArgType),
 }
 
 fn num_lead_params(iseq: *const rb_iseq_t) -> usize {
@@ -1699,8 +1710,20 @@ fn filter_translatable_calls(flag: u32) -> Result<(), ParseError> {
     Ok(())
 }
 
+/// If we can't handle the type of params (yet), bail out.
+fn filter_translatable_params(iseq: IseqPtr) -> Result<(), ParseError> {
+    if unsafe { rb_get_iseq_flags_has_opt(iseq) } { return Err(ParseError::UnhandledArgType(ArgType::Opt)); }
+    if unsafe { rb_get_iseq_flags_has_rest(iseq) } { return Err(ParseError::UnhandledArgType(ArgType::Rest)); }
+    if unsafe { rb_get_iseq_flags_has_post(iseq) } { return Err(ParseError::UnhandledArgType(ArgType::Post)); }
+    if unsafe { rb_get_iseq_flags_has_kw(iseq) } { return Err(ParseError::UnhandledArgType(ArgType::Kw)); }
+    if unsafe { rb_get_iseq_flags_has_kwrest(iseq) } { return Err(ParseError::UnhandledArgType(ArgType::KwRest)); }
+    if unsafe { rb_get_iseq_flags_has_block(iseq) } { return Err(ParseError::UnhandledArgType(ArgType::Block)); }
+    Ok(())
+}
+
 /// Compile ISEQ into High-level IR
 pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
+    filter_translatable_params(iseq)?;
     let mut fun = Function::new(iseq);
     // Compute a map of PC->Block by finding jump targets
     let jump_targets = compute_jump_targets(iseq);
@@ -2789,31 +2812,80 @@ mod tests {
     }
 
     #[test]
-    fn test_cant_compile_splat() {
+    fn test_cant_compile_opt_arg() {
+        eval("
+            def test(a=1) = 1
+        ");
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::Opt))
+    }
+
+    #[test]
+    fn test_cant_compile_rest_arg() {
+        eval("
+            def test(*a) = 1
+        ");
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::Rest))
+    }
+
+    #[test]
+    fn test_cant_compile_post_arg() {
+        eval("
+            def test(*a, b) = 1
+        ");
+        // TODO(max): Change to Post when we support Rest
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::Rest))
+    }
+
+    #[test]
+    fn test_cant_compile_kw_arg() {
+        eval("
+            def test(a:) = 1
+        ");
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::Kw))
+    }
+
+    #[test]
+    fn test_cant_compile_kwrest_arg() {
+        eval("
+            def test(**a) = 1
+        ");
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::KwRest))
+    }
+
+    #[test]
+    fn test_cant_compile_block_arg() {
+        eval("
+            def test(&a) = 1
+        ");
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::Block))
+    }
+
+    #[test]
+    fn test_cant_compile_send_splat() {
         eval("
             def test(a) = foo(*a)
         ");
         assert_compile_fails("test", ParseError::UnknownOpcode("splatarray".into()))
     }
 
     #[test]
-    fn test_cant_compile_block_arg() {
+    fn test_cant_compile_send_block_arg() {
         eval("
             def test(a) = foo(&a)
         ");
         assert_compile_fails("test", ParseError::UnhandledCallType(CallType::BlockArg))
     }
 
     #[test]
-    fn test_cant_compile_kwarg() {
+    fn test_cant_compile_send_kwarg() {
         eval("
             def test(a) = foo(a: 1)
         ");
         assert_compile_fails("test", ParseError::UnhandledCallType(CallType::Kwarg))
     }
 
     #[test]
-    fn test_cant_compile_kw_splat() {
+    fn test_cant_compile_send_kw_splat() {
         eval("
             def test(a) = foo(**a)
         ");
@@ -2823,23 +2895,23 @@ mod tests {
     // TODO(max): Figure out how to generate a call with TAILCALL flag
 
     #[test]
-    fn test_cant_compile_super() {
+    fn test_cant_compile_send_super() {
         eval("
             def test = super()
         ");
         assert_compile_fails("test", ParseError::UnknownOpcode("invokesuper".into()))
     }
 
     #[test]
-    fn test_cant_compile_zsuper() {
+    fn test_cant_compile_send_zsuper() {
         eval("
             def test = super
         ");
         assert_compile_fails("test", ParseError::UnknownOpcode("invokesuper".into()))
     }
 
     #[test]
-    fn test_cant_compile_super_forward() {
+    fn test_cant_compile_send_super_forward() {
         eval("
             def test(...) = super(...)
         ");
@@ -2849,23 +2921,24 @@ mod tests {
     // TODO(max): Figure out how to generate a call with OPT_SEND flag
 
     #[test]
-    fn test_cant_compile_kw_splat_mut() {
+    fn test_cant_compile_send_kw_splat_mut() {
         eval("
             def test(a) = foo **a, b: 1
         ");
         assert_compile_fails("test", ParseError::UnknownOpcode("putspecialobject".into()))
     }
 
     #[test]
-    fn test_cant_compile_splat_mut() {
+    fn test_cant_compile_send_splat_mut() {
         eval("
             def test(*) = foo *, 1
         ");
-        assert_compile_fails("test", ParseError::UnknownOpcode("splatarray".into()))
+        // TODO(max): Change to unhandled splat mut call type when we support rest params
+        assert_compile_fails("test", ParseError::UnhandledArgType(ArgType::Rest))
     }
 
     #[test]
-    fn test_cant_compile_forwarding() {
+    fn test_cant_compile_send_forwarding() {
         eval("
             def test(...) = foo(...)
         ");