github
/
boa
mirror of https://github.com/boa-dev/boa.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Fix unreachable panics in compile_access (#1861) 

This PR changes the following:

- More elegantly handles illegal access statements in compile_access
- Adds a slew of previously unhandled illegal access test cases

### Caveats

It is very, very likely that you will want to simply restrict unary and assignment operations in the AST. However, this prevents crashes in the meantime with a error that is just slightly less detailed than if it were implemented in AST.
pull/1904/head
Addison Crump 3 years ago
parent
3b53fec412
commit
7fa37b50bc
2 changed files with 95 additions and 15 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 65
      boa_engine/src/bytecompiler.rs
  2. 45
      boa_engine/src/tests.rs

65
boa_engine/src/bytecompiler.rs
Unescape View File

@ -456,13 +456,13 @@ impl<'b> ByteCompiler<'b> {
}
#[inline]
fn compile_access(node: &'_ Node) -> Access<'_> {
fn compile_access(node: &Node) -> Option<Access<'_>> {
match node {
Node::Identifier(name) => Access::Variable { name: name.sym() },
Node::GetConstField(node) => Access::ByName { node },
Node::GetField(node) => Access::ByValue { node },
Node::This => Access::This,
_ => unreachable!(),
Node::Identifier(name) => Some(Access::Variable { name: name.sym() }),
Node::GetConstField(node) => Some(Access::ByName { node }),
Node::GetField(node) => Some(Access::ByValue { node }),
Node::This => Some(Access::This),
_ => None,
}
}
@ -571,7 +571,10 @@ impl<'b> ByteCompiler<'b> {
self.compile_expr(unary.target(), true)?;
self.emit(Opcode::Inc, &[]);
let access = Self::compile_access(unary.target());
let access = Self::compile_access(unary.target()).ok_or_else(|| {
self.context
.construct_syntax_error("Invalid increment operand")
})?;
self.access_set(access, None, true)?;
None
}
@ -579,7 +582,10 @@ impl<'b> ByteCompiler<'b> {
self.compile_expr(unary.target(), true)?;
self.emit(Opcode::Dec, &[]);
let access = Self::compile_access(unary.target());
let access = Self::compile_access(unary.target()).ok_or_else(|| {
self.context
.construct_syntax_error("Invalid decrement operand")
})?;
self.access_set(access, None, true)?;
None
}
@ -587,7 +593,11 @@ impl<'b> ByteCompiler<'b> {
self.compile_expr(unary.target(), true)?;
self.emit(Opcode::Dup, &[]);
self.emit(Opcode::Inc, &[]);
let access = Self::compile_access(unary.target());
let access = Self::compile_access(unary.target()).ok_or_else(|| {
self.context
.construct_syntax_error("Invalid increment operand")
})?;
self.access_set(access, None, false)?;
None
@ -596,7 +606,11 @@ impl<'b> ByteCompiler<'b> {
self.compile_expr(unary.target(), true)?;
self.emit(Opcode::Dup, &[]);
self.emit(Opcode::Dec, &[]);
let access = Self::compile_access(unary.target());
let access = Self::compile_access(unary.target()).ok_or_else(|| {
self.context
.construct_syntax_error("Invalid decrement operand")
})?;
self.access_set(access, None, false)?;
None
@ -744,7 +758,12 @@ impl<'b> ByteCompiler<'b> {
AssignOp::BoolAnd => {
let exit = self.jump_with_custom_opcode(Opcode::LogicalAnd);
self.compile_expr(binary.rhs(), true)?;
let access = Self::compile_access(binary.lhs());
let access =
Self::compile_access(binary.lhs()).ok_or_else(|| {
self.context.construct_syntax_error(
"Invalid left-hand side in assignment",
)
})?;
self.access_set(access, None, use_expr)?;
self.patch_jump(exit);
None
@ -752,7 +771,12 @@ impl<'b> ByteCompiler<'b> {
AssignOp::BoolOr => {
let exit = self.jump_with_custom_opcode(Opcode::LogicalOr);
self.compile_expr(binary.rhs(), true)?;
let access = Self::compile_access(binary.lhs());
let access =
Self::compile_access(binary.lhs()).ok_or_else(|| {
self.context.construct_syntax_error(
"Invalid left-hand side in assignment",
)
})?;
self.access_set(access, None, use_expr)?;
self.patch_jump(exit);
None
@ -760,7 +784,12 @@ impl<'b> ByteCompiler<'b> {
AssignOp::Coalesce => {
let exit = self.jump_with_custom_opcode(Opcode::Coalesce);
self.compile_expr(binary.rhs(), true)?;
let access = Self::compile_access(binary.lhs());
let access =
Self::compile_access(binary.lhs()).ok_or_else(|| {
self.context.construct_syntax_error(
"Invalid left-hand side in assignment",
)
})?;
self.access_set(access, None, use_expr)?;
self.patch_jump(exit);
None
@ -770,7 +799,10 @@ impl<'b> ByteCompiler<'b> {
if let Some(opcode) = opcode {
self.compile_expr(binary.rhs(), true)?;
self.emit(opcode, &[]);
let access = Self::compile_access(binary.lhs());
let access = Self::compile_access(binary.lhs()).ok_or_else(|| {
self.context
.construct_syntax_error("Invalid left-hand side in assignment")
})?;
self.access_set(access, None, use_expr)?;
}
}
@ -903,7 +935,10 @@ impl<'b> ByteCompiler<'b> {
if let Node::Object(_) = assign.lhs() {
self.emit_opcode(Opcode::PushUndefined);
} else {
let access = Self::compile_access(assign.lhs());
let access = Self::compile_access(assign.lhs()).ok_or_else(|| {
self.context
.construct_syntax_error("Invalid left-hand side in assignment")
})?;
self.access_set(access, Some(assign.rhs()), use_expr)?;
}
}

45
boa_engine/src/tests.rs
Unescape View File

@ -485,6 +485,16 @@ fn unary_pre() {
assert_eq!(&exec(execs_before_dec), "true");
}
#[test]
fn invalid_unary_access() {
check_output(&[
TestAction::TestStartsWith("++[];", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("[]++;", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("--[];", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("[]--;", "Uncaught \"SyntaxError\": "),
]);
}
#[test]
fn typeof_string() {
let typeof_string = r#"
@ -690,6 +700,7 @@ fn unary_delete() {
mod in_operator {
use super::*;
use crate::forward_val;
#[test]
fn propery_in_object() {
let p_in_o = r#"
@ -1335,6 +1346,21 @@ fn assignment_to_non_assignable() {
}
}
#[test]
fn assignment_to_non_assignable_ctd() {
check_output(&[
TestAction::TestStartsWith("(()=>{})() -= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() *= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() /= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() %= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() &= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() ^= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() |= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() += 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() = 5", "Uncaught \"SyntaxError\": "),
]);
}
#[test]
fn multicharacter_assignment_to_non_assignable() {
// Relates to the behaviour described at
@ -1351,6 +1377,15 @@ fn multicharacter_assignment_to_non_assignable() {
}
}
#[test]
fn multicharacter_assignment_to_non_assignable_ctd() {
check_output(&[
TestAction::TestStartsWith("(()=>{})() **= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() <<= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() >>= 5", "Uncaught \"SyntaxError\": "),
]);
}
#[test]
fn multicharacter_bitwise_assignment_to_non_assignable() {
let mut context = Context::default();
@ -1366,6 +1401,16 @@ fn multicharacter_bitwise_assignment_to_non_assignable() {
}
}
#[test]
fn multicharacter_bitwise_assignment_to_non_assignable_ctd() {
check_output(&[
TestAction::TestStartsWith("(()=>{})() >>>= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() &&= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() ||= 5", "Uncaught \"SyntaxError\": "),
TestAction::TestStartsWith("(()=>{})() ??= 5", "Uncaught \"SyntaxError\": "),
]);
}
#[test]
fn assign_to_array_decl() {
check_output(&[

Write Preview
Loading…
Cancel
Save