feat(builtins): eval

Author: litlighilit

Parser/lexer.nim

@@ -733,8 +733,6 @@ proc lexOneLine(lexer: Lexer, line: string, mode: Mode) {.inline, raises: [Synta
     lexer.add(Token.NEWLINE, idx)
 
 proc lexString*(lexer: Lexer, input: string, mode=Mode.File) = 
-  assert mode != Mode.Eval # eval not tested
-
   # interactive mode and an empty line
   if mode == Mode.Single and input.len == 0 and not lexer.tripleStr.within:
     lexer.dedentAll

Python/ast.nim

@@ -320,11 +320,18 @@ ast file_input, [AstModule]:
     if child.tokenNode.token == Token.stmt:
       result.body.addCompat astStmt(child)
 
-#[
-ast eval_input, []:
-  discard
-  
-]#
+# eval_input: testlist NEWLINE* ENDMARKER
+ast eval_input, [AstExpression]:
+  result = newAstExpression()
+  let child = parseNode.children[0]
+  if child.tokenNode.token != Token.testlist:
+    raiseSyntaxError("expected testlist in eval input", child)
+  let e = astTestlist(child)
+  result.body = e
+  for i in 1..<parseNode.children.len:
+    let child = parseNode.children[i]
+    if child.tokenNode.token not_in {Token.NEWLINE, Token.ENDMARKER}:
+      raiseSyntaxError("unexpected token in eval input", child)
 
 # decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE
 ast decorator, [AsdlExpr]:
@@ -1747,7 +1754,7 @@ proc ast*(root: ParseNode, tfileName: string): AsdlModl =
   of Token.single_input:
     result = astSingleInput(root)
   of Token.eval_input:
-    unreachable  # currently no eval mode
+    result = astEvalInput(root)
   else:
     unreachable
   when defined(debug_ast):

Python/bltinmodule/compile_eval_exec.nim

@@ -1,5 +1,5 @@
 
-
+from std/strutils import strip
 import ../../Objects/[
   stringobject/codec,
   noneobject,
@@ -46,9 +46,10 @@ proc compile*(
 
   Py_CompileStringObject(str, filename, emode, cf, optimize)
 
-proc exec*(
-  source: PyObject, globals: PyObject = pyNone, locals: PyObject = pyNone,
-    closure: PyObject = nil): PyObject{.bltin_clinicGen.} =
+template init_globals_locals_ensure_bltin(no_globals_err,
+      globals_invalid, locals_invalid
+    ){.dirty.} =
+
   var globals = globals
   var fromframe = false
   if globals.isPyNone:
@@ -59,7 +60,7 @@ proc exec*(
     else:
       globals = PyEval_GetGlobalsFromRunningMain()
       if globals.isNil:
-        return newSystemError newPyAscii "globals and locals cannot be NULL"
+        return newSystemError newPyAscii no_globals_err
 
   var locals = locals
   if locals.isPyNone:
@@ -70,16 +71,68 @@ proc exec*(
       locals = globals
 
   if not globals.ofPyDictObject:
-    return type_errorn("exec() globals must be a dict, not $#", globals)
+    return type_error globals_invalid
   if not locals.ofPyMapping:
-    return type_errorn("exec() locals must be a mapping or None, not $#", locals)
+    return type_error locals_invalid
 
   locals = nil
   TODO_locals locals
 
   let dglobals = PyDictObject globals
   retIfExc PyEval_EnsureBuiltins(dglobals)
 
+template asStringAndInitCf(source, funName){.dirty.} =
+  var cf = initPyCompilerFlags()
+  cf.flags = typeof(cf.flags) PyCF.SOURCE_IS_UTF8
+  var source_copy: PyObject
+  var str: string
+  retIfExc Py_SourceAsString(source, funName, "string, bytes or AST", cf, source_copy, str)
+
+proc eval*(
+    source: PyObject, globals: PyObject = pyNone, locals: PyObject = pyNone,
+  ): PyObject{.bltin_clinicGen.} =
+  var globalsIsDict = globals.ofPyDictObject
+  # if not globals.isPyNone and not (globalsIsDict = globals.ofPyDictObject; globalsIsDict):
+  #   return type_error(
+  #       )
+  # if not locals.isPyNone and not locals.ofPyMapping:
+  #   return type_error 
+
+  init_globals_locals_ensure_bltin(
+    "eval must be given globals and locals when called without a frame",
+      if globalsIsDict: "globals must be a real dict; try eval(expr, {}, mapping)"
+      else: "globals must be a dict"
+      ,
+    "locals must be a mapping"
+  )
+  if source.ofPyCodeObject:
+    let co = PyCodeObject source
+    retIfExc audit("exec", source)
+    if co.freeVars.len > 0:
+      return type_error "code object passed to eval() may not have free variables"
+
+    result = evalCode(co, dglobals, locals)
+  else:
+    asStringAndInitCf source, "eval"
+
+    str = str.strip(chars={' ', '\t'}, trailing=false)
+
+    discard PyEval_MergeCompilerFlags(cf)
+
+    return PyRun_StringFlags(str, Mode.Eval, dglobals, locals, cf)
+
+
+proc exec*(
+  source: PyObject, globals: PyObject = pyNone, locals: PyObject = pyNone,
+    closure: PyObject = nil): PyObject{.bltin_clinicGen.} =
+  
+  init_globals_locals_ensure_bltin(
+    "globals and locals cannot be NULL",
+    "exec() globals must be a dict, not " & globals.typeName,
+    "exec() locals must be a mapping or None, not " & locals.typeName
+
+  )
+
   var closure = closure
   if closure.isPyNone:
     closure = nil
@@ -113,11 +166,7 @@ proc exec*(
     if not closure.isNil:
       return type_error "closure can only be used when source is a code object"
 
-    var cf = initPyCompilerFlags()
-    cf.flags = typeof(cf.flags) PyCF.SOURCE_IS_UTF8
-    var source_copy: PyObject
-    var str: string
-    retIfExc Py_SourceAsString(source, "exec", "string, bytes or AST", cf, source_copy, str)
+    asStringAndInitCf source, "exec"
     result = if PyEval_MergeCompilerFlags(cf):
       PyRun_StringFlags(str, Mode.File, dglobals, locals, cf)
     else:
@@ -130,3 +179,4 @@ template reg(f) =
 template register_compile_eval_exec* =
   reg compile
   reg exec
+  reg eval

Python/compile.nim

@@ -447,6 +447,9 @@ compileMethod Interactive:
   c.interactive = true
   c.compileSeq(astNode.body)
 
+compileMethod Expression:
+  c.compile(astNode.body)
+  c.addOp(newInstr(OpCode.ReturnValue, astNode.body.lineNo.value))
 
 proc compileArguments(c: Compiler; astNode: auto; argsNode: AstArguments,
                       codeName: PyStrObject): int =

Python/symtable.nim

@@ -213,6 +213,9 @@ proc collectDeclaration*(st: SymTable, astRoot: AsdlModl){.raises: [SyntaxError]
     elif astNode of AstInteractive:
       ste.kind = SteKind.Module
       addBodies(AstInteractive)
+    elif astNode of AstExpression:
+      ste.kind = SteKind.Module #TODO:eval: right?
+      visit AstExpression(astNode).body
     elif astNode of AstFunctionDef:
       ste.kind = SteKind.Function
       # deal with function args