just-bash 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

just_bash/interpreter/interpreter.py

@@ -41,7 +41,7 @@ from .errors import (
     NounsetError,
     ReturnError,
 )
-from .types import InterpreterContext, InterpreterState, ShellOptions
+from .types import InterpreterContext, InterpreterState, ShellOptions, VariableStore, FDTable
 from .expansion import expand_word_async, expand_word_with_glob, get_variable, evaluate_arithmetic
 from .conditionals import evaluate_conditional
 from .control_flow import (
@@ -80,6 +80,17 @@ def _is_shopt_set(env: dict[str, str], name: str) -> bool:
     return DEFAULT_SHOPTS.get(name, False)
 
 
+def _word_has_quoting(word) -> bool:
+    """Check if a word contains any quoting (single, double, or escape)."""
+    from ..ast.types import SingleQuotedPart, DoubleQuotedPart, EscapedPart
+    if word is None or not hasattr(word, 'parts'):
+        return False
+    for part in word.parts:
+        if isinstance(part, (SingleQuotedPart, DoubleQuotedPart, EscapedPart)):
+            return True
+    return False
+
+
 class Interpreter:
     """AST interpreter for bash scripts."""
 
@@ -102,14 +113,14 @@ class Interpreter:
         self._commands = commands
         self._limits = limits
         self._state = state or InterpreterState(
-            env={
+            env=VariableStore({
                 "PATH": "/usr/local/bin:/usr/bin:/bin",
                 "HOME": "/home/user",
                 "USER": "user",
                 "SHELL": "/bin/bash",
                 "PWD": "/home/user",
                 "?": "0",
-            },
+            }),
             cwd="/home/user",
             previous_dir="/home/user",
             start_time=time.time(),
@@ -147,7 +158,9 @@ class Interpreter:
 
         # Create a new state for the subshell if env/cwd are provided
         if env or cwd:
-            new_env = {**self._state.env, **(env or {})}
+            new_env = self._state.env.copy() if isinstance(self._state.env, VariableStore) else VariableStore(self._state.env)
+            if env:
+                new_env.update(env)
             new_state = InterpreterState(
                 env=new_env,
                 cwd=cwd or self._state.cwd,
@@ -161,6 +174,7 @@ class Interpreter:
                     xtrace=self._state.options.xtrace,
                     verbose=self._state.options.verbose,
                 ),
+                fd_table=self._state.fd_table.clone(),
             )
             sub_interpreter = Interpreter(
                 fs=self._fs,
@@ -300,7 +314,10 @@ class Interpreter:
 
     async def execute_pipeline(self, node: PipelineNode) -> ExecResult:
         """Execute a pipeline AST node."""
-        stdin = ""
+        # Use group_stdin for the first command if we're inside a group
+        stdin = self._state.group_stdin or ""
+        # Clear group_stdin after first use so it's not reused
+        self._state.group_stdin = ""
         last_result = _ok()
         pipefail_exit_code = 0
         pipestatus_exit_codes: list[int] = []
@@ -403,7 +420,7 @@ class Interpreter:
         """Execute a subshell command."""
         # Create a new interpreter with a copy of the state
         new_state = InterpreterState(
-            env=dict(self._state.env),
+            env=self._state.env.copy() if isinstance(self._state.env, VariableStore) else VariableStore(self._state.env),
             cwd=self._state.cwd,
             previous_dir=self._state.previous_dir,
             functions=dict(self._state.functions),
@@ -415,6 +432,7 @@ class Interpreter:
                 xtrace=self._state.options.xtrace,
                 verbose=self._state.options.verbose,
             ),
+            fd_table=self._state.fd_table.clone(),
         )
         sub_interpreter = Interpreter(
             fs=self._fs,
@@ -427,13 +445,25 @@ class Interpreter:
         stdout = ""
         stderr = ""
         exit_code = 0
-        for stmt in node.body:
-            result = await sub_interpreter.execute_statement(stmt)
-            stdout += result.stdout
-            stderr += result.stderr
-            exit_code = result.exit_code
+        try:
+            for stmt in node.body:
+                result = await sub_interpreter.execute_statement(stmt)
+                stdout += result.stdout
+                stderr += result.stderr
+                exit_code = result.exit_code
+        except ExitError as e:
+            # exit inside a subshell only exits the subshell
+            stdout += e.stdout
+            stderr += e.stderr
+            exit_code = e.exit_code
 
-        return _result(stdout, stderr, exit_code)
+        result = _result(stdout, stderr, exit_code)
+
+        # Process output redirections on the subshell
+        if node.redirections:
+            result = await self._process_output_redirections(node.redirections, result)
+
+        return result
 
     async def _execute_group(self, node: GroupNode, stdin: str) -> ExecResult:
         """Execute a command group { ... }."""
@@ -456,7 +486,13 @@ class Interpreter:
         finally:
             self._state.group_stdin = saved_group_stdin
 
-        return _result(stdout, stderr, exit_code)
+        result = _result(stdout, stderr, exit_code)
+
+        # Process output redirections on the group
+        if node.redirections:
+            result = await self._process_output_redirections(node.redirections, result)
+
+        return result
 
     async def _execute_function_def(self, node: FunctionDefNode) -> ExecResult:
         """Execute a function definition."""
@@ -495,8 +531,9 @@ class Interpreter:
         if node.line is not None:
             self._state.current_line = node.line
 
-        # Clear expansion stderr
+        # Clear expansion state
         self._state.expansion_stderr = ""
+        self._state.expansion_exit_code = None
 
         # Temporary assignments for command environment
         temp_assignments: dict[str, str | None] = {}
@@ -505,34 +542,133 @@ class Interpreter:
         for assignment in node.assignments:
             name = assignment.name
 
-            # Check for array assignment
-            if assignment.array:
-                # Clear existing array elements
-                prefix = f"{name}_"
-                to_remove = [k for k in self._state.env if k.startswith(prefix) and not k.startswith(f"{name}__")]
-                for k in to_remove:
-                    del self._state.env[k]
+            # Check for array subscript in name: a[idx]=value
+            import re as _re
+            _array_lhs = _re.match(r'^([a-zA-Z_][a-zA-Z0-9_]*)\[(.+)\]$', name)
 
-                # Mark as array
-                self._state.env[f"{name}__is_array"] = "indexed"
+            # Resolve nameref for array assignment target
+            if (assignment.array
+                    and isinstance(self._state.env, VariableStore)
+                    and self._state.env.is_nameref(name)):
+                try:
+                    name = self._state.env.resolve_nameref(name)
+                except ValueError:
+                    pass
 
-                # Expand and store each element
-                for idx, elem in enumerate(assignment.array):
-                    elem_value = await expand_word_async(self._ctx, elem)
-                    self._state.env[f"{name}_{idx}"] = elem_value
+            # Check for array assignment
+            if assignment.array:
+                if assignment.append:
+                    # a+=(2 3) - append to existing array
+                    # Find next available index
+                    from .expansion import get_array_elements as _get_elems
+                    existing_elems = _get_elems(self._ctx, name)
+                    next_idx = (max(i for i, _ in existing_elems) + 1) if existing_elems else 0
+
+                    # Mark as array if not already
+                    if f"{name}__is_array" not in self._state.env:
+                        self._state.env[f"{name}__is_array"] = "indexed"
+
+                    # Expand and store each new element
+                    for i, elem in enumerate(assignment.array):
+                        elem_value = await expand_word_async(self._ctx, elem)
+                        self._state.env[f"{name}_{next_idx + i}"] = elem_value
+                else:
+                    # a=(1 2 3) - replace array
+                    # Clear existing array elements
+                    prefix = f"{name}_"
+                    to_remove = [k for k in self._state.env if k.startswith(prefix) and not k.startswith(f"{name}__")]
+                    for k in to_remove:
+                        del self._state.env[k]
+
+                    # Mark as array
+                    self._state.env[f"{name}__is_array"] = "indexed"
+
+                    # Expand and store each element, handling [idx]=value syntax
+                    auto_idx = 0
+                    for elem in assignment.array:
+                        elem_value = await expand_word_async(self._ctx, elem)
+                        # Check for [idx]=value syntax (from GlobPart + LiteralPart)
+                        bracket_match = _re.match(r'^\[([^\]]+)\]=(.*)$', elem_value)
+                        if bracket_match:
+                            key = bracket_match.group(1)
+                            val = bracket_match.group(2)
+                            self._state.env[f"{name}_{key}"] = val
+                            try:
+                                auto_idx = int(key) + 1
+                            except ValueError:
+                                pass  # assoc array key
+                        else:
+                            self._state.env[f"{name}_{auto_idx}"] = elem_value
+                            auto_idx += 1
                 continue
 
+            # Resolve nameref for the assignment target
+            if (isinstance(self._state.env, VariableStore)
+                    and not _array_lhs
+                    and self._state.env.is_nameref(name)):
+                try:
+                    name = self._state.env.resolve_nameref(name)
+                except ValueError:
+                    pass
+
             # Expand assignment value
             value = ""
             if assignment.value:
                 value = await expand_word_async(self._ctx, assignment.value)
 
+            # Apply attribute-based transformations
+            if isinstance(self._state.env, VariableStore):
+                attrs = self._state.env.get_attributes(name)
+                if "i" in attrs:
+                    # Integer attribute: evaluate as arithmetic
+                    try:
+                        from .expansion import evaluate_arithmetic_sync
+                        from ..parser.parser import Parser
+                        parser = Parser()
+                        arith_expr = parser._parse_arith_comma(value)
+                        value = str(evaluate_arithmetic_sync(self._ctx, arith_expr))
+                    except Exception:
+                        try:
+                            value = str(int(value))
+                        except ValueError:
+                            value = "0"
+                if "l" in attrs:
+                    value = value.lower()
+                elif "u" in attrs:
+                    value = value.upper()
+
             if node.name is None:
                 # Assignment-only command - set in environment
-                if assignment.append:
+                if _array_lhs:
+                    # a[idx]=value or a[idx]+=value
+                    arr_name = _array_lhs.group(1)
+                    subscript = _array_lhs.group(2)
+                    # Resolve nameref for array base name
+                    if isinstance(self._state.env, VariableStore) and self._state.env.is_nameref(arr_name):
+                        try:
+                            arr_name = self._state.env.resolve_nameref(arr_name)
+                        except ValueError:
+                            pass
+                    # Mark as array if not already
+                    if f"{arr_name}__is_array" not in self._state.env:
+                        self._state.env[f"{arr_name}__is_array"] = "indexed"
+                    if assignment.append:
+                        existing = self._state.env.get(f"{arr_name}_{subscript}", "")
+                        self._state.env[f"{arr_name}_{subscript}"] = existing + value
+                    else:
+                        self._state.env[f"{arr_name}_{subscript}"] = value
+                elif assignment.append:
                     existing = self._state.env.get(name, "")
                     self._state.env[name] = existing + value
                 else:
+                    # Special handling for SECONDS - reset timer
+                    if name == "SECONDS":
+                        import time
+                        try:
+                            offset = int(value)
+                            self._state.seconds_reset_time = time.time() - offset
+                        except (ValueError, TypeError):
+                            self._state.seconds_reset_time = time.time()
                     self._state.env[name] = value
             else:
                 # Temporary assignment for command
@@ -559,17 +695,39 @@ class Interpreter:
                         lines = heredoc_content.split("\n")
                         heredoc_content = "\n".join(line.lstrip("\t") for line in lines)
                     stdin = heredoc_content
+            elif redir.operator == "<<<":
+                # Here-string: expand the word and use as stdin with trailing newline
+                if redir.target is not None and isinstance(redir.target, WordNode):
+                    herestring_content = await expand_word_async(self._ctx, redir.target)
+                    stdin = herestring_content + "\n"
             elif redir.operator == "<":
-                # Input redirection: read file content into stdin
+                # Input redirection: read file content
+                fd = redir.fd if redir.fd is not None else 0
                 if redir.target is not None and isinstance(redir.target, WordNode):
                     target_path = await expand_word_async(self._ctx, redir.target)
                     target_path = self._fs.resolve_path(self._state.cwd, target_path)
                     try:
-                        stdin = await self._fs.read_file(target_path)
+                        file_content = await self._fs.read_file(target_path)
                     except FileNotFoundError:
                         return _failure(f"bash: {target_path}: No such file or directory\n")
                     except IsADirectoryError:
                         return _failure(f"bash: {target_path}: Is a directory\n")
+                    if fd == 0:
+                        stdin = file_content
+                    else:
+                        # Custom FD input redirect - store in FD table
+                        self._state.fd_table.open(fd, target_path, "r")
+                        self._state.fd_table._fds[fd].content = file_content
+            elif redir.operator == "<&":
+                # Input FD duplication
+                fd = redir.fd if redir.fd is not None else 0
+                if redir.target is not None and isinstance(redir.target, WordNode):
+                    target_str = await expand_word_async(self._ctx, redir.target)
+                    if target_str == "-":
+                        self._state.fd_table.close(fd)
+                    elif target_str.isdigit():
+                        target_fd = int(target_str)
+                        self._state.fd_table.dup(target_fd, fd)
 
         try:
             # Expand command name
@@ -579,18 +737,37 @@ class Interpreter:
             alias_args: list[str] = []
             if _is_shopt_set(self._state.env, "expand_aliases"):
                 aliases = get_aliases(self._ctx)
-                if cmd_name in aliases:
-                    alias_value = aliases[cmd_name]
-                    # Simple word splitting for alias value
-                    import shlex
-                    try:
-                        alias_parts = shlex.split(alias_value)
-                    except ValueError:
-                        # Fall back to simple split if shlex fails
-                        alias_parts = alias_value.split()
-                    if alias_parts:
-                        cmd_name = alias_parts[0]
-                        alias_args = alias_parts[1:]
+                # Don't expand if command name was quoted
+                name_is_quoted = _word_has_quoting(node.name) if node.name else False
+                if not name_is_quoted and cmd_name in aliases:
+                    expanded_aliases: set[str] = set()
+                    trailing_space = False
+                    while cmd_name in aliases and cmd_name not in expanded_aliases:
+                        expanded_aliases.add(cmd_name)
+                        alias_value = aliases[cmd_name]
+                        # Check if alias value ends with whitespace (triggers next-word expansion)
+                        trailing_space = alias_value.endswith((" ", "\t"))
+                        # Simple word splitting for alias value
+                        import shlex
+                        try:
+                            alias_parts = shlex.split(alias_value)
+                        except ValueError:
+                            alias_parts = alias_value.split()
+                        if alias_parts:
+                            cmd_name = alias_parts[0]
+                            alias_args = alias_parts[1:] + alias_args
+                    # Trailing space: alias-expand first argument too
+                    if trailing_space and node.args and aliases:
+                        first_arg = await expand_word_async(self._ctx, node.args[0])
+                        if not _word_has_quoting(node.args[0]) and first_arg in aliases:
+                            arg_alias_value = aliases[first_arg]
+                            import shlex
+                            try:
+                                arg_parts = shlex.split(arg_alias_value)
+                            except ValueError:
+                                arg_parts = arg_alias_value.split()
+                            if arg_parts:
+                                alias_args.extend(arg_parts)
 
             # Check for function call first (functions override builtins)
             if cmd_name in self._state.functions:
@@ -606,6 +783,14 @@ class Interpreter:
                 expanded = await expand_word_with_glob(self._ctx, arg)
                 args.extend(expanded["values"])
 
+            # Check for expansion errors (e.g., failglob)
+            if self._state.expansion_exit_code is not None:
+                exit_code = self._state.expansion_exit_code
+                stderr = self._state.expansion_stderr
+                self._state.expansion_exit_code = None
+                self._state.expansion_stderr = ""
+                return _result("", stderr, exit_code)
+
             # Update last arg for $_
             if args:
                 self._state.last_arg = args[-1]
@@ -616,6 +801,12 @@ class Interpreter:
                 # Create command context
                 from ..types import CommandContext
 
+                # Collect custom FD contents for commands
+                fd_contents: dict[int, str] = {}
+                for fd_num, fd_entry in self._state.fd_table._fds.items():
+                    if fd_num >= 3 and not fd_entry.is_closed:
+                        fd_contents[fd_num] = fd_entry.content
+
                 ctx = CommandContext(
                     fs=self._fs,
                     cwd=self._state.cwd,
@@ -626,6 +817,7 @@ class Interpreter:
                         script, opts.get("env"), opts["cwd"]
                     ),
                     get_registered_commands=lambda: list(self._commands.keys()),
+                    fd_contents=fd_contents,
                 )
                 result = await cmd.execute(args, ctx)
             else:
@@ -652,12 +844,25 @@ class Interpreter:
         stdout = result.stdout
         stderr = result.stderr
 
-        for redir in redirections:
+        # Pre-process: find the last file redirect index per fd for "last wins" semantics
+        # For > or >>, last redirect per fd gets the content; earlier ones just create/truncate
+        last_file_redir_for_fd: dict[int, int] = {}
+        for idx, redir in enumerate(redirections):
+            if not isinstance(redir, RedirectionNode):
+                continue
+            if redir.operator in (">", ">>"):
+                fd = redir.fd if redir.fd is not None else 1
+                last_file_redir_for_fd[fd] = idx
+            elif redir.operator == "&>":
+                last_file_redir_for_fd[1] = idx
+                last_file_redir_for_fd[2] = idx
+
+        for idx, redir in enumerate(redirections):
             if not isinstance(redir, RedirectionNode):
                 continue
 
-            # Skip heredocs - already handled
-            if redir.operator in ("<<", "<<-"):
+            # Skip heredocs and input redirections - already handled
+            if redir.operator in ("<<", "<<-", "<<<", "<"):
                 continue
 
             # Get the target path
@@ -670,20 +875,50 @@ class Interpreter:
             else:
                 continue
 
-            # Resolve to absolute path
-            target_path = self._fs.resolve_path(self._state.cwd, target_path)
-
             try:
                 fd = redir.fd if redir.fd is not None else 1  # Default to stdout
 
-                if redir.operator == ">":
-                    # Overwrite file
-                    if fd == 1:
-                        await self._fs.write_file(target_path, stdout)
+                # Check for FD duplication operators - don't resolve as path
+                is_fd_dup = redir.operator in (">&", "<&")
+                is_fd_target = is_fd_dup and (target_path.isdigit() or target_path == "-")
+
+                # Handle /dev/null and special device files
+                if target_path in ("/dev/null", "/dev/zero"):
+                    if redir.operator in (">", ">>"):
+                        if fd == 1:
+                            stdout = ""
+                        elif fd == 2:
+                            stderr = ""
+                    elif redir.operator == "&>":
                         stdout = ""
-                    elif fd == 2:
-                        await self._fs.write_file(target_path, stderr)
                         stderr = ""
+                    continue
+                elif target_path in ("/dev/stdout", "/dev/stderr", "/dev/stdin"):
+                    continue
+
+                # Resolve to absolute path for file operations
+                if not is_fd_target:
+                    target_path = self._fs.resolve_path(self._state.cwd, target_path)
+
+                if redir.operator == ">":
+                    is_last_for_fd = last_file_redir_for_fd.get(fd) == idx
+                    if is_last_for_fd:
+                        # Last redirect for this fd - write content
+                        if fd == 1:
+                            await self._fs.write_file(target_path, stdout)
+                            stdout = ""
+                        elif fd == 2:
+                            await self._fs.write_file(target_path, stderr)
+                            stderr = ""
+                        elif fd >= 3:
+                            # Custom FD - register in FD table and create file
+                            self._state.fd_table.open(fd, target_path, "w")
+                            await self._fs.write_file(target_path, "")
+                    else:
+                        # Not the last redirect - just create/truncate the file
+                        await self._fs.write_file(target_path, "")
+                        if fd >= 3:
+                            self._state.fd_table.open(fd, target_path, "w")
 
                 elif redir.operator == ">>":
                     # Append to file
@@ -691,12 +926,22 @@ class Interpreter:
                         existing = await self._fs.read_file(target_path)
                     except FileNotFoundError:
                         existing = ""
-                    if fd == 1:
-                        await self._fs.write_file(target_path, existing + stdout)
-                        stdout = ""
-                    elif fd == 2:
-                        await self._fs.write_file(target_path, existing + stderr)
-                        stderr = ""
+                    is_last_for_fd = last_file_redir_for_fd.get(fd) == idx
+                    if is_last_for_fd:
+                        if fd == 1:
+                            await self._fs.write_file(target_path, existing + stdout)
+                            stdout = ""
+                        elif fd == 2:
+                            await self._fs.write_file(target_path, existing + stderr)
+                            stderr = ""
+                        elif fd >= 3:
+                            self._state.fd_table.open(fd, target_path, "a")
+                    else:
+                        # Not last - ensure file exists but don't write content
+                        if not existing:
+                            await self._fs.write_file(target_path, "")
+                        if fd >= 3:
+                            self._state.fd_table.open(fd, target_path, "a")
 
                 elif redir.operator == "&>":
                     # Redirect both stdout and stderr to file
@@ -705,16 +950,81 @@ class Interpreter:
                     stderr = ""
 
                 elif redir.operator == ">&":
-                    # Redirect stdout to stderr or fd duplication
-                    if target_path == "2":
-                        stderr = stderr + stdout
-                        stdout = ""
+                    # FD duplication
+                    if target_path == "-":
+                        # Close FD
+                        self._state.fd_table.close(fd)
+                    elif target_path == "2":
+                        # fd>&2: redirect fd to stderr
+                        if fd == 1:
+                            stderr = stderr + stdout
+                            stdout = ""
+                        elif fd >= 3:
+                            # Custom FD to stderr - no content to redirect
+                            self._state.fd_table.dup(2, fd)
                     elif target_path == "1":
-                        stdout = stdout + stderr
-                        stderr = ""
+                        # fd>&1: redirect fd to stdout
+                        if fd == 2:
+                            stdout = stdout + stderr
+                            stderr = ""
+                        elif fd >= 3:
+                            self._state.fd_table.dup(1, fd)
+                    elif target_path.isdigit():
+                        target_fd = int(target_path)
+                        if target_fd >= 3:
+                            # Redirect fd to a custom FD
+                            fd_entry = self._state.fd_table._fds.get(target_fd)
+                            fd_path = self._state.fd_table.get_path(target_fd)
+                            # Check if target FD is a dup of stdout or stderr
+                            target_dup_of = fd_entry.dup_of if fd_entry else None
+                            if fd == 1:
+                                if target_dup_of == 1:
+                                    # FD is dup of stdout - content stays in stdout
+                                    pass
+                                elif target_dup_of == 2:
+                                    # FD is dup of stderr - merge into stderr
+                                    stderr = stderr + stdout
+                                    stdout = ""
+                                elif fd_path:
+                                    # Write stdout to the target FD's file
+                                    try:
+                                        existing = await self._fs.read_file(fd_path)
+                                    except FileNotFoundError:
+                                        existing = ""
+                                    await self._fs.write_file(fd_path, existing + stdout)
+                                    stdout = ""
+                                else:
+                                    # Custom FD without file - store content
+                                    self._state.fd_table.write(target_fd, stdout)
+                                    stdout = ""
+                            elif fd == 2:
+                                if target_dup_of == 2:
+                                    # FD is dup of stderr - content stays in stderr
+                                    pass
+                                elif target_dup_of == 1:
+                                    # FD is dup of stdout - merge into stdout
+                                    stdout = stdout + stderr
+                                    stderr = ""
+                                elif fd_path:
+                                    try:
+                                        existing = await self._fs.read_file(fd_path)
+                                    except FileNotFoundError:
+                                        existing = ""
+                                    await self._fs.write_file(fd_path, existing + stderr)
+                                    stderr = ""
+                                else:
+                                    self._state.fd_table.write(target_fd, stderr)
+                                    stderr = ""
+                            else:
+                                self._state.fd_table.dup(target_fd, fd)
+                        else:
+                            self._state.fd_table.dup(target_fd, fd)
                     else:
-                        await self._fs.write_file(target_path, stdout)
-                        stdout = ""
+                        # >&file is same as &> for fd 1
+                        if fd == 1:
+                            await self._fs.write_file(target_path, stdout + stderr)
+                            stdout = ""
+                            stderr = ""
 
                 elif redir.operator == "2>&1":
                     # Redirect stderr to stdout
@@ -768,8 +1078,14 @@ class Interpreter:
             self._state.env[str(i + 1)] = arg
         self._state.env["#"] = str(len(expanded_args))
 
+        # Save and set FUNCNAME
+        saved_funcname = self._state.env.get("FUNCNAME")
+        self._state.env["FUNCNAME"] = name
+
         # Create local scope
         self._state.local_scopes.append({})
+        if isinstance(self._state.env, VariableStore):
+            self._state.env.push_local_meta_scope()
 
         try:
             # Execute function body (which is a CompoundCommandNode)
@@ -779,6 +1095,40 @@ class Interpreter:
             except ReturnError as e:
                 return _result(e.stdout, e.stderr, e.exit_code)
         finally:
+            # Pop local scope and restore saved variables
+            scope = self._state.local_scopes.pop()
+
+            # Pop and restore metadata scope
+            if isinstance(self._state.env, VariableStore) and self._state.env._local_meta_scopes:
+                meta_scope = self._state.env.pop_local_meta_scope()
+                self._state.env.restore_metadata_from_scope(meta_scope)
+
+            # First pass: identify arrays that need element cleanup
+            # If __is_array is restored to None, the array didn't exist before
+            # and we need to clean up all element keys created inside the function
+            arrays_to_clean = []
+            for var_name, original_value in scope.items():
+                if var_name.endswith("__is_array") and original_value is None:
+                    arr_name = var_name[:-len("__is_array")]
+                    arrays_to_clean.append(arr_name)
+
+            # Clean up array element keys created inside the function
+            for arr_name in arrays_to_clean:
+                prefix = f"{arr_name}_"
+                to_remove = [
+                    k for k in self._state.env
+                    if k.startswith(prefix) and not k.startswith(f"{arr_name}__")
+                ]
+                for k in to_remove:
+                    del self._state.env[k]
+
+            # Second pass: restore all saved variables
+            for var_name, original_value in scope.items():
+                if original_value is None:
+                    self._state.env.pop(var_name, None)
+                else:
+                    self._state.env[var_name] = original_value
+
             # Restore positional parameters
             i = 1
             while str(i) in self._state.env:
@@ -788,8 +1138,12 @@ class Interpreter:
                 self._state.env[k] = v
             self._state.env["#"] = saved_count
 
-            # Pop local scope
-            self._state.local_scopes.pop()
+            # Restore FUNCNAME
+            if saved_funcname is None:
+                self._state.env.pop("FUNCNAME", None)
+            else:
+                self._state.env["FUNCNAME"] = saved_funcname
+
             self._state.call_depth -= 1
 
     async def _execute_builtin(