fix(interpreter): fix side-effects on type-info icalls

Author: Alonely0

interpreter/src/builtins.rs

@@ -256,7 +256,8 @@ fn typeof_value<'a>(v: &Value<'_>) -> Value<'a> {
         Value::String(_) => b"string",
         Value::Regex(_) => b"regexp",
         Value::Array(_) => b"array",
-        Value::Untyped | Value::Unassigned => b"untyped",
+        Value::Untyped => b"untyped",
+        Value::Unassigned => b"unassigned",
     };
     Value::String(name.into())
 }

interpreter/src/ir.rs

@@ -69,6 +69,7 @@ pub enum Instruction {
     StoreR { dest: Reg, src: Arg, arg: Arg, ty: ArgTy, tys: ArgTy },
     StoreA { dest: Reg, ty_place: ArgTy, start: Reg, end: Reg, var: NonLocal, arg: Reg },
     LoadA { dest: Reg, ty_place: ArgTy, start: Reg, end: Reg, var: NonLocal },
+    PureCopy { dest: Reg, arg: Arg, ty: ArgTy },
     IntrinsicCall { dest: Reg, start: Reg, end: Reg, fun: BuiltinFunction },
     OutputCall { start: Reg, end: Reg, cmd: Command, redir: Option<Redirection> },
     UserCall { dest: Reg, start: Reg, end: Reg, name: NonLocal },
@@ -206,7 +207,8 @@ impl Display for Instruction {
             | Self::Negation { dest, arg, ty }
             | Self::ToInt { dest, arg, ty }
             | Self::Negative { dest, arg, ty }
-            | Self::Copy { dest, arg, ty } => {
+            | Self::Copy { dest, arg, ty }
+            | Self::PureCopy { dest, arg, ty } => {
                 write!(f, "{dest} <- {op}")?;
                 fmt_arg(f, arg, ty, " ")
             }
@@ -316,6 +318,7 @@ impl Instruction {
             Self::StoreA { .. } => "astore",
             Self::LoadA { .. } => "aload",
             Self::Copy { .. } => "cpy",
+            Self::PureCopy { .. } => "pcpy",
             Self::IntrinsicCall { .. } => "icall",
             Self::UserCall { .. } => "ucall",
             Self::IndirectCall { .. } => "vcall",

interpreter/src/ir/lower.rs

@@ -8,9 +8,9 @@ use std::{borrow::Cow, mem::forget, ops::Deref, vec::Vec as StdVec};
 use bumpalo::{Bump, collections::Vec};
 use either::Either;
 use parser::{
-    ArrayOperator, Ast, Atom, BinaryOperator, BinaryPlaceOperator, Body, Command, Expr, ExprNode,
-    Function as AstFunction, FunctionTable, Identifier, MetaId, Place, Rule, RulePattern,
-    SimpleStatement, Statement, UnaryOperator, UnaryPlaceOperator, Variable,
+    ArrayOperator, Ast, Atom, BinaryOperator, BinaryPlaceOperator, Body, BuiltinFunction, Command,
+    Expr, ExprNode, Function as AstFunction, FunctionTable, Identifier, MetaId, Place, Rule,
+    RulePattern, SimpleStatement, Statement, UnaryOperator, UnaryPlaceOperator, Variable,
 };
 
 use crate::{
@@ -654,7 +654,31 @@ impl<'a> CodeGen<'a> {
                             this.emit(Instruction::UserCall { dest, start, end, name });
                         }
                         ExprNode::BuiltinCall(fun, args) => {
-                            let (start, end, ()) = this.gen_call_convention(args, |_| ());
+                            // Bypass regular variable lookups on type-info funs.
+                            let (start, end, _) = match fun {
+                                BuiltinFunction::Typeof | BuiltinFunction::Isarray
+                                    if let &[Expr::Leaf(Atom::Variable(var), _)] =
+                                        args.as_slice() =>
+                                {
+                                    let TypedArg(arg, ty) =
+                                        this.load_place(dest, &Place::Variable(var));
+                                    this.emit(Instruction::PureCopy { dest, arg, ty });
+                                    (dest, Reg(dest.0 + 1), ())
+                                }
+                                BuiltinFunction::Typeof | BuiltinFunction::Isarray
+                                    if let [expr] = args.as_slice() =>
+                                {
+                                    this.lower_expr_into(expr, dest);
+                                    (dest, Reg(dest.0 + 1), ())
+                                }
+                                BuiltinFunction::Typeof
+                                    if let &[Expr::Leaf(Atom::Variable(_var), _), ref _arg2] =
+                                        args.as_slice() =>
+                                {
+                                    todo!()
+                                }
+                                _ => this.gen_call_convention(args, |_| ()),
+                            };
                             this.emit(Instruction::IntrinsicCall { dest, start, end, fun: *fun });
                         }
                         ExprNode::IndirectCall(place, args) => {

interpreter/src/vm.rs

@@ -320,7 +320,7 @@ impl<'a> SymbolTable<'a> {
             .borrow()
             .get(key)
             .cloned()
-            .unwrap_or(Value::Unassigned)
+            .unwrap_or(Value::Untyped)
     }
 
     fn store_user_array_elem(&mut self, var: NonLocal, key: String, value: Value<'a>) {
@@ -443,6 +443,10 @@ impl<'a> Interpreter<'a> {
                     let val = arg.get_val(ty, self, &mut MaybeUninit::uninit()).clone();
                     self.write_reg(dest, val);
                 }
+                Instruction::PureCopy { dest, arg, ty } => {
+                    let val = arg.get_pure(ty, self, &mut MaybeUninit::uninit()).clone();
+                    self.write_reg(dest, val);
+                }
                 Instruction::Eq { dest, lhs, rhs, tyl, tyr } => {
                     let val = Arg::get_val2(lhs, tyl, rhs, tyr, self, |lhs, rhs| lhs == rhs);
                     self.write_reg(dest, val);
@@ -841,6 +845,23 @@ impl Arg {
         f(lhs, rhs)
     }
 
+    /// Gets a value without scalar/array side-effects.
+    fn get_pure<'v, 'a>(
+        self,
+        ty: ArgTy,
+        intrp: &'v Interpreter<'a>,
+        stack_space: &'v mut MaybeUninit<Value<'a>>,
+    ) -> &'v Value<'a> {
+        match ty {
+            ArgTy::Reg => intrp.read_reg(unsafe { self.reg }),
+            ArgTy::Rec => todo!(),
+            ArgTy::Imm => stack_space.write(Value::Int(unsafe { self.imm } as _)),
+            ArgTy::Cnt | ArgTy::ImmF => &intrp.consts.0[unsafe { self.sym.0 } as usize],
+            ArgTy::UsVal => intrp.symbols.raw_user_lookup(unsafe { self.sym }),
+            _ => todo!(),
+        }
+    }
+
     /// Only exists to make the borrow checker happy. To be used in conjunction
     /// w/ [`Self::read_already_prepared`]. Please, don't use either of these if
     /// you can help it; use [`Self::get_val`] or [`Self::get_val2`] instead.