def run_test(self, testcase):
     a = []
     try:
         line = testcase.input[0]
         mask = ''
         if line.startswith('##'):
             mask = '(' + line[2:].strip() + ')$'
         
         src = '\n'.join(testcase.input)
         result = build.build(program_path='main',
                              target=build.TYPE_CHECK,
                              program_text=src,
                              flags=[build.TEST_BUILTINS],
                              alt_lib_path=testconfig.test_temp_dir)
         map = result.types
         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 run_case(self, testcase: DataDrivenTestCase) -> None:
        try:
            line = testcase.input[0]
            mask = ''
            if line.startswith('##'):
                mask = '(' + line[2:].strip() + ')$'

            src = '\n'.join(testcase.input)
            options = Options()
            options.strict_optional = False  # TODO: Enable strict optional checking
            options.use_builtins_fixtures = True
            options.show_traceback = True
            options.export_types = True
            result = build.build(sources=[BuildSource('main', None, src)],
                                 options=options,
                                 alt_lib_path=test_temp_dir)
            a = result.errors
            map = result.types
            nodes = map.keys()

            # Ignore NameExpr nodes of variables with explicit (trivial) types
            # to simplify output.
            searcher = SkippedNodeSearcher()
            for file in result.files.values():
                file.accept(searcher)
            ignored = searcher.nodes

            # Filter nodes that should be included in the output.
            keys = []
            for node in nodes:
                if node.line is not None and node.line != -1 and map[node]:
                    if ignore_node(node) or node in ignored:
                        continue
                    if (re.match(mask, short_type(node))
                            or (isinstance(node, NameExpr)
                                and re.match(mask, node.name))):
                        # Include node in output.
                        keys.append(node)

            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 run_test(self, testcase):
        implementation = testcase_python_implementation(testcase)

        a = []
        try:
            line = testcase.input[0]
            mask = ''
            if line.startswith('##'):
                mask = '(' + line[2:].strip() + ')$'

            src = '\n'.join(testcase.input)
            result = build.build(target=build.TYPE_CHECK,
                                 sources=[BuildSource('main', None, src)],
                                 implementation=implementation,
                                 flags=[build.TEST_BUILTINS],
                                 alt_lib_path=config.test_temp_dir)
            map = result.types
            nodes = map.keys()

            # Ignore NameExpr nodes of variables with explicit (trivial) types
            # to simplify output.
            searcher = VariableDefinitionNodeSearcher()
            for file in result.files.values():
                file.accept(searcher)
            ignored = searcher.nodes

            # Filter nodes that should be included in the output.
            keys = []
            for node in nodes:
                if node.line is not None and node.line != -1 and map[node]:
                    if ignore_node(node) or node in ignored:
                        continue
                    if (re.match(mask, short_type(node))
                            or (isinstance(node, NameExpr)
                                and re.match(mask, node.name))):
                        # Include node in output.
                        keys.append(node)

            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 visit_name_expr(self, o: 'mypy.nodes.NameExpr') -> str:
     pretty = self.pretty_name(o.name, o.kind, o.fullname,
                               o.is_inferred_def or o.is_special_form,
                               o.node)
     if isinstance(o.node, mypy.nodes.Var) and o.node.is_final:
         pretty += ' = {}'.format(o.node.final_value)
     return short_type(o) + '(' + pretty + ')'

 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.type() is not None:
         s += ' : {}'.format(self.type())
     return s

    def dump(self, nodes: Sequence[object], obj: 'mypy.nodes.Context') -> str:
        """Convert a list of items to a multiline pretty-printed string.

        The tag is produced from the type name of obj and its line
        number. See mypy.util.dump_tagged for a description of the nodes
        argument.
        """
        return dump_tagged(nodes, short_type(obj) + ':' + str(obj.get_line()))

 def __str__(self) -> str:
     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

 def dump_types(self, manager: BuildManager) -> List[str]:
     a = []
     # To make the results repeatable, we try to generate unique and
     # deterministic sort keys.
     for module_id in sorted(manager.modules):
         if not is_dumped_module(module_id):
             continue
         type_map = manager.saved_cache[module_id][2]
         if type_map:
             a.append('## {}'.format(module_id))
             for expr in sorted(type_map, key=lambda n: (n.line, short_type(n),
                                                         str(n) + str(type_map[n]))):
                 typ = type_map[expr]
                 a.append('{}:{}: {}'.format(short_type(expr),
                                             expr.line,
                                             self.format_type(typ)))
     return a

    def dump(self, nodes: Sequence[object], obj: 'mypy.nodes.Context') -> str:
        """Convert a list of items to a multiline pretty-printed string.

        The tag is produced from the type name of obj and its line
        number. See mypy.util.dump_tagged for a description of the nodes
        argument.
        """
        tag = short_type(obj) + ':' + str(obj.get_line())
        if self.show_ids:
            assert self.id_mapper is not None
            tag += '<{}>'.format(self.get_id(obj))
        return dump_tagged(nodes, tag, self)

 def visit_name_expr(self, o: 'mypy.nodes.NameExpr') -> str:
     return (short_type(o) + '(' + self.pretty_name(o.name, o.kind,
                                                    o.fullname, o.is_def)
             + ')')

        else:
            return None
    
    mypy.types.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
        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)
        

mypy.types.FunctionLike function_type(FuncBase func):
    if func.type:
        return (mypy.types.FunctionLike)func.type

from mypy.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):
        """The representation is of form Keyword('  if')."""
        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):
        """Replace common non-printable chars with escape sequences.

        Do not use repr() since we don't want do duplicate backslashes.
        """
        return s.replace('\n', '\\n').replace('\t', '\\t').replace('\r', '\\r')


# Token classes

 def visit_name_expr(self, o):
     return short_type(o) + "(" + self.pretty_name(o.name, o.kind, o.fullname, o.is_def) + ")"

 def visit_name_expr(self, o: 'mypy.nodes.NameExpr') -> str:
     pretty = self.pretty_name(o.name, o.kind, o.fullname, o.is_inferred_def, o.node)
     return short_type(o) + '(' + pretty + ')'

 def __repr__(self) -> str:
     """The representation is of form 'Keyword(  if)'."""
     t = short_type(self)
     return t + '(' + self.fix(self.pre) + self.fix(self.string) + ')'

 def visit_name_expr(self, o):
     return (short_type(o) + '(' + self.pretty_name(o.name, o.kind,
                                                    o.fullname, 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) + ')'