def testNewParser(self):
program = lex(
"print 'Hello World!'\n"
"print 42"
)
ast = parse(program)
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 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 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 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 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 testNameResolution(self):
program = util.source('''
class A(B):
pass
class B(A):
pass
''')
ast = parse(lex(program))
globalScope = Scope()
semantic.collectNames(ast, globalScope)
semantic.resolveNames(ast, globalScope)
def testCollectNames(self):
program = util.source('''
class A(B):
pass
class B(A):
pass
''')
ast = parse(lex(program))
globalScope = Scope()
semantic.collectNames(ast, globalScope)
self.assertTrue('A' in globalScope.symbols)
self.assertTrue('B' in globalScope.symbols)
def testSemantic(self):
program = util.source('''
while 0:
print '1!'
print '2!'
'''
)
from nine.lexer import lex
from nine.parser import parse
from nine.semantic import semantic
from nine.scope import Scope
tokens = lex(program)
ast = parse(tokens)
block = ast[0].block
assert isinstance(block, BlockStatement)
scope = Scope(parent=None)
result = block.semantic(scope)
assert isinstance(result, BlockStatement)
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 parseProgram(program):
return parse(lex(program))
def parseString(self, source, fileName=None):
tokens = lex(source, fileName)
return parse(tokens)
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)))
def testBadSemantic(self):
self.failUnlessRaises(TypeError,
lambda: semantic(parse(lex("while 's':\n print 9\n")))
)
