Refactor Context::run()

boa-dev · Oct 17, 2023 · 6d9a22f · 6d9a22f
1 parent 217b17b
commit 6d9a22f
Showing 1 changed file with 53 additions and 72 deletions.
diff --git a/boa_engine/src/vm/mod.rs b/boa_engine/src/vm/mod.rs
@@ -398,65 +398,8 @@ impl Context<'_> {
             #[cfg(not(feature = "trace"))]
             let result = self.execute_instruction();
 
-            match result {
-                Ok(CompletionType::Normal) => {}
-                Ok(CompletionType::Return) => {
-                    self.vm.stack.truncate(self.vm.frame().fp as usize);
-
-                    let result = self.vm.take_return_value();
-                    if self.vm.frame().exit_early() {
-                        return CompletionRecord::Normal(result);
-                    }
-
-                    self.vm.push(result);
-                    self.vm.pop_frame();
-                }
-                Ok(CompletionType::Throw) => {
-                    self.vm.stack.truncate(self.vm.frame().fp as usize);
-
-                    if self.vm.frame().exit_early() {
-                        return CompletionRecord::Throw(
-                            self.vm
-                                .pending_exception
-                                .take()
-                                .expect("Err must exist for a CompletionType::Throw"),
-                        );
-                    }
-
-                    self.vm.pop_frame();
-
-                    while let Some(frame) = self.vm.frames.last_mut() {
-                        let pc = frame.pc;
-                        let fp = frame.fp;
-                        let exit_early = frame.exit_early();
-
-                        if self.vm.handle_exception_at(pc) {
-                            continue 'instruction;
-                        }
-
-                        if exit_early {
-                            return CompletionRecord::Throw(
-                                self.vm
-                                    .pending_exception
-                                    .take()
-                                    .expect("Err must exist for a CompletionType::Throw"),
-                            );
-                        }
-
-                        self.vm.stack.truncate(fp as usize);
-                        self.vm.pop_frame();
-                    }
-                }
-                // Early return immediately.
-                Ok(CompletionType::Yield) => {
-                    let result = self.vm.take_return_value();
-                    if self.vm.frame().exit_early() {
-                        return CompletionRecord::Return(result);
-                    }
-
-                    self.vm.push(result);
-                    self.vm.pop_frame();
-                }
+            let result = match result {
+                Ok(result) => result,
                 Err(err) => {
                     if let Some(native_error) = err.as_native() {
                         // If we hit the execution step limit, bubble up the error to the
@@ -497,38 +440,76 @@ impl Context<'_> {
                         continue;
                     }
 
+                    // Inject realm before crossing the function boundry
+                    let err = err.inject_realm(self.realm().clone());
+
+                    self.vm.pending_exception = Some(err);
+                    CompletionType::Throw
+                }
+            };
+
+            match result {
+                CompletionType::Normal => {}
+                CompletionType::Return => {
+                    self.vm.stack.truncate(self.vm.frame().fp as usize);
+
+                    let result = self.vm.take_return_value();
                     if self.vm.frame().exit_early() {
-                        self.vm
-                            .environments
-                            .truncate(self.vm.frame().env_fp as usize);
-                        self.vm.stack.truncate(self.vm.frame().fp as usize);
-                        return CompletionRecord::Throw(err);
+                        return CompletionRecord::Normal(result);
                     }
 
-                    // Inject realm before crossing the function boundry
-                    let err = err.inject_realm(self.realm().clone());
+                    self.vm.push(result);
+                    self.vm.pop_frame();
+                }
+                CompletionType::Throw => {
+                    let mut fp = self.vm.frame().fp;
+                    let mut env_fp = self.vm.frame().env_fp;
+                    if self.vm.frame().exit_early() {
+                        self.vm.environments.truncate(env_fp as usize);
+                        self.vm.stack.truncate(fp as usize);
+                        return CompletionRecord::Throw(
+                            self.vm
+                                .pending_exception
+                                .take()
+                                .expect("Err must exist for a CompletionType::Throw"),
+                        );
+                    }
 
                     self.vm.pop_frame();
 
                     while let Some(frame) = self.vm.frames.last_mut() {
+                        fp = frame.fp;
+                        env_fp = frame.fp;
                         let pc = frame.pc;
-                        let fp = frame.fp;
-                        let env_fp = frame.env_fp;
                         let exit_early = frame.exit_early();
 
                         if self.vm.handle_exception_at(pc) {
-                            self.vm.pending_exception = Some(err);
                             continue 'instruction;
                         }
 
                         if exit_early {
-                            return CompletionRecord::Throw(err);
+                            return CompletionRecord::Throw(
+                                self.vm
+                                    .pending_exception
+                                    .take()
+                                    .expect("Err must exist for a CompletionType::Throw"),
+                            );
                         }
 
-                        self.vm.environments.truncate(env_fp as usize);
-                        self.vm.stack.truncate(fp as usize);
                         self.vm.pop_frame();
                     }
+                    self.vm.environments.truncate(env_fp as usize);
+                    self.vm.stack.truncate(fp as usize);
+                }
+                // Early return immediately.
+                CompletionType::Yield => {
+                    let result = self.vm.take_return_value();
+                    if self.vm.frame().exit_early() {
+                        return CompletionRecord::Return(result);
+                    }
+
+                    self.vm.push(result);
+                    self.vm.pop_frame();
                 }
             }
         }