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"))) )