Add variable-to-variable assignment

demo/demo.rpy

@@ -6,7 +6,9 @@ if True:
     "Bob will be here in [x] seconds."
     if True:
         x = "1"
-        let x = "4"
+        let y = "4"
+        y = "5"
+        x = y
         "[x]"
     "Bob will be here in [x] seconds."
 "Bob will be here in [x] seconds."

renrs/src/parser/block.rs

@@ -37,62 +37,65 @@ impl CommandContext {
                     assign_type,
                     variable,
                     value,
-                } => match assign_type {
+                } => {
-                    Define => panic!("define command should not be executed at runtime!"),
+                    let value = if let Token::Keyword(keyword) = value {
-                    GlobalAssign => {
-                        if let Token::Keyword(_) = value {
-                            todo!("assignment variable interpolation isn't implemented");
-                        }
-                        let root = self.context.borrow().get_root(&self.context);
-                        // Don't want to re-borrow if root is self
-                        let root = if Rc::ptr_eq(&self.context, &root) {
-                            &self.context
-                        } else {
-                            &root
-                        };
-                        root.borrow_mut()
-                            .variables
-                            .as_ref()
-                            .borrow_mut()
-                            .insert(variable.clone(), value.clone());
-                        return None;
-                    }
-                    Let => {
-                        if let Token::Keyword(_) = value {
-                            todo!("assignment variable interpolation isn't implemented");
-                        }
                         self.context
                             .borrow()
-                            .variables
+                            .get_variables()
-                            .borrow_mut()
+                            .get(keyword)
-                            .insert(variable.clone(), value.clone());
+                            .unwrap_or_else(|| panic!("undefined variable `{keyword}`"))
-                        return None;
+                            .clone()
-                    }
+                    } else {
-                    Assign => {
+                        value.clone()
-                        if let Token::Keyword(_) = value {
+                    };
-                            todo!("assignment variable interpolation isn't implemented");
+                    match assign_type {
+                        Define => panic!("define command should not be executed at runtime!"),
+                        GlobalAssign => {
+                            let root = self.context.borrow().get_root(&self.context);
+                            // Don't want to re-borrow if root is self
+                            let root = if Rc::ptr_eq(&self.context, &root) {
+                                &self.context
+                            } else {
+                                &root
+                            };
+                            root.borrow_mut()
+                                .variables
+                                .as_ref()
+                                .borrow_mut()
+                                .insert(variable.clone(), value.clone());
+                            return None;
                         }
-                        let mut block_option = Some(self.context.clone());
+                        Let => {
-                        let mut modified = false;
+                            self.context
-                        while let Some(block) = block_option {
+                                .borrow()
-                            let block = block.borrow();
-                            block
                                 .variables
                                 .borrow_mut()
-                                .entry(variable.clone())
+                                .insert(variable.clone(), value.clone());
-                                .and_modify(|e| {
+                            return None;
-                                    *e = value.clone();
-                                    modified = true;
-                                });
-                            if modified {
-                                break;
-                            }
-                            block_option = block.parent.clone();
                         }
-                        if !modified {
+                        Assign => {
-                            panic!("undefined variable `{variable}`");
+                            let mut block_option = Some(self.context.clone());
+                            let mut modified = false;
+                            while let Some(block) = block_option {
+                                let block = block.borrow();
+                                block
+                                    .variables
+                                    .borrow_mut()
+                                    .entry(variable.clone())
+                                    .and_modify(|e| {
+                                        *e = value.clone();
+                                        modified = true;
+                                    });
+                                if modified {
+                                    break;
+                                }
+                                block_option = block.parent.clone();
+                            }
+                            if !modified {
+                                panic!("undefined variable `{variable}`");
+                            }
+                            return None;
                         }
-                        return None;
                     }
                 },
                 Eat { .. } => return None,