def test_compiler_yield_return(): """ Check that the compiler correctly generates return statements for a generator function. In Python versions prior to 3.3, the return statement in a generator can't take a value, so the final expression should not generate a return statement. From 3.3 onwards a return value should be generated. """ e = make_expression(HySymbol("fn"), HyList(), HyExpression([HySymbol("yield"), HyInteger(2)]), HyExpression([HySymbol("+"), HyInteger(1), HyInteger(1)])) ret = compiler.HyASTCompiler('test').compile_function_def(e) assert len(ret.stmts) == 1 stmt, = ret.stmts assert isinstance(stmt, ast.FunctionDef) body = stmt.body assert len(body) == 2 assert isinstance(body[0], ast.Expr) assert isinstance(body[0].value, ast.Yield) if PY3: # From 3.3+, the final statement becomes a return value assert isinstance(body[1], ast.Return) assert isinstance(body[1].value, ast.BinOp) else: # In earlier versions, the expression is not returned assert isinstance(body[1], ast.Expr) assert isinstance(body[1].value, ast.BinOp)
def test_sets(): """ Ensure that we can tokenize a set. """ objs = tokenize("#{1 2}") assert objs == [HySet([HyInteger(1), HyInteger(2)])] objs = tokenize("(bar #{foo bar baz})") assert objs == [ HyExpression([HySymbol("bar"), HySet(["foo", "bar", "baz"])]) ] objs = tokenize("#{(foo bar) (baz quux)}") assert objs == [ HySet([ HyExpression([HySymbol("foo"), HySymbol("bar")]), HyExpression([HySymbol("baz"), HySymbol("quux")]) ]) ] # Duplicate items in a literal set should be okay (and should # be preserved). objs = tokenize("#{1 2 1 1 2 1}") assert objs == [HySet([HyInteger(n) for n in [1, 2, 1, 1, 2, 1]])] assert len(objs[0]) == 6 # https://github.com/hylang/hy/issues/1120 objs = tokenize("#{a 1}") assert objs == [HySet([HySymbol("a"), HyInteger(1)])]
def test_compiler_yield_return(self): """ Check that the compiler correctly generates return statements for a generator function. In Python versions prior to 3.3, the return statement in a generator can't take a value, so the final expression should not generate a return statement. From 3.3 onwards a return value should be generated. """ ret = self.c.compile_function_def( self._make_expression( HySymbol("fn"), HyList(), HyExpression([HySymbol("yield"), HyInteger(2)]), HyExpression([HySymbol("+"), HyInteger(1), HyInteger(1)]))) self.assertEqual(len(ret.stmts), 1) stmt = ret.stmts[0] self.assertIsInstance(stmt, ast.FunctionDef) body = stmt.body self.assertEquals(len(body), 2) self.assertIsInstance(body[0], ast.Expr) self.assertIsInstance(body[0].value, ast.Yield) if PY33: # From 3.3+, the final statement becomes a return value self.assertIsInstance(body[1], ast.Return) self.assertIsInstance(body[1].value, ast.BinOp) else: # In earlier versions, the expression is not returned self.assertIsInstance(body[1], ast.Expr) self.assertIsInstance(body[1].value, ast.BinOp)
def test_macroexpand_source_data(): # https://github.com/hylang/hy/issues/1944 ast = HyExpression([HySymbol('#@'), HyString('a')]) ast.start_line = 3 ast.start_column = 5 bad = macroexpand(ast, "hy.core.macros") assert bad.start_line == 3 assert bad.start_column == 5
def test_lex_expression_float(): """ Make sure expressions can produce floats """ objs = tokenize("(foo 2.)") assert objs == [HyExpression([HySymbol("foo"), HyFloat(2.)])] objs = tokenize("(foo -0.5)") assert objs == [HyExpression([HySymbol("foo"), HyFloat(-0.5)])] objs = tokenize("(foo 1.e7)") assert objs == [HyExpression([HySymbol("foo"), HyFloat(1.e7)])]
def test_lex_expression_complex(): """ Make sure expressions can produce complex """ objs = tokenize("(foo 2.j)") assert objs == [HyExpression([HySymbol("foo"), HyComplex(2.j)])] objs = tokenize("(foo -0.5j)") assert objs == [HyExpression([HySymbol("foo"), HyComplex(-0.5j)])] objs = tokenize("(foo 1.e7j)") assert objs == [HyExpression([HySymbol("foo"), HyComplex(1.e7j)])] objs = tokenize("(foo j)") assert objs == [HyExpression([HySymbol("foo"), HySymbol("j")])]
def test_dicts(): """ Ensure that we can tokenize a dict. """ objs = tokenize("{foo bar bar baz}") assert objs == [HyDict(["foo", "bar", "bar", "baz"])] objs = tokenize("(bar {foo bar bar baz})") assert objs == [HyExpression([HySymbol("bar"), HyDict(["foo", "bar", "bar", "baz"])])] objs = tokenize("{(foo bar) (baz quux)}") assert objs == [HyDict([ HyExpression([HySymbol("foo"), HySymbol("bar")]), HyExpression([HySymbol("baz"), HySymbol("quux")]) ])]
def runsource(self, source, filename='<input>', symbol='single'): global SIMPLE_TRACEBACKS try: try: tokens = tokenize(source) except PrematureEndOfInput: return True do = HyExpression([HySymbol('do')] + tokens) do.start_line = do.end_line = do.start_column = do.end_column = 1 do.replace(do) except LexException as e: if e.source is None: e.source = source e.filename = filename print(e, file=sys.stderr) return False try: def ast_callback(main_ast, expr_ast): if self.spy: # Mush the two AST chunks into a single module for # conversion into Python. new_ast = ast.Module(main_ast.body + [ast.Expr(expr_ast.body)]) print(astor.to_source(new_ast)) value = hy_eval(do, self.locals, "__console__", ast_callback) except HyTypeError as e: if e.source is None: e.source = source e.filename = filename if SIMPLE_TRACEBACKS: print(e, file=sys.stderr) else: self.showtraceback() return False except Exception: self.showtraceback() return False if value is not None: # Make the last non-None value available to # the user as `_`. self.locals['_'] = value # Print the value. print(self.output_fn(value)) return False
def test_lex_digit_separators(): assert tokenize("1_000_000") == [HyInteger(1000000)] assert tokenize("1,000,000") == [HyInteger(1000000)] assert tokenize("1,000_000") == [HyInteger(1000000)] assert tokenize("1_000,000") == [HyInteger(1000000)] assert tokenize("0x_af") == [HyInteger(0xaf)] assert tokenize("0x,af") == [HyInteger(0xaf)] assert tokenize("0b_010") == [HyInteger(0b010)] assert tokenize("0b,010") == [HyInteger(0b010)] assert tokenize("0o_373") == [HyInteger(0o373)] assert tokenize("0o,373") == [HyInteger(0o373)] assert tokenize('1_2.3,4') == [HyFloat(12.34)] assert tokenize('1_2e3,4') == [HyFloat(12e34)] assert (tokenize("1,2/3_4") == [ HyExpression([HySymbol("fraction"), HyInteger(12), HyInteger(34)]) ]) assert tokenize("1,0_00j") == [HyComplex(1000j)] assert tokenize("1,,,,___,____,,__,,2__,,,__") == [HyInteger(12)] assert (tokenize("_1,,,,___,____,,__,,2__,,,__") == [ HySymbol("_1,,,,___,____,,__,,2__,,,__") ]) assert (tokenize("1,,,,___,____,,__,,2__,q,__") == [ HySymbol("1,,,,___,____,,__,,2__,q,__") ])
def t_identifier(p): obj = p[0].value try: return HyInteger(obj) except ValueError: pass if '/' in obj: try: lhs, rhs = obj.split('/') return HyExpression( [HySymbol('fraction'), HyInteger(lhs), HyInteger(rhs)]) except ValueError: pass try: return HyFloat(obj) except ValueError: pass if obj != 'j': try: return HyComplex(obj) except ValueError: pass if obj.startswith(":"): return HyKeyword(obj) obj = ".".join([hy_symbol_mangle(part) for part in obj.split(".")]) return HySymbol(obj)
def symbol_like(obj): "Try to interpret `obj` as a number or keyword." try: return HyInteger(obj) except ValueError: pass if '/' in obj: try: lhs, rhs = obj.split('/') return HyExpression( [HySymbol('fraction'), HyInteger(lhs), HyInteger(rhs)]) except ValueError: pass try: return HyFloat(obj) except ValueError: pass if obj != 'j': try: return HyComplex(obj) except ValueError: pass if obj.startswith(":") and "." not in obj: return HyKeyword(obj[1:])
def hy_parse(source, filename='<string>'): """Parse a Hy source string. Args: source (string): Source code to parse. filename (string, optional): File name corresponding to source. Defaults to "<string>". Returns: out : HyExpression """ _source = re.sub(r'\A#!.*', '', source) res = HyExpression([HySymbol("do")] + tokenize(_source + "\n", filename=filename)) res.source = source res.filename = filename return res
def ideas_macro(ETname): return HyExpression([ HySymbol('print'), HyString(r""" => (import [sh [figlet]]) => (figlet "Hi, Hy!") _ _ _ _ _ _ | | | (_) | | | |_ _| | | |_| | | | |_| | | | | | | _ | |_ | _ | |_| |_| |_| |_|_( ) |_| |_|\__, (_) |/ |___/ ;;; string things (.join ", " ["what" "the" "heck"]) ;;; this one plays with command line bits (import [sh [cat grep]]) (-> (cat "/usr/share/dict/words") (grep "-E" "bro$")) ;;; filtering a list w/ a lambda (filter (fn [x] (= (% x 2) 0)) (range 0 10)) ;;; swaggin' functional bits (Python rulez) (max (map (fn [x] (len x)) ["hi" "my" "name" "is" "paul"])) """) ])
def test_lex_fractions(): """ Make sure that fractions are valid expressions""" objs = tokenize("1/2") assert objs == [ HyExpression([HySymbol("fraction"), HyInteger(1), HyInteger(2)]) ]
def _make_expression(*args): h = HyExpression(args) h.start_line = 1 h.end_line = 1 h.start_column = 1 h.end_column = 1 return h.replace(h)
def macroexpand_1(tree, compiler): """Expand the toplevel macro from `tree` once, in the context of `module_name`.""" if isinstance(tree, HyExpression): if tree == []: return tree fn = tree[0] if fn in ("quote", "quasiquote"): return tree ntree = HyExpression(tree[:]) ntree.replace(tree) opts = {} if isinstance(fn, HySymbol): fn = mangle(str_type(fn)) m = _hy_macros[compiler.module_name].get(fn) if m is None: m = _hy_macros[None].get(fn) if m is not None: if m._hy_macro_pass_compiler: opts['compiler'] = compiler try: m_copy = make_empty_fn_copy(m) m_copy(compiler.module_name, *ntree[1:], **opts) except TypeError as e: msg = "expanding `" + str(tree[0]) + "': " msg += str(e).replace("<lambda>()", "", 1).strip() raise HyMacroExpansionError(tree, msg) try: obj = m(compiler.module_name, *ntree[1:], **opts) except HyTypeError as e: if e.expression is None: e.expression = tree raise except Exception as e: msg = "expanding `" + str(tree[0]) + "': " + repr(e) raise HyMacroExpansionError(tree, msg) replace_hy_obj(obj, tree) return obj return ntree return tree
def test_cons_list(): """Check that cons of something and a list gets tokenized as a list""" entry = tokenize("(a . [])")[0] assert entry == HyList([HySymbol("a")]) assert type(entry) == HyList entry = tokenize("(a . ())")[0] assert entry == HyExpression([HySymbol("a")]) assert type(entry) == HyExpression entry = tokenize("(a b . {})")[0] assert entry == HyDict([HySymbol("a"), HySymbol("b")]) assert type(entry) == HyDict
def term_hashstars(state, p): n_stars = len(p[0].getstr()[1:]) if n_stars == 1: sym = "unpack-iterable" elif n_stars == 2: sym = "unpack-mapping" else: raise LexException.from_lexer( "Too many stars in `#*` construct (if you want to unpack a symbol " "beginning with a star, separate it with whitespace)", state, p[0]) return HyExpression([HySymbol(sym), p[1]])
def term_hashstars(p): n_stars = len(p[0].getstr()[1:]) if n_stars == 1: sym = "unpack_iterable" elif n_stars == 2: sym = "unpack_mapping" else: raise LexException( "Too many stars in `#*` construct (if you want to unpack a symbol " "beginning with a star, separate it with whitespace)", p[0].source_pos.lineno, p[0].source_pos.colno) return HyExpression([HySymbol(sym), p[1]])
def make_expression(*args): h = HyExpression(args) h.start_line = 1 h.end_line = 1 h.start_column = 1 h.end_column = 1 return h.replace(h)
def hy_parse(source, filename='<string>'): """Parse a Hy source string. Parameters ---------- source: string Source code to parse. filename: string, optional File name corresponding to source. Defaults to "<string>". Returns ------- out : HyExpression """ _source = re.sub(r'\A#!.*', '', source) res = HyExpression([HySymbol("do")] + tokenize(_source + "\n", filename=filename)) res.source = source res.filename = filename return res
def hy_parse(source): """Parse a Hy source string. Parameters ---------- source: string Source code to parse. Returns ------- out : instance of `types.CodeType` """ source = re.sub(r'\A#!.*', '', source) return HyExpression([HySymbol("do")] + tokenize(source + "\n"))
def test_preprocessor_expression(): """ Test that macro expansion doesn't recurse""" obj = macroexpand( tokenize('(test (test "one" "two"))')[0], HyASTCompiler(__name__)) assert type(obj) == HyList assert type(obj[0]) == HyExpression assert obj[0] == HyExpression( [HySymbol("test"), HyString("one"), HyString("two")]) obj = HyList([HyString("one"), HyString("two")]) obj = tokenize('(shill ["one" "two"])')[0][1] assert obj == macroexpand(obj, HyASTCompiler(""))
def koan_macro(ETname): return HyExpression([HySymbol('print'), HyString(""" Ummon asked the head monk, "What sutra are you lecturing on?" "The Nirvana Sutra." "The Nirvana Sutra has the Four Virtues, hasn't it?" "It has." Ummon asked, picking up a cup, "How many virtues has this?" "None at all," said the monk. "But ancient people said it had, didn't they?" said Ummon. "What do you think of what they said?" Ummon struck the cup and asked, "You understand?" "No," said the monk. "Then," said Ummon, "You'd better go on with your lectures on the sutra." """)])
def paren(p): cont = p[1] # Dotted lists are expressions of the form # (a b c . d) # that evaluate to nested cons cells of the form # (a . (b . (c . d))) if len(cont) >= 3 and isinstance(cont[-2], HySymbol) and cont[-2] == ".": reject_spurious_dots(cont[:-2], cont[-1:]) if len(cont) == 3: # Two-item dotted list: return the cons cell directly return HyCons(cont[0], cont[2]) else: # Return a nested cons cell return HyCons(cont[0], paren([p[0], cont[1:], p[2]])) # Warn preemptively on a malformed dotted list. # Only check for dots after the first item to allow for a potential # attribute accessor shorthand reject_spurious_dots(cont[1:]) return HyExpression(p[1])
def paren(p): return HyExpression(p[1])
def test_lex_expression_strings(): """ Test that expressions can produce strings """ objs = tokenize("(foo \"bar\")") assert objs == [HyExpression([HySymbol("foo"), HyString("bar")])]
def test_lex_expression_integer(): """ Make sure expressions can produce integers """ objs = tokenize("(foo 2)") assert objs == [HyExpression([HySymbol("foo"), HyInteger(2)])]
def hash_other(p): # p == [(Token('HASHOTHER', '#foo'), bar)] st = p[0].getstr()[1:] str_object = HyString(st) expr = p[1] return HyExpression([HySymbol("dispatch-tag-macro"), str_object, expr])
def term_unquote_splice(p): return HyExpression([HySymbol("unquote-splice"), p[1]])
def term_quasiquote(p): return HyExpression([HySymbol("quasiquote"), p[1]])
def empty_paren(p): return HyExpression([])