def eval(self, context):

		evaluate(self.node["expression"], context)

class CallExpression:

	def __init__(self, node):

		self.node = node

	def eval(self, context):

		callee = evaluate(self.node["callee"], context)

		arguments = [evaluate(arg, context) for arg in self.node["arguments"]]

		return callee(*arguments)

class MemberExpression:

	def __init__(self, node):

		self.node = node

	def eval(self, context):

		obj = evaluate(self.node["object"], context)

		prop = evaluate(self.node["property"], [obj])

		return prop

class BinaryExpression:

	def __init__(self, node):

		self.node = node

	def eval(self, context):

		left = evaluate(self.node["left"], context)

		right = evaluate(self.node["right"], context)

		# in fact this doesn't follow JavaScript "+" semantics

		if self.node["operator"] == "+":

			return Number(left.val+right.val)

		else:

			raise NotImplementedError

class EmptyStatement:

	def __init__(self, node):

		pass

	def eval(self, context):

		pass

class VariableDeclaration:

		if self.node["id"]["type"] == "Identifier":

			name = self.node["id"]["name"]

			context[-1][name] = value

		else:

			raise NotImplementedError

class Literal:

	def __init__(self, node):

		self.node = node

	def eval(self, context):

		val = self.node["value"]

		if isinstance(val, float):

			if int(val) == val:

				return Number(int(val))

			else:

				return Number(val)

		else:

			raise NotImplementedError

node_index = {cls.__name__: cls for cls in [

]}

def interpret(parse_tree):

	return evaluate(parse_tree, [stdlib])

from unittest import TestCase

from unittest.mock import patch

from pyjsparser import parse

from jasinta import interpret

class TestBasicAddition(TestCase):

	@patch("builtins.print")

	def test_interpret(self, mock_print):

		s = """var a=3;

var b=1;

var c=a+b;

document.write(c);"""

		interpret(parse(s))

		mock_print.assert_called_with(4)