Rename variables in @builds_model(HyExpression)
This commit is contained in:
parent
271f2846dc
commit
0f85331c81
@ -1539,98 +1539,98 @@ class HyASTCompiler(object):
|
||||
else Result())
|
||||
|
||||
@builds_model(HyExpression)
|
||||
def compile_expression(self, expression):
|
||||
def compile_expression(self, expr):
|
||||
# Perform macro expansions
|
||||
expression = macroexpand(expression, self)
|
||||
if not isinstance(expression, HyExpression):
|
||||
expr = macroexpand(expr, self)
|
||||
if not isinstance(expr, HyExpression):
|
||||
# Go through compile again if the type changed.
|
||||
return self.compile(expression)
|
||||
return self.compile(expr)
|
||||
|
||||
if not expression:
|
||||
if not expr:
|
||||
raise HyTypeError(
|
||||
expression, "empty expressions are not allowed at top level")
|
||||
expr, "empty expressions are not allowed at top level")
|
||||
|
||||
fn = expression[0]
|
||||
root = expr[0]
|
||||
func = None
|
||||
|
||||
if isinstance(fn, HySymbol):
|
||||
if isinstance(root, HySymbol):
|
||||
|
||||
# First check if `fn` is a special operator, unless it has an
|
||||
# First check if `root` is a special operator, unless it has an
|
||||
# `unpack-iterable` in it, since Python's operators (`+`,
|
||||
# etc.) can't unpack. An exception to this exception is that
|
||||
# tuple literals (`,`) can unpack.
|
||||
sfn = ast_str(fn)
|
||||
if (sfn in _special_form_compilers or sfn in _bad_roots) and (
|
||||
sfn == mangle(",") or
|
||||
not any(is_unpack("iterable", x) for x in expression[1:])):
|
||||
if sfn in _bad_roots:
|
||||
sroot = ast_str(root)
|
||||
if (sroot in _special_form_compilers or sroot in _bad_roots) and (
|
||||
sroot == mangle(",") or
|
||||
not any(is_unpack("iterable", x) for x in expr[1:])):
|
||||
if sroot in _bad_roots:
|
||||
raise HyTypeError(
|
||||
expression,
|
||||
"The special form '{}' is not allowed here".format(fn))
|
||||
# `sfn` is a special operator. Get the build method and
|
||||
expr,
|
||||
"The special form '{}' is not allowed here".format(root))
|
||||
# `sroot` is a special operator. Get the build method and
|
||||
# pattern-match the arguments.
|
||||
build_method, pattern = _special_form_compilers[sfn]
|
||||
build_method, pattern = _special_form_compilers[sroot]
|
||||
try:
|
||||
parse_tree = pattern.parse(expression[1:])
|
||||
parse_tree = pattern.parse(expr[1:])
|
||||
except NoParseError as e:
|
||||
raise HyTypeError(
|
||||
expression[min(e.state.pos + 1, len(expression) - 1)],
|
||||
expr[min(e.state.pos + 1, len(expr) - 1)],
|
||||
"parse error for special form '{}': {}".format(
|
||||
expression[0],
|
||||
expr[0],
|
||||
e.msg.replace("<EOF>", "end of form")))
|
||||
return Result() + build_method(
|
||||
self, expression, unmangle(sfn), *parse_tree)
|
||||
self, expr, unmangle(sroot), *parse_tree)
|
||||
|
||||
if fn.startswith("."):
|
||||
if root.startswith("."):
|
||||
# (.split "test test") -> "test test".split()
|
||||
# (.a.b.c x) -> (.c (. x a b)) -> x.a.b.c()
|
||||
|
||||
# Get the method name (the last named attribute
|
||||
# in the chain of attributes)
|
||||
attrs = [HySymbol(a).replace(fn) for a in fn.split(".")[1:]]
|
||||
fn = attrs.pop()
|
||||
attrs = [HySymbol(a).replace(root) for a in root.split(".")[1:]]
|
||||
root = attrs.pop()
|
||||
|
||||
# Get the object we're calling the method on
|
||||
# (extracted with the attribute access DSL)
|
||||
i = 1
|
||||
if len(expression) != 2:
|
||||
if len(expr) != 2:
|
||||
# If the expression has only one object,
|
||||
# always use that as the callee.
|
||||
# Otherwise, hunt for the first thing that
|
||||
# isn't a keyword argument or its value.
|
||||
while i < len(expression):
|
||||
if isinstance(expression[i], HyKeyword):
|
||||
while i < len(expr):
|
||||
if isinstance(expr[i], HyKeyword):
|
||||
# Skip the keyword argument and its value.
|
||||
i += 1
|
||||
else:
|
||||
# Use expression[i].
|
||||
# Use expr[i].
|
||||
break
|
||||
i += 1
|
||||
else:
|
||||
raise HyTypeError(expression,
|
||||
raise HyTypeError(expr,
|
||||
"attribute access requires object")
|
||||
func = self.compile(HyExpression(
|
||||
[HySymbol(".").replace(fn), expression.pop(i)] +
|
||||
[HySymbol(".").replace(root), expr.pop(i)] +
|
||||
attrs))
|
||||
|
||||
# And get the method
|
||||
func += asty.Attribute(fn,
|
||||
func += asty.Attribute(root,
|
||||
value=func.force_expr,
|
||||
attr=ast_str(fn),
|
||||
attr=ast_str(root),
|
||||
ctx=ast.Load())
|
||||
|
||||
if not func:
|
||||
func = self.compile(fn)
|
||||
func = self.compile(root)
|
||||
|
||||
# An exception for pulling together keyword args is if we're doing
|
||||
# a typecheck, eg (type :foo)
|
||||
with_kwargs = fn not in (
|
||||
with_kwargs = root not in (
|
||||
"type", "HyKeyword", "keyword", "name", "keyword?", "identity")
|
||||
args, ret, keywords, oldpy_star, oldpy_kw = self._compile_collect(
|
||||
expression[1:], with_kwargs, oldpy_unpack=True)
|
||||
expr[1:], with_kwargs, oldpy_unpack=True)
|
||||
|
||||
return func + ret + asty.Call(
|
||||
expression, func=func.expr, args=args, keywords=keywords,
|
||||
expr, func=func.expr, args=args, keywords=keywords,
|
||||
starargs=oldpy_star, kwargs=oldpy_kw)
|
||||
|
||||
@builds_model(HyInteger, HyFloat, HyComplex)
|
||||
|
Loading…
Reference in New Issue
Block a user