Try to use yield from instead of yield, if possible

jedi/inference/value/dynamic_arrays.py

@@ -155,14 +155,12 @@ class _DynamicArrayAdditions(HelperValueMixin):
         except StopIteration:
             pass
         else:
-            for lazy in lazy_value.infer().iterate():
-                yield lazy
+            yield from lazy_value.infer().iterate()
 
         from jedi.inference.arguments import TreeArguments
         if isinstance(arguments, TreeArguments):
             additions = _internal_check_array_additions(arguments.context, self._instance)
-            for addition in additions:
-                yield addition
+            yield from additions
 
     def iterate(self, contextualized_node=None, is_async=False):
         return self.py__iter__(contextualized_node)
@@ -189,8 +187,7 @@ class _Modification(ValueWrapper):
 
 class DictModification(_Modification):
     def py__iter__(self, contextualized_node=None):
-        for lazy_context in self._wrapped_value.py__iter__(contextualized_node):
-            yield lazy_context
+        yield from self._wrapped_value.py__iter__(contextualized_node)
         yield self._contextualized_key
 
     def get_key_values(self):
@@ -199,6 +196,5 @@ class DictModification(_Modification):
 
 class ListModification(_Modification):
     def py__iter__(self, contextualized_node=None):
-        for lazy_context in self._wrapped_value.py__iter__(contextualized_node):
-            yield lazy_context
+        yield from self._wrapped_value.py__iter__(contextualized_node)
         yield LazyKnownValues(self._assigned_values)

jedi/inference/value/function.py

@@ -59,8 +59,7 @@ class FunctionMixin(object):
     def get_filters(self, origin_scope=None):
         cls = self.py__class__()
         for instance in cls.execute_with_values():
-            for filter in instance.get_filters(origin_scope=origin_scope):
-                yield filter
+            yield from instance.get_filters(origin_scope=origin_scope)
 
     def py__get__(self, instance, class_value):
         from jedi.inference.value.instance import BoundMethod
@@ -256,8 +255,7 @@ class BaseFunctionExecutionContext(ValueContext, TreeContextMixin):
         node = yield_expr.children[1]
         if node.type == 'yield_arg':  # It must be a yield from.
             cn = ContextualizedNode(self, node.children[1])
-            for lazy_value in cn.infer().iterate(cn):
-                yield lazy_value
+            yield from cn.infer().iterate(cn)
         else:
             yield LazyTreeValue(self, node)
 
@@ -296,8 +294,7 @@ class BaseFunctionExecutionContext(ValueContext, TreeContextMixin):
             if for_stmt is None:
                 # No for_stmt, just normal yields.
                 for yield_ in yields:
-                    for result in self._get_yield_lazy_value(yield_):
-                        yield result
+                    yield from self._get_yield_lazy_value(yield_)
             else:
                 input_node = for_stmt.get_testlist()
                 cn = ContextualizedNode(self, input_node)
@@ -307,8 +304,7 @@ class BaseFunctionExecutionContext(ValueContext, TreeContextMixin):
                     dct = {str(for_stmt.children[1].value): lazy_value.infer()}
                     with self.predefine_names(for_stmt, dct):
                         for yield_in_same_for_stmt in yields:
-                            for result in self._get_yield_lazy_value(yield_in_same_for_stmt):
-                                yield result
+                            yield from self._get_yield_lazy_value(yield_in_same_for_stmt)
 
     def merge_yield_values(self, is_async=False):
         return ValueSet.from_sets(

jedi/inference/value/instance.py

@@ -255,8 +255,7 @@ class _BaseTreeInstance(AbstractInstanceValue):
 
         def iterate():
             for generator in self.execute_function_slots(iter_slot_names):
-                for lazy_value in generator.py__next__(contextualized_node):
-                    yield lazy_value
+                yield from generator.py__next__(contextualized_node)
         return iterate()
 
     def py__next__(self, contextualized_node=None):
@@ -526,8 +525,7 @@ class LazyInstanceClassName(NameWrapper):
     @iterator_to_value_set
     def infer(self):
         for result_value in self._wrapped_name.infer():
-            for c in result_value.py__get__(self._instance, self._instance.py__class__()):
-                yield c
+            yield from result_value.py__get__(self._instance, self._instance.py__class__())
 
     def get_signatures(self):
         return self.infer().get_signatures()
@@ -616,5 +614,4 @@ class InstanceArguments(TreeArgumentsWrapper):
 
     def unpack(self, func=None):
         yield None, LazyKnownValue(self.instance)
-        for values in self._wrapped_arguments.unpack(func):
-            yield values
+        yield from self._wrapped_arguments.unpack(func)

jedi/inference/value/iterable.py

@@ -153,8 +153,7 @@ class ComprehensionMixin(object):
             )
             with context.predefine_names(comp_for, dct):
                 try:
-                    for result in self._nested(comp_fors[1:], context):
-                        yield result
+                    yield from self._nested(comp_fors[1:], context)
                 except IndexError:
                     iterated = context.infer_node(self._entry_node)
                     if self.array_type == 'dict':
@@ -166,8 +165,7 @@ class ComprehensionMixin(object):
     @to_list
     def _iterate(self):
         comp_fors = tuple(get_sync_comp_fors(self._sync_comp_for_node))
-        for result in self._nested(comp_fors):
-            yield result
+        yield from self._nested(comp_fors)
 
     def py__iter__(self, contextualized_node=None):
         for set_ in self._iterate():
@@ -358,8 +356,7 @@ class SequenceLiteralValue(Sequence):
                 yield LazyKnownValue(Slice(self._defining_context, None, None, None))
             else:
                 yield LazyTreeValue(self._defining_context, node)
-        for addition in check_array_additions(self._defining_context, self):
-            yield addition
+        yield from check_array_additions(self._defining_context, self)
 
     def py__len__(self):
         # This function is not really used often. It's more of a try.
@@ -566,8 +563,7 @@ class MergedArray(Sequence):
 
     def py__iter__(self, contextualized_node=None):
         for array in self._arrays:
-            for lazy_value in array.py__iter__():
-                yield lazy_value
+            yield from array.py__iter__()
 
     def py__simple_getitem__(self, index):
         return ValueSet.from_sets(lazy_value.infer() for lazy_value in self.py__iter__())

jedi/inference/value/klass.py

@@ -68,8 +68,7 @@ class ClassName(TreeNameDefinition):
 
         for result_value in inferred:
             if self._apply_decorators:
-                for c in result_value.py__get__(instance=None, class_value=self._class_value):
-                    yield c
+                yield from result_value.py__get__(instance=None, class_value=self._class_value)
             else:
                 yield result_value
 

jedi/inference/value/module.py

@@ -67,8 +67,7 @@ class ModuleMixin(SubModuleDictMixin):
         )
         yield DictFilter(self.sub_modules_dict())
         yield DictFilter(self._module_attributes_dict())
-        for star_filter in self.iter_star_filters():
-            yield star_filter
+        yield from self.iter_star_filters()
 
     def py__class__(self):
         c, = values_from_qualified_names(self.inference_state, 'types', 'ModuleType')