VimPlug/jedi-fork
1
0
Fork 0
forked from VimPlug/jedi
Code Pull Requests Activity

More unicode literals

Browse Source
This commit is contained in:
Dave Halter
2017-12-29 01:42:22 +01:00
parent 59c44fe499
commit b4f301e082
6 changed files with 26 additions and 26 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
jedi/evaluate/context/function.py
View File

@@ -146,7 +146,7 @@ class FunctionExecutionContext(TreeContext):
try: try:
children = r.children children = r.children
except AttributeError: except AttributeError:
ctx = compiled.builtin_from_name(self.evaluator, 'None') ctx = compiled.builtin_from_name(self.evaluator, u'None')
context_set |= ContextSet(ctx) context_set |= ContextSet(ctx)
else: else:
context_set |= self.eval_node(children[1]) context_set |= self.eval_node(children[1])
@@ -158,7 +158,7 @@ class FunctionExecutionContext(TreeContext):
def _eval_yield(self, yield_expr): def _eval_yield(self, yield_expr):
if yield_expr.type == 'keyword': if yield_expr.type == 'keyword':
# `yield` just yields None. # `yield` just yields None.
ctx = compiled.builtin_from_name(self.evaluator, 'None') ctx = compiled.builtin_from_name(self.evaluator, u'None')
yield LazyKnownContext(ctx) yield LazyKnownContext(ctx)
return return

2
jedi/evaluate/context/instance.py
View File

@@ -94,7 +94,7 @@ class AbstractInstanceContext(Context):
if isinstance(obj, AbstractInstanceContext): if isinstance(obj, AbstractInstanceContext):
return self.execute_function_slots(names, obj, obj.class_context) return self.execute_function_slots(names, obj, obj.class_context)
else: else:
none_obj = compiled.builtin_from_name(self.evaluator, 'None') none_obj = compiled.builtin_from_name(self.evaluator, u'None')
return self.execute_function_slots(names, none_obj, obj) return self.execute_function_slots(names, none_obj, obj)
else: else:
return ContextSet(self) return ContextSet(self)

36
jedi/evaluate/context/iterable.py
View File

@@ -223,7 +223,7 @@ class ArrayMixin(object):
class ListComprehension(ArrayMixin, Comprehension): class ListComprehension(ArrayMixin, Comprehension):
array_type = 'list' array_type = u'list'
def py__getitem__(self, index): def py__getitem__(self, index):
if isinstance(index, slice): if isinstance(index, slice):
@@ -234,12 +234,12 @@ class ListComprehension(ArrayMixin, Comprehension):
class SetComprehension(ArrayMixin, Comprehension): class SetComprehension(ArrayMixin, Comprehension):
array_type = 'set' array_type = u'set'
@has_builtin_methods @has_builtin_methods
class DictComprehension(ArrayMixin, Comprehension): class DictComprehension(ArrayMixin, Comprehension):
array_type = 'dict' array_type = u'dict'
def _get_comp_for(self): def _get_comp_for(self):
return self._get_comprehension().children[3] return self._get_comprehension().children[3]
@@ -262,18 +262,18 @@ class DictComprehension(ArrayMixin, Comprehension):
@register_builtin_method('values') @register_builtin_method('values')
def _imitate_values(self): def _imitate_values(self):
lazy_context = LazyKnownContexts(self.dict_values()) lazy_context = LazyKnownContexts(self.dict_values())
return ContextSet(FakeSequence(self.evaluator, 'list', [lazy_context])) return ContextSet(FakeSequence(self.evaluator, u'list', [lazy_context]))
@register_builtin_method('items') @register_builtin_method('items')
def _imitate_items(self): def _imitate_items(self):
items = ContextSet.from_iterable( items = ContextSet.from_iterable(
FakeSequence( FakeSequence(
self.evaluator, 'tuple' self.evaluator, u'tuple'
(LazyKnownContexts(keys), LazyKnownContexts(values)) (LazyKnownContexts(keys), LazyKnownContexts(values))
) for keys, values in self._iterate() ) for keys, values in self._iterate()
) )
return create_evaluated_sequence_set(self.evaluator, items, sequence_type='list') return create_evaluated_sequence_set(self.evaluator, items, sequence_type=u'list')
class GeneratorComprehension(GeneratorMixin, Comprehension): class GeneratorComprehension(GeneratorMixin, Comprehension):
@@ -281,9 +281,9 @@ class GeneratorComprehension(GeneratorMixin, Comprehension):
class SequenceLiteralContext(ArrayMixin, AbstractIterable): class SequenceLiteralContext(ArrayMixin, AbstractIterable):
mapping = {'(': 'tuple', mapping = {'(': u'tuple',
'[': 'list', '[': u'list',
'{': 'set'} '{': u'set'}
def __init__(self, evaluator, defining_context, atom): def __init__(self, evaluator, defining_context, atom):
super(SequenceLiteralContext, self).__init__(evaluator) super(SequenceLiteralContext, self).__init__(evaluator)
@@ -291,14 +291,14 @@ class SequenceLiteralContext(ArrayMixin, AbstractIterable):
self._defining_context = defining_context self._defining_context = defining_context
if self.atom.type in ('testlist_star_expr', 'testlist'): if self.atom.type in ('testlist_star_expr', 'testlist'):
self.array_type = 'tuple' self.array_type = u'tuple'
else: else:
self.array_type = SequenceLiteralContext.mapping[atom.children[0]] self.array_type = SequenceLiteralContext.mapping[atom.children[0]]
"""The builtin name of the array (list, set, tuple or dict).""" """The builtin name of the array (list, set, tuple or dict)."""
def py__getitem__(self, index): def py__getitem__(self, index):
"""Here the index is an int/str. Raises IndexError/KeyError.""" """Here the index is an int/str. Raises IndexError/KeyError."""
if self.array_type == 'dict': if self.array_type == u'dict':
compiled_obj_index = compiled.create_simple_object(self.evaluator, index) compiled_obj_index = compiled.create_simple_object(self.evaluator, index)
for key, value in self._items(): for key, value in self._items():
for k in self._defining_context.eval_node(key): for k in self._defining_context.eval_node(key):
@@ -318,7 +318,7 @@ class SequenceLiteralContext(ArrayMixin, AbstractIterable):
While values returns the possible values for any array field, this While values returns the possible values for any array field, this
function returns the value for a certain index. function returns the value for a certain index.
""" """
if self.array_type == 'dict': if self.array_type == u'dict':
# Get keys. # Get keys.
types = ContextSet() types = ContextSet()
for k, _ in self._items(): for k, _ in self._items():
@@ -336,7 +336,7 @@ class SequenceLiteralContext(ArrayMixin, AbstractIterable):
def _values(self): def _values(self):
"""Returns a list of a list of node.""" """Returns a list of a list of node."""
if self.array_type == 'dict': if self.array_type == u'dict':
return ContextSet.from_sets(v for k, v in self._items()) return ContextSet.from_sets(v for k, v in self._items())
else: else:
return self._items() return self._items()
@@ -384,7 +384,7 @@ class SequenceLiteralContext(ArrayMixin, AbstractIterable):
@has_builtin_methods @has_builtin_methods
class DictLiteralContext(SequenceLiteralContext): class DictLiteralContext(SequenceLiteralContext):
array_type = 'dict' array_type = u'dict'
def __init__(self, evaluator, defining_context, atom): def __init__(self, evaluator, defining_context, atom):
super(SequenceLiteralContext, self).__init__(evaluator) super(SequenceLiteralContext, self).__init__(evaluator)
@@ -394,19 +394,19 @@ class DictLiteralContext(SequenceLiteralContext):
@register_builtin_method('values') @register_builtin_method('values')
def _imitate_values(self): def _imitate_values(self):
lazy_context = LazyKnownContexts(self.dict_values()) lazy_context = LazyKnownContexts(self.dict_values())
return ContextSet(FakeSequence(self.evaluator, 'list', [lazy_context])) return ContextSet(FakeSequence(self.evaluator, u'list', [lazy_context]))
@register_builtin_method('items') @register_builtin_method('items')
def _imitate_items(self): def _imitate_items(self):
lazy_contexts = [ lazy_contexts = [
LazyKnownContext(FakeSequence( LazyKnownContext(FakeSequence(
self.evaluator, 'tuple', self.evaluator, u'tuple',
(LazyTreeContext(self._defining_context, key_node), (LazyTreeContext(self._defining_context, key_node),
LazyTreeContext(self._defining_context, value_node)) LazyTreeContext(self._defining_context, value_node))
)) for key_node, value_node in self._items() )) for key_node, value_node in self._items()
] ]
return ContextSet(FakeSequence(self.evaluator, 'list', lazy_contexts)) return ContextSet(FakeSequence(self.evaluator, u'list', lazy_contexts))
class _FakeArray(SequenceLiteralContext): class _FakeArray(SequenceLiteralContext):
@@ -440,7 +440,7 @@ class FakeSequence(_FakeArray):
class FakeDict(_FakeArray): class FakeDict(_FakeArray):
def __init__(self, evaluator, dct): def __init__(self, evaluator, dct):
super(FakeDict, self).__init__(evaluator, dct, 'dict') super(FakeDict, self).__init__(evaluator, dct, u'dict')
self._dct = dct self._dct = dct
def py__iter__(self): def py__iter__(self):

2
jedi/evaluate/context/klass.py
View File

@@ -146,7 +146,7 @@ class ClassContext(use_metaclass(CachedMetaClass, TreeContext)):
return ContextSet(TreeInstance(self.evaluator, self.parent_context, self, params)) return ContextSet(TreeInstance(self.evaluator, self.parent_context, self, params))
def py__class__(self): def py__class__(self):
return compiled.builtin_from_name(self.evaluator, 'type') return compiled.builtin_from_name(self.evaluator, u'type')
def get_params(self): def get_params(self):
from jedi.evaluate.context import AnonymousInstance from jedi.evaluate.context import AnonymousInstance

2
jedi/evaluate/context/module.py
View File

@@ -25,7 +25,7 @@ class _ModuleAttributeName(AbstractNameDefinition):
self.string_name = string_name self.string_name = string_name
def infer(self): def infer(self):
ctx = compiled.builtin_from_name(self.parent_context.evaluator, 'str') ctx = compiled.builtin_from_name(self.parent_context.evaluator, u'str')
return ctx.execute_evaluated() return ctx.execute_evaluated()

6
jedi/evaluate/syntax_tree.py
View File

@@ -102,7 +102,7 @@ def eval_node(context, element):
# In Python 2 ellipsis is coded as three single dot tokens, not # In Python 2 ellipsis is coded as three single dot tokens, not
# as one token 3 dot token. # as one token 3 dot token.
assert element.value in ('.', '...') assert element.value in ('.', '...')
return ContextSet(compiled.builtin_from_name(evaluator, 'Ellipsis')) return ContextSet(compiled.builtin_from_name(evaluator, u'Ellipsis'))
elif typ == 'dotted_name': elif typ == 'dotted_name':
context_set = eval_atom(context, element.children[0]) context_set = eval_atom(context, element.children[0])
for next_name in element.children[2::2]: for next_name in element.children[2::2]:
@@ -183,7 +183,7 @@ def eval_atom(context, atom):
context_set = eval_atom(context, c[0]) context_set = eval_atom(context, c[0])
for string in c[1:]: for string in c[1:]:
right = eval_atom(context, string) right = eval_atom(context, string)
context_set = _eval_comparison(context.evaluator, context, context_set, '+', right) context_set = _eval_comparison(context.evaluator, context, context_set, u'+', right)
return context_set return context_set
# Parentheses without commas are not tuples. # Parentheses without commas are not tuples.
elif c[0] == '(' and not len(c) == 2 \ elif c[0] == '(' and not len(c) == 2 \
@@ -362,7 +362,7 @@ def _is_list(context):
def _bool_to_context(evaluator, bool_): def _bool_to_context(evaluator, bool_):
return compiled.builtin_from_name(evaluator, str(bool_)) return compiled.builtin_from_name(evaluator, force_unicode(str(bool_)))
def _eval_comparison_part(evaluator, context, left, operator, right): def _eval_comparison_part(evaluator, context, left, operator, right):