def run_test(self, testcase):
a = []
try:
line = testcase.input[0]
mask = ''
if line.startswith('##'):
mask = '(' + line[2:].strip() + ')$'
src = '\n'.join(testcase.input)
map = build(src, 'main', True, testconfig.test_temp_dir, True)[3]
kk = map.keys()
keys = []
for k in kk:
if k.line is not None and k.line != -1 and map[k]:
if (re.match(mask, short_type(k))
or (isinstance(k, NameExpr)
and re.match(mask, k.name))):
keys.append(k)
for key in sorted(keys,
key=lambda n: (n.line, short_type(n),
str(n) + str(map[n]))):
ts = str(map[key]).replace('*', '') # Remove erased tags
ts = ts.replace('__main__.', '')
a.append('{}({}) : {}'.format(short_type(key), key.line, ts))
except CompileError as e:
a = e.messages
assert_string_arrays_equal(
testcase.output, a,
'Invalid type checker output ({}, line {})'.format(testcase.file,
testcase.line))
def dump(self, nodes, obj):
"""Convert an array of items to a multiline pretty-printed
string. The tag is produced from the type name of obj and its
line number. See util::DumpTagged for a description of the
nodes argument.
"""
return dump_tagged(nodes, short_type(obj) + ':' + str(obj.line))
def __str__(self):
s = '{}/{}'.format(node_kinds[self.kind], short_type(self.node))
if self.mod_id is not None:
s += ' ({})'.format(self.mod_id)
# Include declared type of variables and functions.
if self.typ() is not None:
s += ' : {}'.format(self.typ())
return s
from util import short_type
class Token:
"""Base class for all tokens"""
str pre = '' # Space, comments etc. before token
str string # Token string
int line # Token line number
void __init__(self, str string, str pre=''):
self.string = string
self.pre = pre
str __repr__(self):
t = short_type(self)
return t + '(' + self.fix(self.pre) + self.fix(self.string) + ')'
str rep(self):
return self.pre + self.string
str fix(self, str s):
return s.replace('\n', '\\n').replace('\t', '\\t').replace('\r', '\\r')
# Token classes
class Break(Token):
"""Statement break (line break or semicolon)"""
class Indent(Token):
def visit_name_expr(self, o):
return (short_type(o) + '(' + self.pretty_name(o.name, o.kind,
o.full_name, o.is_def)
+ ')')
def __repr__(self):
"""The representation is of form Keyword(' if')."""
t = short_type(self)
return t + '(' + self.fix(self.pre) + self.fix(self.string) + ')'
else:
return None
mtypes.Type type(self):
# IDEA: Get rid of the any type.
any node = self.node
if self.type_override is not None:
return self.type_override
elif ((isinstance(node, Var) or isinstance(node, FuncDef))
and node.type is not None):
return node.type.type
else:
return None
str __str__(self):
s = '{}/{}'.format(node_kinds[self.kind], short_type(self.node))
if self.mod_id is not None:
s += ' ({})'.format(self.mod_id)
# Include declared type of variables and functions.
if self.type() is not None:
s += ' : {}'.format(self.type())
return s
str clean_up(str s):
return re.sub('.*::', '', s)
mtypes.FunctionLike function_type(FuncBase func):
if func.type:
return (mtypes.FunctionLike)func.type
