def testBadSemantic(self):
program = "var x = 5 * 'bork'\n"
self.failUnlessRaises(
error.TypeError,
lambda: semantic(parse(lex(program)))
)
def testGoodProgram(self):
source = lex(
"print 'Hello World!'"
)
ast = parse(source)
result = semantic.semantic(ast)
def testTypeMismatch2(self):
program = util.source('''
def foo(i as int) as void:
return i
''')
self.failUnlessRaises(
error.TypeError,
lambda: semantic(parse(lex(program)))
)
def testTypeMismatch(self):
ast = parse(lex('var x as string = 42'))
assert ast is not None
self.failUnlessRaises(
error.TypeError,
lambda: semantic(ast)
)
def testABugAndyFound(self):
from nine.lexer import lex
from nine.parser import parse
from nine.semantic import semantic
result = semantic(parse(lex(util.source('''
if true:
print 'True!'
print 'This caused a spurious syntax error because there is no END_OF_STATEMENT after the dedent!'
'''))))
def testTypeMismatch1(self):
program = util.source('''
def foo(i as int) as int:
return "This isn't an int!!"
''')
ast = parse(lex(program))
self.failUnlessRaises(
error.TypeError,
lambda: semantic(ast)
)
def testSemantic(self):
from nine.parser import parse
from nine.semantic import semantic
tokens = lex(util.source('''
def foo():
print 'foo!'
foo()
'''))
ast = parse(tokens)
st = semantic(ast)
def testTypeInfer(self):
from ast import vartypes
program = util.source('''
var x = 19
var z = 'Hello!'
''')
ast = parse(lex(program))
st = semantic(ast)
assert st[0].type is vartypes.IntType, (st[0].type, vartypes.IntType)
assert st[1].type is vartypes.StringType, (st[1].type, vartypes.StringType)
def testSemantic2(self):
from nine.parser import parse
from nine.semantic import semantic
program = util.source('''
var x = 42
var y = 'Hello!'
print x
print y
''')
result = semantic(parse(lex(program)))
assert result is not None
def semanticProgram(program, assemblies=[]):
from ast.namespace import Namespace
from ast.vartypes import Type
driver = Driver()
globalNs = Namespace('')
for asm in assemblies:
driver._scanAssembly(globalNs, asm)
driver.fixPrimitives()
globalScope = semantic.makeGlobalScope(globalNs.symbols)
return semantic.semantic(parse(lex(program)), globalScope)
def compileProgram(self, ast, outputName):
globalNs = self.scanAssemblies(self.references)
self.fixPrimitives()
# Fill globalNs with declared symbols
for decl in ast:
if hasattr(decl, 'name'):
globalNs.symbols[decl.name] = decl
globalScope = semantic.makeGlobalScope(globalNs.symbols)
st = semantic.semantic(ast, globalScope)
gen = CodeGenerator()
gen.createProgram(outputName, st)
def testSemantic(self):
program = util.source('''
var x as int
x = 5
''')
from nine.lexer import lex
from nine.parser import parse
from nine.semantic import semantic
tokens = lex(program)
ast = parse(tokens)
st = semantic(ast)
# Two statements
self.failUnlessEqual(len(st), 2)
# The second of which is an assignment whose lhs is the previous statement
self.failUnlessEqual(st[1].lhs.variable, st[0])
# named x
self.failUnlessEqual(st[1].lhs.variable.name, 'x')
def testBadSemantic(self):
self.failUnlessRaises(TypeError,
lambda: semantic(parse(lex("while 's':\n print 9\n")))
)
def testGoodSemantic(self):
result = semantic(parse(lex("while true:\n print 9\n")))
self.failUnlessEqual(len(result), 1)
stmt = result[0]
self.failUnless(isinstance(stmt, WhileStatement), stmt)
def testGoodSemantic(self):
program = 'print 5 * 42\n'
result = semantic(parse(lex(program)))
