From c95dd77fae45d1e916ea2f0a6683d5cb3e0737ce Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 5 Jul 2020 13:50:58 +0100
Subject: [PATCH 01/13] start on label

---
 .../parser/statement/labelled_stm/mod.rs      | 47 +++++++++++++++++++
 boa/src/syntax/parser/statement/mod.rs        |  6 ++-
 2 files changed, 52 insertions(+), 1 deletion(-)
 create mode 100644 boa/src/syntax/parser/statement/labelled_stm/mod.rs

diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
new file mode 100644
index 00000000000..bb7ae581f2a
--- /dev/null
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -0,0 +1,47 @@
+use super::LabelIdentifier;
+use crate::{
+    syntax::{
+        ast::Punctuator,
+        parser::{
+            cursor::Cursor, error::ParseError, AllowAwait, AllowReturn, AllowYield, TokenParser,
+        },
+    },
+    BoaProfiler,
+};
+/// Labelled Statement Parsing
+///
+/// More information
+/// - [MDN documentation][mdn]
+/// - [ECMAScript specification][spec]
+///
+/// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label
+/// [spec]: https://tc39.es/ecma262/#sec-labelled-statements
+#[derive(Debug, Clone, Copy)]
+pub(super) struct Label {
+    allow_yield: AllowYield,
+    allow_await: AllowAwait,
+    allow_return: AllowReturn,
+}
+
+impl Label {
+    pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self
+    where
+        Y: Into<AllowYield>,
+        A: Into<AllowAwait>,
+        R: Into<AllowReturn>,
+    {
+        Self {
+            allow_yield: allow_yield.into(),
+            allow_await: allow_await.into(),
+            allow_return: allow_return.into(),
+        }
+    }
+}
+
+impl TokenParser for Label {
+    fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> {
+        let _timer = BoaProfiler::global().start_event("Label", "Parsing");
+        let name = LabelIdentifier::new(false, false).try_parse(cursor);
+        cursor.expect(Punctuator::Colon, "Labelled Statement")?;
+    }
+}
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 6b93bdc7e88..49b90910de0 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -14,6 +14,7 @@ mod declaration;
 mod expression;
 mod if_stm;
 mod iteration;
+mod labelled_stm;
 mod return_stm;
 mod switch;
 mod throw;
@@ -170,6 +171,9 @@ where
                     .parse(cursor)
                     .map(Node::from)
             }
+            // TokenKind::Identifier(name) => LabelIdentifier::new(self.allow_yield, self.allow_await)
+            //     .parse(cursor)
+            //     .map(Node::from),
             // TODO: https://tc39.es/ecma262/#prod-LabelledStatement
             _ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor),
         }
@@ -367,7 +371,7 @@ where
 ///  - [ECMAScript specification][spec]
 ///
 /// [spec]: https://tc39.es/ecma262/#prod-LabelIdentifier
-type LabelIdentifier = BindingIdentifier;
+pub(super) type LabelIdentifier = BindingIdentifier;
 
 /// Binding identifier parsing.
 ///

From c483171f9dd555e251b365140a5fe4b837109402 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 5 Jul 2020 14:46:19 +0100
Subject: [PATCH 02/13] Parse optional label at the beginning of statement

---
 boa/src/syntax/parser/statement/labelled_stm/mod.rs | 5 ++++-
 boa/src/syntax/parser/statement/mod.rs              | 1 +
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index bb7ae581f2a..751173cd51f 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -39,9 +39,12 @@ impl Label {
 }
 
 impl TokenParser for Label {
+    type Output = Box<str>;
+
     fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
-        let name = LabelIdentifier::new(false, false).try_parse(cursor);
+        let name = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
         cursor.expect(Punctuator::Colon, "Labelled Statement")?;
+        Ok(name)
     }
 }
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 49b90910de0..02b9b8646d3 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -43,6 +43,7 @@ use crate::{
     syntax::ast::{node, Keyword, Node, Punctuator},
     BoaProfiler,
 };
+use labelled_stm::Label;
 
 use std::io::Read;
 

From 81e6b35068ef4e10ca71edb60f4a69dee17713c7 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 5 Jul 2020 16:14:19 +0100
Subject: [PATCH 03/13] * Working proof of concept for breaking with labels

---
 boa/src/exec/iteration/mod.rs                       | 13 +++++++++++--
 boa/src/syntax/ast/node/iteration.rs                | 10 +++++++++-
 .../parser/statement/iteration/for_statement.rs     |  7 +++++--
 boa/src/syntax/parser/statement/labelled_stm/mod.rs |  4 ++--
 boa/src/syntax/parser/statement/mod.rs              |  2 +-
 5 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/boa/src/exec/iteration/mod.rs b/boa/src/exec/iteration/mod.rs
index 29d04b2c027..ace74e72e38 100644
--- a/boa/src/exec/iteration/mod.rs
+++ b/boa/src/exec/iteration/mod.rs
@@ -34,8 +34,17 @@ impl Executable for ForLoop {
             let result = self.body().run(interpreter)?;
 
             match interpreter.executor().get_current_state() {
-                InterpreterState::Break(_label) => {
-                    // TODO break to label.
+                InterpreterState::Break(label) => {
+                    // If a label is set we want to break the current block and still keep state as Break if the label is a block above
+                    if let Some(stmt_label) = &self.label {
+                        if let Some(brk_label) = label {
+                            // We have a label, but not for the current statement
+                            // break without resetting to executing
+                            if stmt_label != brk_label {
+                                break;
+                            }
+                        }
+                    }
 
                     // Loops 'consume' breaks.
                     interpreter
diff --git a/boa/src/syntax/ast/node/iteration.rs b/boa/src/syntax/ast/node/iteration.rs
index d84a12499f3..8a5918dea7b 100644
--- a/boa/src/syntax/ast/node/iteration.rs
+++ b/boa/src/syntax/ast/node/iteration.rs
@@ -21,11 +21,18 @@ use serde::{Deserialize, Serialize};
 pub struct ForLoop {
     #[cfg_attr(feature = "serde", serde(flatten))]
     inner: Box<InnerForLoop>,
+    pub label: Option<String>,
 }
 
 impl ForLoop {
     /// Creates a new for loop AST node.
-    pub(in crate::syntax) fn new<I, C, E, B>(init: I, condition: C, final_expr: E, body: B) -> Self
+    pub(in crate::syntax) fn new<I, C, E, B>(
+        init: I,
+        condition: C,
+        final_expr: E,
+        body: B,
+        label: Option<String>,
+    ) -> Self
     where
         I: Into<Option<Node>>,
         C: Into<Option<Node>>,
@@ -34,6 +41,7 @@ impl ForLoop {
     {
         Self {
             inner: Box::new(InnerForLoop::new(init, condition, final_expr, body)),
+            label,
         }
     }
 
diff --git a/boa/src/syntax/parser/statement/iteration/for_statement.rs b/boa/src/syntax/parser/statement/iteration/for_statement.rs
index 8e53392fb73..d377d76bb04 100644
--- a/boa/src/syntax/parser/statement/iteration/for_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/for_statement.rs
@@ -34,11 +34,12 @@ use std::io::Read;
 ///
 /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for
 /// [spec]: https://tc39.es/ecma262/#sec-for-statement
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone)]
 pub(in crate::syntax::parser::statement) struct ForStatement {
     allow_yield: AllowYield,
     allow_await: AllowAwait,
     allow_return: AllowReturn,
+    label: Option<String>,
 }
 
 impl ForStatement {
@@ -47,6 +48,7 @@ impl ForStatement {
         allow_yield: Y,
         allow_await: A,
         allow_return: R,
+        label: Option<String>,
     ) -> Self
     where
         Y: Into<AllowYield>,
@@ -57,6 +59,7 @@ impl ForStatement {
             allow_yield: allow_yield.into(),
             allow_await: allow_await.into(),
             allow_return: allow_return.into(),
+            label,
         }
     }
 }
@@ -124,6 +127,6 @@ where
             Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
 
         // TODO: do not encapsulate the `for` in a block just to have an inner scope.
-        Ok(ForLoop::new(init, cond, step, body))
+        Ok(ForLoop::new(init, cond, step, body, self.label))
     }
 }
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index 751173cd51f..95bc350f069 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -39,12 +39,12 @@ impl Label {
 }
 
 impl TokenParser for Label {
-    type Output = Box<str>;
+    type Output = String;
 
     fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
         let name = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
         cursor.expect(Punctuator::Colon, "Labelled Statement")?;
-        Ok(name)
+        Ok(name.to_string())
     }
 }
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 02b9b8646d3..f1c0db1aa69 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -129,7 +129,7 @@ where
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::For) => {
-                ForStatement::new(self.allow_yield, self.allow_await, self.allow_return)
+                ForStatement::new(self.allow_yield, self.allow_await, self.allow_return, label)
                     .parse(cursor)
                     .map(Node::from)
             }

From cee2e0f1d70732cd66a4e3893344b5c5024452e5 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Thu, 16 Jul 2020 19:20:19 +0100
Subject: [PATCH 04/13] use labelled_stmt as a node

---
 boa/src/exec/iteration/mod.rs                 |  7 ++++
 boa/src/syntax/ast/node/iteration.rs          | 10 +----
 boa/src/syntax/ast/node/labelled_smt.rs       | 38 +++++++++++++++++++
 boa/src/syntax/ast/node/mod.rs                |  6 +++
 .../statement/iteration/for_statement.rs      |  5 +--
 .../parser/statement/labelled_stm/mod.rs      | 16 ++++----
 boa/src/syntax/parser/statement/mod.rs        | 23 ++++++++---
 7 files changed, 80 insertions(+), 25 deletions(-)
 create mode 100644 boa/src/syntax/ast/node/labelled_smt.rs

diff --git a/boa/src/exec/iteration/mod.rs b/boa/src/exec/iteration/mod.rs
index ace74e72e38..55138ea5fce 100644
--- a/boa/src/exec/iteration/mod.rs
+++ b/boa/src/exec/iteration/mod.rs
@@ -51,6 +51,13 @@ impl Executable for ForLoop {
                         .executor()
                         .set_current_state(InterpreterState::Executing);
                     break;
+                    //         }
+                    //     }
+                    // }
+
+                    // // Loops 'consume' breaks.
+                    // interpreter.set_current_state(InterpreterState::Executing);
+                    // break;
                 }
                 InterpreterState::Continue(_label) => {
                     // TODO continue to label.
diff --git a/boa/src/syntax/ast/node/iteration.rs b/boa/src/syntax/ast/node/iteration.rs
index 8a5918dea7b..d84a12499f3 100644
--- a/boa/src/syntax/ast/node/iteration.rs
+++ b/boa/src/syntax/ast/node/iteration.rs
@@ -21,18 +21,11 @@ use serde::{Deserialize, Serialize};
 pub struct ForLoop {
     #[cfg_attr(feature = "serde", serde(flatten))]
     inner: Box<InnerForLoop>,
-    pub label: Option<String>,
 }
 
 impl ForLoop {
     /// Creates a new for loop AST node.
-    pub(in crate::syntax) fn new<I, C, E, B>(
-        init: I,
-        condition: C,
-        final_expr: E,
-        body: B,
-        label: Option<String>,
-    ) -> Self
+    pub(in crate::syntax) fn new<I, C, E, B>(init: I, condition: C, final_expr: E, body: B) -> Self
     where
         I: Into<Option<Node>>,
         C: Into<Option<Node>>,
@@ -41,7 +34,6 @@ impl ForLoop {
     {
         Self {
             inner: Box::new(InnerForLoop::new(init, condition, final_expr, body)),
-            label,
         }
     }
 
diff --git a/boa/src/syntax/ast/node/labelled_smt.rs b/boa/src/syntax/ast/node/labelled_smt.rs
new file mode 100644
index 00000000000..f669f435e6b
--- /dev/null
+++ b/boa/src/syntax/ast/node/labelled_smt.rs
@@ -0,0 +1,38 @@
+use super::Node;
+use gc::{Finalize, Trace};
+use std::fmt;
+
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
+pub struct Label {
+    stmt: Box<Node>,
+    label: Box<str>,
+}
+
+impl Label {
+    pub(super) fn display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", format!("{}: {}", self.label, self.stmt))
+    }
+
+    pub fn new(stmt: Node, label: Box<str>) -> Self {
+        Self {
+            stmt: stmt.into(),
+            label,
+        }
+    }
+}
+
+impl From<Label> for Node {
+    fn from(label_stmt: Label) -> Node {
+        Node::Label(label_stmt)
+    }
+}
+
+impl fmt::Display for Label {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.display(f)
+    }
+}
diff --git a/boa/src/syntax/ast/node/mod.rs b/boa/src/syntax/ast/node/mod.rs
index 7042451acbc..dbc76a377b7 100644
--- a/boa/src/syntax/ast/node/mod.rs
+++ b/boa/src/syntax/ast/node/mod.rs
@@ -9,6 +9,7 @@ pub mod expression;
 pub mod field;
 pub mod identifier;
 pub mod iteration;
+pub mod labelled_smt;
 pub mod object;
 pub mod operator;
 pub mod return_smt;
@@ -31,6 +32,7 @@ pub use self::{
     field::{GetConstField, GetField},
     identifier::Identifier,
     iteration::{Continue, DoWhileLoop, ForLoop, WhileLoop},
+    labelled_smt::Label,
     object::Object,
     operator::{Assign, BinOp, UnaryOp},
     return_smt::Return,
@@ -116,6 +118,9 @@ pub enum Node {
     /// An 'if' statement. [More information](./conditional/struct.If.html).
     If(If),
 
+    /// A labelled Statement.
+    Label(Label),
+
     /// A `let` declaration list. [More information](./declaration/struct.LetDeclList.html).
     LetDeclList(LetDeclList),
 
@@ -222,6 +227,7 @@ impl Node {
             Self::WhileLoop(ref while_loop) => while_loop.display(f, indentation),
             Self::DoWhileLoop(ref do_while) => do_while.display(f, indentation),
             Self::If(ref if_smt) => if_smt.display(f, indentation),
+            Self::Label(ref label) => label.display(f),
             Self::Switch(ref switch) => switch.display(f, indentation),
             Self::Object(ref obj) => obj.display(f, indentation),
             Self::ArrayDecl(ref arr) => Display::fmt(arr, f),
diff --git a/boa/src/syntax/parser/statement/iteration/for_statement.rs b/boa/src/syntax/parser/statement/iteration/for_statement.rs
index d377d76bb04..b950f265109 100644
--- a/boa/src/syntax/parser/statement/iteration/for_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/for_statement.rs
@@ -39,7 +39,6 @@ pub(in crate::syntax::parser::statement) struct ForStatement {
     allow_yield: AllowYield,
     allow_await: AllowAwait,
     allow_return: AllowReturn,
-    label: Option<String>,
 }
 
 impl ForStatement {
@@ -48,7 +47,6 @@ impl ForStatement {
         allow_yield: Y,
         allow_await: A,
         allow_return: R,
-        label: Option<String>,
     ) -> Self
     where
         Y: Into<AllowYield>,
@@ -59,7 +57,6 @@ impl ForStatement {
             allow_yield: allow_yield.into(),
             allow_await: allow_await.into(),
             allow_return: allow_return.into(),
-            label,
         }
     }
 }
@@ -127,6 +124,6 @@ where
             Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
 
         // TODO: do not encapsulate the `for` in a block just to have an inner scope.
-        Ok(ForLoop::new(init, cond, step, body, self.label))
+        Ok(ForLoop::new(init, cond, step, body))
     }
 }
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index 95bc350f069..fcf651af6ad 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -1,7 +1,7 @@
-use super::LabelIdentifier;
+use super::{LabelIdentifier, Statement};
 use crate::{
     syntax::{
-        ast::Punctuator,
+        ast::{node::Label, Punctuator},
         parser::{
             cursor::Cursor, error::ParseError, AllowAwait, AllowReturn, AllowYield, TokenParser,
         },
@@ -17,13 +17,13 @@ use crate::{
 /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/label
 /// [spec]: https://tc39.es/ecma262/#sec-labelled-statements
 #[derive(Debug, Clone, Copy)]
-pub(super) struct Label {
+pub(super) struct LabelledStatement {
     allow_yield: AllowYield,
     allow_await: AllowAwait,
     allow_return: AllowReturn,
 }
 
-impl Label {
+impl LabelledStatement {
     pub(super) fn new<Y, A, R>(allow_yield: Y, allow_await: A, allow_return: R) -> Self
     where
         Y: Into<AllowYield>,
@@ -38,13 +38,15 @@ impl Label {
     }
 }
 
-impl TokenParser for Label {
-    type Output = String;
+impl TokenParser for LabelledStatement {
+    type Output = Label;
 
     fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
         let name = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
         cursor.expect(Punctuator::Colon, "Labelled Statement")?;
-        Ok(name.to_string())
+        let stmt =
+            Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
+        Ok(Label::new(stmt, name))
     }
 }
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index f1c0db1aa69..8fa27e85f63 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -43,7 +43,7 @@ use crate::{
     syntax::ast::{node, Keyword, Node, Punctuator},
     BoaProfiler,
 };
-use labelled_stm::Label;
+use labelled_stm::LabelledStatement;
 
 use std::io::Read;
 
@@ -129,7 +129,7 @@ where
                     .map(Node::from)
             }
             TokenKind::Keyword(Keyword::For) => {
-                ForStatement::new(self.allow_yield, self.allow_await, self.allow_return, label)
+                ForStatement::new(self.allow_yield, self.allow_await, self.allow_return)
                     .parse(cursor)
                     .map(Node::from)
             }
@@ -172,9 +172,22 @@ where
                     .parse(cursor)
                     .map(Node::from)
             }
-            // TokenKind::Identifier(name) => LabelIdentifier::new(self.allow_yield, self.allow_await)
-            //     .parse(cursor)
-            //     .map(Node::from),
+            // Create guard to check if the next token is a `:` then we know we're sitting on a label
+            // if not fall back to ExpressionStatement
+            TokenKind::Identifier(_)
+                if matches!(
+                    cursor.peek(1),
+                    Some(Token {
+                        kind: TokenKind::Punctuator(Punctuator::Colon),
+                        ..
+                    })
+                ) =>
+            {
+                LabelledStatement::new(self.allow_yield, self.allow_await, self.allow_return)
+                    .parse(cursor)
+                    .map(Node::from)
+            }
+
             // TODO: https://tc39.es/ecma262/#prod-LabelledStatement
             _ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor),
         }

From 44385e6b730ea2d0efabd5614e016ac02c28c62d Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Thu, 27 Aug 2020 09:58:39 +0100
Subject: [PATCH 05/13] Label is now set at "parse time" just after the `Node`
 is created. All exec needs to do now is run the statement. `Label` node is
 still needed because we don't know what the statement is

---
 boa/src/exec/labelled_stm/mod.rs                    |  7 +++++++
 boa/src/exec/mod.rs                                 |  1 +
 boa/src/syntax/ast/node/iteration.rs                |  6 ++++++
 boa/src/syntax/ast/node/labelled_smt.rs             | 12 ++++--------
 boa/src/syntax/ast/node/mod.rs                      |  8 ++++++++
 boa/src/syntax/parser/statement/labelled_stm/mod.rs |  5 +++--
 6 files changed, 29 insertions(+), 10 deletions(-)
 create mode 100644 boa/src/exec/labelled_stm/mod.rs

diff --git a/boa/src/exec/labelled_stm/mod.rs b/boa/src/exec/labelled_stm/mod.rs
new file mode 100644
index 00000000000..7e8b22e6e89
--- /dev/null
+++ b/boa/src/exec/labelled_stm/mod.rs
@@ -0,0 +1,7 @@
+use crate::{builtins::Value, syntax::ast::node::Label, Executable, Interpreter, Result};
+
+impl Executable for Label {
+    fn run(&self, interpreter: &mut Interpreter) -> Result<Value> {
+        self.stmt.run(interpreter)
+    }
+}
diff --git a/boa/src/exec/mod.rs b/boa/src/exec/mod.rs
index 7f7b9905638..c47111fc435 100644
--- a/boa/src/exec/mod.rs
+++ b/boa/src/exec/mod.rs
@@ -9,6 +9,7 @@ mod declaration;
 mod field;
 mod identifier;
 mod iteration;
+mod labelled_stm;
 mod new;
 mod object;
 mod operator;
diff --git a/boa/src/syntax/ast/node/iteration.rs b/boa/src/syntax/ast/node/iteration.rs
index d84a12499f3..1265becd811 100644
--- a/boa/src/syntax/ast/node/iteration.rs
+++ b/boa/src/syntax/ast/node/iteration.rs
@@ -21,6 +21,7 @@ use serde::{Deserialize, Serialize};
 pub struct ForLoop {
     #[cfg_attr(feature = "serde", serde(flatten))]
     inner: Box<InnerForLoop>,
+    label: Option<Box<str>>,
 }
 
 impl ForLoop {
@@ -34,6 +35,7 @@ impl ForLoop {
     {
         Self {
             inner: Box::new(InnerForLoop::new(init, condition, final_expr, body)),
+            label: None,
         }
     }
 
@@ -76,6 +78,10 @@ impl ForLoop {
 
         write!(f, "}}")
     }
+
+    pub fn set_label(&mut self, label: Box<str>) {
+        self.label = Some(label);
+    }
 }
 
 impl fmt::Display for ForLoop {
diff --git a/boa/src/syntax/ast/node/labelled_smt.rs b/boa/src/syntax/ast/node/labelled_smt.rs
index f669f435e6b..d1b0c73a751 100644
--- a/boa/src/syntax/ast/node/labelled_smt.rs
+++ b/boa/src/syntax/ast/node/labelled_smt.rs
@@ -8,20 +8,16 @@ use serde::{Deserialize, Serialize};
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[derive(Clone, Debug, Trace, Finalize, PartialEq)]
 pub struct Label {
-    stmt: Box<Node>,
-    label: Box<str>,
+    pub(crate) stmt: Box<Node>,
 }
 
 impl Label {
     pub(super) fn display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", format!("{}: {}", self.label, self.stmt))
+        write!(f, "{}", format!("{}", self.stmt))
     }
 
-    pub fn new(stmt: Node, label: Box<str>) -> Self {
-        Self {
-            stmt: stmt.into(),
-            label,
-        }
+    pub fn new(stmt: Node) -> Self {
+        Self { stmt: stmt.into() }
     }
 }
 
diff --git a/boa/src/syntax/ast/node/mod.rs b/boa/src/syntax/ast/node/mod.rs
index dbc76a377b7..9e5ee2f65e0 100644
--- a/boa/src/syntax/ast/node/mod.rs
+++ b/boa/src/syntax/ast/node/mod.rs
@@ -244,6 +244,14 @@ impl Node {
             Self::ConstDeclList(ref decl) => Display::fmt(decl, f),
         }
     }
+
+    // https://tc39.es/ecma262/#sec-labelled-statements
+    // Labels can be set on any statement
+    pub fn set_label(&mut self, label: Box<str>) {
+        if let Self::ForLoop(ref mut for_loop) = *self {
+            for_loop.set_label(label);
+        }
+    }
 }
 
 /// Utility to join multiple Nodes into a single string.
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index fcf651af6ad..6c0c8a6654c 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -45,8 +45,9 @@ impl TokenParser for LabelledStatement {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
         let name = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
         cursor.expect(Punctuator::Colon, "Labelled Statement")?;
-        let stmt =
+        let mut stmt =
             Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
-        Ok(Label::new(stmt, name))
+        stmt.set_label(name);
+        Ok(Label::new(stmt))
     }
 }

From 5a66507dec50ff87a0f83be15858834889f85c0b Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 20 Sep 2020 17:10:55 +0100
Subject: [PATCH 06/13] Label node isn't needed. Instead the Label parser
 modifies the Node to have a label then returns that Node.

---
 boa/src/exec/iteration/mod.rs                 | 12 ++++---
 boa/src/exec/labelled_stm/mod.rs              |  7 ----
 boa/src/exec/mod.rs                           |  1 -
 boa/src/syntax/ast/node/iteration.rs          |  2 +-
 boa/src/syntax/ast/node/labelled_smt.rs       | 34 -------------------
 boa/src/syntax/ast/node/mod.rs                |  6 ----
 .../parser/statement/labelled_stm/mod.rs      | 16 ++++++---
 7 files changed, 20 insertions(+), 58 deletions(-)
 delete mode 100644 boa/src/exec/labelled_stm/mod.rs
 delete mode 100644 boa/src/syntax/ast/node/labelled_smt.rs

diff --git a/boa/src/exec/iteration/mod.rs b/boa/src/exec/iteration/mod.rs
index 55138ea5fce..9161554aac8 100644
--- a/boa/src/exec/iteration/mod.rs
+++ b/boa/src/exec/iteration/mod.rs
@@ -39,8 +39,11 @@ impl Executable for ForLoop {
                     if let Some(stmt_label) = &self.label {
                         if let Some(brk_label) = label {
                             // We have a label, but not for the current statement
-                            // break without resetting to executing
-                            if stmt_label != brk_label {
+                            // break without resetting to executings
+                            if stmt_label.to_string() != *brk_label {
+                                break;
+                            } else {
+                                interpreter.set_current_state(InterpreterState::Executing);
                                 break;
                             }
                         }
@@ -55,9 +58,8 @@ impl Executable for ForLoop {
                     //     }
                     // }
 
-                    // // Loops 'consume' breaks.
-                    // interpreter.set_current_state(InterpreterState::Executing);
-                    // break;
+                    interpreter.set_current_state(InterpreterState::Executing);
+                    break;
                 }
                 InterpreterState::Continue(_label) => {
                     // TODO continue to label.
diff --git a/boa/src/exec/labelled_stm/mod.rs b/boa/src/exec/labelled_stm/mod.rs
deleted file mode 100644
index 7e8b22e6e89..00000000000
--- a/boa/src/exec/labelled_stm/mod.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-use crate::{builtins::Value, syntax::ast::node::Label, Executable, Interpreter, Result};
-
-impl Executable for Label {
-    fn run(&self, interpreter: &mut Interpreter) -> Result<Value> {
-        self.stmt.run(interpreter)
-    }
-}
diff --git a/boa/src/exec/mod.rs b/boa/src/exec/mod.rs
index c47111fc435..7f7b9905638 100644
--- a/boa/src/exec/mod.rs
+++ b/boa/src/exec/mod.rs
@@ -9,7 +9,6 @@ mod declaration;
 mod field;
 mod identifier;
 mod iteration;
-mod labelled_stm;
 mod new;
 mod object;
 mod operator;
diff --git a/boa/src/syntax/ast/node/iteration.rs b/boa/src/syntax/ast/node/iteration.rs
index 1265becd811..6f97cca4e54 100644
--- a/boa/src/syntax/ast/node/iteration.rs
+++ b/boa/src/syntax/ast/node/iteration.rs
@@ -21,7 +21,7 @@ use serde::{Deserialize, Serialize};
 pub struct ForLoop {
     #[cfg_attr(feature = "serde", serde(flatten))]
     inner: Box<InnerForLoop>,
-    label: Option<Box<str>>,
+    pub(crate) label: Option<Box<str>>,
 }
 
 impl ForLoop {
diff --git a/boa/src/syntax/ast/node/labelled_smt.rs b/boa/src/syntax/ast/node/labelled_smt.rs
deleted file mode 100644
index d1b0c73a751..00000000000
--- a/boa/src/syntax/ast/node/labelled_smt.rs
+++ /dev/null
@@ -1,34 +0,0 @@
-use super::Node;
-use gc::{Finalize, Trace};
-use std::fmt;
-
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#[derive(Clone, Debug, Trace, Finalize, PartialEq)]
-pub struct Label {
-    pub(crate) stmt: Box<Node>,
-}
-
-impl Label {
-    pub(super) fn display(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", format!("{}", self.stmt))
-    }
-
-    pub fn new(stmt: Node) -> Self {
-        Self { stmt: stmt.into() }
-    }
-}
-
-impl From<Label> for Node {
-    fn from(label_stmt: Label) -> Node {
-        Node::Label(label_stmt)
-    }
-}
-
-impl fmt::Display for Label {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.display(f)
-    }
-}
diff --git a/boa/src/syntax/ast/node/mod.rs b/boa/src/syntax/ast/node/mod.rs
index 9e5ee2f65e0..1645e51a576 100644
--- a/boa/src/syntax/ast/node/mod.rs
+++ b/boa/src/syntax/ast/node/mod.rs
@@ -9,7 +9,6 @@ pub mod expression;
 pub mod field;
 pub mod identifier;
 pub mod iteration;
-pub mod labelled_smt;
 pub mod object;
 pub mod operator;
 pub mod return_smt;
@@ -32,7 +31,6 @@ pub use self::{
     field::{GetConstField, GetField},
     identifier::Identifier,
     iteration::{Continue, DoWhileLoop, ForLoop, WhileLoop},
-    labelled_smt::Label,
     object::Object,
     operator::{Assign, BinOp, UnaryOp},
     return_smt::Return,
@@ -118,9 +116,6 @@ pub enum Node {
     /// An 'if' statement. [More information](./conditional/struct.If.html).
     If(If),
 
-    /// A labelled Statement.
-    Label(Label),
-
     /// A `let` declaration list. [More information](./declaration/struct.LetDeclList.html).
     LetDeclList(LetDeclList),
 
@@ -227,7 +222,6 @@ impl Node {
             Self::WhileLoop(ref while_loop) => while_loop.display(f, indentation),
             Self::DoWhileLoop(ref do_while) => do_while.display(f, indentation),
             Self::If(ref if_smt) => if_smt.display(f, indentation),
-            Self::Label(ref label) => label.display(f),
             Self::Switch(ref switch) => switch.display(f, indentation),
             Self::Object(ref obj) => obj.display(f, indentation),
             Self::ArrayDecl(ref arr) => Display::fmt(arr, f),
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index 6c0c8a6654c..50b3c16a3e0 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -1,7 +1,8 @@
 use super::{LabelIdentifier, Statement};
 use crate::{
+    syntax::ast::Node,
     syntax::{
-        ast::{node::Label, Punctuator},
+        ast::Punctuator,
         parser::{
             cursor::Cursor, error::ParseError, AllowAwait, AllowReturn, AllowYield, TokenParser,
         },
@@ -39,7 +40,7 @@ impl LabelledStatement {
 }
 
 impl TokenParser for LabelledStatement {
-    type Output = Label;
+    type Output = Node;
 
     fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
@@ -47,7 +48,14 @@ impl TokenParser for LabelledStatement {
         cursor.expect(Punctuator::Colon, "Labelled Statement")?;
         let mut stmt =
             Statement::new(self.allow_yield, self.allow_await, self.allow_return).parse(cursor)?;
-        stmt.set_label(name);
-        Ok(Label::new(stmt))
+
+        set_label_for_node(&mut stmt, name);
+        Ok(stmt)
+    }
+}
+
+fn set_label_for_node(stmt: &mut Node, name: Box<str>) {
+    if let Node::ForLoop(ref mut for_loop) = stmt {
+        for_loop.set_label(name)
     }
 }

From d50fcd57eb18a1b08772f4bb802fd4e496f9a755 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 20 Sep 2020 17:12:06 +0100
Subject: [PATCH 07/13] set_label not needed on node anymore

---
 boa/src/syntax/ast/node/mod.rs | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/boa/src/syntax/ast/node/mod.rs b/boa/src/syntax/ast/node/mod.rs
index 1645e51a576..7042451acbc 100644
--- a/boa/src/syntax/ast/node/mod.rs
+++ b/boa/src/syntax/ast/node/mod.rs
@@ -238,14 +238,6 @@ impl Node {
             Self::ConstDeclList(ref decl) => Display::fmt(decl, f),
         }
     }
-
-    // https://tc39.es/ecma262/#sec-labelled-statements
-    // Labels can be set on any statement
-    pub fn set_label(&mut self, label: Box<str>) {
-        if let Self::ForLoop(ref mut for_loop) = *self {
-            for_loop.set_label(label);
-        }
-    }
 }
 
 /// Utility to join multiple Nodes into a single string.

From ace55addc7cd16232235f11e5cc0e044222f013a Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 20 Sep 2020 18:08:14 +0100
Subject: [PATCH 08/13] rebase on master

---
 boa/src/exec/iteration/mod.rs                       | 10 +++-------
 boa/src/syntax/parser/statement/labelled_stm/mod.rs |  9 +++++++--
 boa/src/syntax/parser/statement/mod.rs              | 10 +++-------
 3 files changed, 13 insertions(+), 16 deletions(-)

diff --git a/boa/src/exec/iteration/mod.rs b/boa/src/exec/iteration/mod.rs
index 9161554aac8..ee19ec3f8e3 100644
--- a/boa/src/exec/iteration/mod.rs
+++ b/boa/src/exec/iteration/mod.rs
@@ -43,7 +43,9 @@ impl Executable for ForLoop {
                             if stmt_label.to_string() != *brk_label {
                                 break;
                             } else {
-                                interpreter.set_current_state(InterpreterState::Executing);
+                                interpreter
+                                    .executor()
+                                    .set_current_state(InterpreterState::Executing);
                                 break;
                             }
                         }
@@ -54,12 +56,6 @@ impl Executable for ForLoop {
                         .executor()
                         .set_current_state(InterpreterState::Executing);
                     break;
-                    //         }
-                    //     }
-                    // }
-
-                    interpreter.set_current_state(InterpreterState::Executing);
-                    break;
                 }
                 InterpreterState::Continue(_label) => {
                     // TODO continue to label.
diff --git a/boa/src/syntax/parser/statement/labelled_stm/mod.rs b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
index 50b3c16a3e0..231a5c0b8a1 100644
--- a/boa/src/syntax/parser/statement/labelled_stm/mod.rs
+++ b/boa/src/syntax/parser/statement/labelled_stm/mod.rs
@@ -1,3 +1,5 @@
+use std::io::Read;
+
 use super::{LabelIdentifier, Statement};
 use crate::{
     syntax::ast::Node,
@@ -39,10 +41,13 @@ impl LabelledStatement {
     }
 }
 
-impl TokenParser for LabelledStatement {
+impl<R> TokenParser<R> for LabelledStatement
+where
+    R: Read,
+{
     type Output = Node;
 
-    fn parse(self, cursor: &mut Cursor<'_>) -> Result<Self::Output, ParseError> {
+    fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Label", "Parsing");
         let name = LabelIdentifier::new(self.allow_yield, self.allow_await).parse(cursor)?;
         cursor.expect(Punctuator::Colon, "Labelled Statement")?;
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 8fa27e85f63..961c372dbbe 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -105,7 +105,7 @@ where
     fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Statement", "Parsing");
         // TODO: add BreakableStatement and divide Whiles, fors and so on to another place.
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
+        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.to_owned();
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::If) => {
@@ -176,11 +176,8 @@ where
             // if not fall back to ExpressionStatement
             TokenKind::Identifier(_)
                 if matches!(
-                    cursor.peek(1),
-                    Some(Token {
-                        kind: TokenKind::Punctuator(Punctuator::Colon),
-                        ..
-                    })
+                    cursor.peek(1)?.ok_or(ParseError::AbruptEnd)?.kind(),
+                    TokenKind::Punctuator(Punctuator::Colon)
                 ) =>
             {
                 LabelledStatement::new(self.allow_yield, self.allow_await, self.allow_return)
@@ -188,7 +185,6 @@ where
                     .map(Node::from)
             }
 
-            // TODO: https://tc39.es/ecma262/#prod-LabelledStatement
             _ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor),
         }
     }

From 9b0bac59fc5d16084eb97f27b3e982bf620053b9 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 20 Sep 2020 18:32:00 +0100
Subject: [PATCH 09/13] addition of test

---
 boa/src/exec/iteration/tests.rs | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/boa/src/exec/iteration/tests.rs b/boa/src/exec/iteration/tests.rs
index 864665b3af4..0cfa919525e 100644
--- a/boa/src/exec/iteration/tests.rs
+++ b/boa/src/exec/iteration/tests.rs
@@ -59,7 +59,7 @@ fn for_loop_return() {
             }
         }
     }
-      
+
     foo();
     "#;
 
@@ -191,3 +191,22 @@ fn do_while_loop_continue() {
     "#;
     assert_eq!(&exec(scenario), "[ 1, 2 ]");
 }
+
+#[test]
+fn for_loop_break_label() {
+    let scenario = r#"
+        var str = "";
+
+        loop1: for (let i = 0; i < 5; i++) {
+            loop2: for (let b = 0; b < 5; b++) {
+                if (b === 2) {
+                break loop1;
+                }
+                str = str + b;
+            }
+            str = str + i;
+        }
+        str;
+    "#;
+    assert_eq!(&exec(scenario), "\"01\"")
+}

From fb11b15de3fc0c55ad302b3d5b74cd9dbfe48b1d Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 20 Sep 2020 18:35:00 +0100
Subject: [PATCH 10/13] adding back copy

---
 boa/src/syntax/parser/statement/iteration/for_statement.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/boa/src/syntax/parser/statement/iteration/for_statement.rs b/boa/src/syntax/parser/statement/iteration/for_statement.rs
index b950f265109..8e53392fb73 100644
--- a/boa/src/syntax/parser/statement/iteration/for_statement.rs
+++ b/boa/src/syntax/parser/statement/iteration/for_statement.rs
@@ -34,7 +34,7 @@ use std::io::Read;
 ///
 /// [mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for
 /// [spec]: https://tc39.es/ecma262/#sec-for-statement
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy)]
 pub(in crate::syntax::parser::statement) struct ForStatement {
     allow_yield: AllowYield,
     allow_await: AllowAwait,

From 1848798333ea93f79e238cd8682760934b70789d Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Sun, 20 Sep 2020 19:13:36 +0100
Subject: [PATCH 11/13] peek_expect_no_lineterminator

---
 boa/src/syntax/parser/statement/mod.rs | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 961c372dbbe..cd62b8b3e56 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -175,10 +175,11 @@ where
             // Create guard to check if the next token is a `:` then we know we're sitting on a label
             // if not fall back to ExpressionStatement
             TokenKind::Identifier(_)
-                if matches!(
-                    cursor.peek(1)?.ok_or(ParseError::AbruptEnd)?.kind(),
-                    TokenKind::Punctuator(Punctuator::Colon)
-                ) =>
+                if cursor.peek_expect_no_lineterminator(1).is_ok()
+                    && matches!(
+                        cursor.peek_expect_no_lineterminator(1)?.kind(),
+                        TokenKind::Punctuator(Punctuator::Colon)
+                    ) =>
             {
                 LabelledStatement::new(self.allow_yield, self.allow_await, self.allow_return)
                     .parse(cursor)

From 9a98fab559f34f7caa08546be2d2d59f01c256b1 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Mon, 21 Sep 2020 19:45:09 +0100
Subject: [PATCH 12/13] check for label before running expression

---
 boa/src/exec/iteration/tests.rs        |  2 +-
 boa/src/syntax/parser/statement/mod.rs | 32 +++++++++++++++-----------
 2 files changed, 20 insertions(+), 14 deletions(-)

diff --git a/boa/src/exec/iteration/tests.rs b/boa/src/exec/iteration/tests.rs
index 0cfa919525e..5c55c580dda 100644
--- a/boa/src/exec/iteration/tests.rs
+++ b/boa/src/exec/iteration/tests.rs
@@ -206,7 +206,7 @@ fn for_loop_break_label() {
             }
             str = str + i;
         }
-        str;
+        str
     "#;
     assert_eq!(&exec(scenario), "\"01\"")
 }
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index cd62b8b3e56..95ed6feae72 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -38,7 +38,7 @@ use self::{
 
 use super::{AllowAwait, AllowReturn, AllowYield, Cursor, ParseError, TokenParser};
 
-use crate::syntax::lexer::TokenKind;
+use crate::syntax::lexer::{InputElement, TokenKind};
 use crate::{
     syntax::ast::{node, Keyword, Node, Punctuator},
     BoaProfiler,
@@ -105,7 +105,7 @@ where
     fn parse(self, cursor: &mut Cursor<R>) -> Result<Self::Output, ParseError> {
         let _timer = BoaProfiler::global().start_event("Statement", "Parsing");
         // TODO: add BreakableStatement and divide Whiles, fors and so on to another place.
-        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?.to_owned();
+        let tok = cursor.peek(0)?.ok_or(ParseError::AbruptEnd)?;
 
         match tok.kind() {
             TokenKind::Keyword(Keyword::If) => {
@@ -172,21 +172,27 @@ where
                     .parse(cursor)
                     .map(Node::from)
             }
-            // Create guard to check if the next token is a `:` then we know we're sitting on a label
-            // if not fall back to ExpressionStatement
-            TokenKind::Identifier(_)
-                if cursor.peek_expect_no_lineterminator(1).is_ok()
+            _ => {
+                // Before falling to expression check for a label
+                cursor.set_goal(InputElement::Div);
+                let tok = cursor.peek(1)?;
+                if tok.is_some()
                     && matches!(
-                        cursor.peek_expect_no_lineterminator(1)?.kind(),
+                        tok.unwrap().kind(),
                         TokenKind::Punctuator(Punctuator::Colon)
-                    ) =>
-            {
-                LabelledStatement::new(self.allow_yield, self.allow_await, self.allow_return)
+                    )
+                {
+                    return LabelledStatement::new(
+                        self.allow_yield,
+                        self.allow_await,
+                        self.allow_return,
+                    )
                     .parse(cursor)
-                    .map(Node::from)
-            }
+                    .map(Node::from);
+                }
 
-            _ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor),
+                ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor)
+            }
         }
     }
 }

From 1b700691a1775b1f94582adc0689363eb64aa7f8 Mon Sep 17 00:00:00 2001
From: jasonwilliams <jase.williams@gmail.com>
Date: Tue, 22 Sep 2020 19:03:03 +0100
Subject: [PATCH 13/13] moving into Identifier check

---
 boa/src/exec/tests.rs                  | 2 +-
 boa/src/syntax/parser/statement/mod.rs | 6 ++++--
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/boa/src/exec/tests.rs b/boa/src/exec/tests.rs
index 246fbe6c59a..2e3f3211dcd 100644
--- a/boa/src/exec/tests.rs
+++ b/boa/src/exec/tests.rs
@@ -1330,7 +1330,7 @@ fn assign_to_object_decl() {
     let mut engine = Context::new();
 
     const ERR_MSG: &str =
-        "Uncaught \"SyntaxError\": \"expected token \';\', got \':\' in expression statement at line 1, col 3\"";
+        "Uncaught \"SyntaxError\": \"unexpected token '=', primary expression at line 1, col 8\"";
 
     assert_eq!(forward(&mut engine, "{a: 3} = {a: 5};"), ERR_MSG);
 }
diff --git a/boa/src/syntax/parser/statement/mod.rs b/boa/src/syntax/parser/statement/mod.rs
index 95ed6feae72..08b419f4d11 100644
--- a/boa/src/syntax/parser/statement/mod.rs
+++ b/boa/src/syntax/parser/statement/mod.rs
@@ -172,8 +172,8 @@ where
                     .parse(cursor)
                     .map(Node::from)
             }
-            _ => {
-                // Before falling to expression check for a label
+            TokenKind::Identifier(_) => {
+                // Labelled Statement check
                 cursor.set_goal(InputElement::Div);
                 let tok = cursor.peek(1)?;
                 if tok.is_some()
@@ -193,6 +193,8 @@ where
 
                 ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor)
             }
+
+            _ => ExpressionStatement::new(self.allow_yield, self.allow_await).parse(cursor),
         }
     }
 }