ast_translator.py 文件源码

def _translate_subscript(self, value, slice, ctx, location):
        value_node = self._translate_node(value)
        value_general_type = self._general_type(value_node['pseudo_type'])
        if value_general_type not in INDEXABLE_TYPES:
            raise type_check_error('pseudo-python can use [] only on String, List, Dictionary or Tuple',
                location, self.lines[location[0]],
                wrong_type=value_node['pseudo_type'])

        if isinstance(slice, ast.Index):
            z = self._translate_node(slice.value)
            if value_general_type in ['String', 'List', 'Tuple'] and z['pseudo_type'] != 'Int':
                raise PseudoPythonTypeCheckError('a non int index for %s %s' % (value_general_type, z['pseudo_type']))

            if value_general_type == 'Dictionary' and z['pseudo_type'] != value_node['pseudo_type'][1]:
                raise PseudoPythonTypeCheckError('a non %s index for %s %s' % (value_node['pseudo_type'][1], value_general_type, z['pseudo_type']))

            if value_general_type == 'String':
                pseudo_type = 'String'
            elif value_general_type == 'List' or value_general_type == 'Array':
                pseudo_type = value_node['pseudo_type'][1]
            elif value_general_type == 'Tuple':
                if z['type'] != 'int':
                    raise PseudoPythonTypeCheckError('pseudo-python can support only literal int indices of a heterogenous tuple ' +
                                                     'because otherwise the index type is not predictable %s %s ' % (serialize_type(value_node['pseudo_type']), z['type']))

                elif z['value'] > len(value_node['pseudo_type']) - 2:
                    raise PseudoPythonTypeCheckError('%s has only %d elements' % serialize_type(value_node['pseudo_type']), len(value_node['pseudo_type']))

                pseudo_type = value_node['pseudo_type'][z['value'] + 1]

            else:
                pseudo_type = value_node['pseudo_type'][2]

            if 'special' in value_node: # sys.argv[index]
                if z['pseudo_type'] != 'Int':
                    raise type_check_error('pseudo-python supports only int indices for sys.argv',
                        location, self.lines[location[0]],
                        wrong_type=z['pseudo_type'])
                return {
                    'type': 'standard_call',
                    'namespace': 'system',
                    'function': 'index',
                    'args': [z],
                    'pseudo_type': 'String'
                }
            result = {
                'type': 'index',
                'sequence': value_node,
                'index': z,
                'pseudo_type': pseudo_type
            }
            if result in self._tuple_assigned:
                j = z.get('value', z.get('name', z.get('attr', '_x')))
                k = value_node.get('value', value_node.get('name', value_node.get('attr', '_y')))
                # i kno c:
                if not any(a[0] == '_old_%s_%s' % (j, k) for a in self._tuple_used):
                    self._tuple_used.append(('_old_%s_%s' % (j, k), result))
                result = {'type': 'local', 'name': '_old_%s_%s' % (j, k), 'pseudo_type': pseudo_type}
            return result
        else:
            return self._translate_slice(receiver=value_node, upper=slice.upper, step=slice.step, lower=slice.lower, location=location)