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