Add DRETURN

Author: python-processing-unit

SPECIFICATION.md

@@ -95,6 +95,8 @@ Program termination is exposed via `EXIT`. `EXIT()` or `EXIT(code)` requests imm
 
 Memory-management and function-return behavior are also exposed via operators. `DEL(x)` deletes the variable `x` from the current environment, freeing its memory; any subsequent reference to `x` is an error unless `x` is re-assigned. `RETURN(a)`, when executed inside a function body, immediately terminates that function and returns the value of `a` to the caller. Executing `RETURN` outside of a function is a runtime error.
 
+`DRETURN(x)` is a convenience operator combining `RETURN` and `DEL`: when executed inside a function body it retrieves the current value of the identifier `x`, deletes the binding `x` from the environment (so subsequent references are an error), and returns the retrieved value to the caller. Using `DRETURN` outside of a function is a runtime error. If `x` is frozen or undefined, `DRETURN(x)` raises the same runtime errors as `DEL(x)` or a reference to `x` would.
+
 
 ## 5. Statements and Control Flow
 

asmln.exe

@@ -34,6 +34,7 @@
     Parser,
     Program,
     ReturnStatement,
+    DReturnStatement,
     SourceLocation,
     Statement,
     TensorLiteral,
@@ -1801,6 +1802,26 @@ def _execute_statement(self, statement: Statement, env: Environment) -> None:
                 closure=env,
             )
             return
+        if isinstance(statement, DReturnStatement):
+            frame: Frame = self.call_stack[-1]
+            if frame.name == "<top-level>":
+                raise ASMRuntimeError("DRETURN outside of function", location=statement.location, rewrite_rule="DRETURN")
+            # Expect identifier expression to delete a symbol
+            expr = statement.expression
+            if not isinstance(expr, Identifier):
+                raise ASMRuntimeError("DRETURN expects identifier", location=statement.location, rewrite_rule="DRETURN")
+            name = expr.name
+            try:
+                value = env.get(name)
+            except ASMRuntimeError as err:
+                err.location = statement.location
+                raise
+            try:
+                env.delete(name)
+            except ASMRuntimeError as err:
+                err.location = statement.location
+                raise
+            raise ReturnSignal(value)
         if isinstance(statement, ReturnStatement):
             frame: Frame = self.call_stack[-1]
             if frame.name == "<top-level>":

interpreter.py

@@ -27,6 +27,7 @@ class Token:
     "FOR",
     "FUNC",
     "RETURN",
+    "DRETURN",
     "BREAK",
     "CONTINUE",
     "GOTO",

lexer.py

@@ -91,6 +91,11 @@ class ReturnStatement(Statement):
     expression: Optional["Expression"]
 
 
+@dataclass
+class DReturnStatement(Statement):
+    expression: "Expression"
+
+
 @dataclass
 class BreakStatement(Statement):
     expression: "Expression"
@@ -192,6 +197,8 @@ def _parse_statement(self) -> Statement:
             return self._parse_for()
         if token.type == "RETURN":
             return self._parse_return()
+        if token.type == "DRETURN":
+            return self._parse_dreturn()
         if token.type == "BREAK":
             return self._parse_break()
         if token.type == "CONTINUE":
@@ -290,6 +297,11 @@ def _parse_return(self) -> ReturnStatement:
         expression: Expression = self._parse_parenthesized_expression()
         return ReturnStatement(location=self._location_from_token(keyword), expression=expression)
 
+    def _parse_dreturn(self) -> DReturnStatement:
+        keyword = self._consume("DRETURN")
+        expression: Expression = self._parse_parenthesized_expression()
+        return DReturnStatement(location=self._location_from_token(keyword), expression=expression)
+
     def _parse_break(self) -> BreakStatement:
         keyword = self._consume("BREAK")
         expression: Expression = self._parse_parenthesized_expression()