rework so that it also works withouty pep0484 type hints in jedi_typing.py

jedi/evaluate/pep0484.py

@@ -21,8 +21,7 @@ x support for type hint comments `# type: (int, str) -> int`. See comment from
 from itertools import chain
 
 import os
-from jedi.parser import \
-    Parser, load_grammar, ParseError, tree, ParserWithRecovery
+from jedi.parser import Parser, load_grammar, ParseError, ParserWithRecovery
 from jedi.evaluate.cache import memoize_default
 from jedi.evaluate import compiled
 from jedi import debug
@@ -31,28 +30,34 @@ from jedi import debug
 def _evaluate_for_annotation(evaluator, annotation):
     if annotation is not None:
         definitions = set()
+        module = annotation.get_parent_until()
         for definition in evaluator.eval_element(annotation):
-            if (isinstance(definition, compiled.CompiledObject) and
-                    isinstance(definition.obj, str)):
-                try:
-                    p = Parser(
-                        load_grammar(), definition.obj, start='eval_input')
-                    element = p.get_parsed_node()
-                except ParseError:
-                    debug.warning('Annotation not parsed: %s' % definition.obj)
-                else:
-                    module = annotation.get_parent_until()
-                    p.position_modifier.line = module.end_pos[0]
-                    element.parent = module
-                    definitions |= evaluator.eval_element(element)
-            else:
-                definitions.add(definition)
+            definitions |= \
+                _fix_forward_reference(evaluator, definition, module)
         return list(chain.from_iterable(
             evaluator.execute(d) for d in definitions))
     else:
         return []
 
 
+def _fix_forward_reference(evaluator, item, module):
+    if (isinstance(item, compiled.CompiledObject) and
+            isinstance(item.obj, str)):
+        try:
+            p = Parser(
+                load_grammar(), item.obj, start='eval_input')
+            element = p.get_parsed_node()
+        except ParseError:
+            debug.warning('Annotation not parsed: %s' % item.obj)
+            return set()
+        else:
+            p.position_modifier.line = module.end_pos[0]
+            element.parent = module
+            return evaluator.eval_element(element)
+    else:
+        return {item}
+
+
 @memoize_default(None, evaluator_is_first_arg=True)
 def follow_param(evaluator, param):
     annotation = param.annotation()
@@ -66,7 +71,7 @@ def find_return_types(evaluator, func):
 
 
 # TODO: Memoize
-def get_typing_replacement_module():
+def _get_typing_replacement_module():
     """
     The idea is to return our jedi replacement for the PEP-0484 typing module
     as discussed at https://github.com/davidhalter/jedi/issues/663
@@ -79,27 +84,35 @@ def get_typing_replacement_module():
     return p.module
 
 
-def get_types_for_typing_module(evaluator, typ, index):
-    from jedi.evaluate.representation import Class
-    if not typ.base.get_parent_until(tree.Module).name.value == "typing":
+def get_types_for_typing_module(evaluator, typ, trailer):
+    if not typ.base.get_parent_until().name.value == "typing":
         return None
     # we assume that any class using [] in a module called
     # "typing" with a name for which we have a replacement
     # should be replaced by that class. This is not 100%
     # airtight but I don't have a better idea to check that it's
     # actually the PEP-0484 typing module and not some other
-    typing = get_typing_replacement_module()
+    indextypes = evaluator.eval_element(trailer.children[1])
+    if not isinstance(indextypes, set):
+        indextypes = {indextypes}
+
+    module = trailer.get_parent_until()
+    dereferencedindextypes = set()
+    for indextyp in indextypes:
+        dereferencedindextypes |= \
+            _fix_forward_reference(evaluator, indextyp, module)
+
+    typing = _get_typing_replacement_module()
     factories = evaluator.find_types(typing, "factory")
     assert len(factories) == 1
     factory = list(factories)[0]
     assert factory
     compiled_classname = compiled.create(evaluator, typ.name.value)
-    if isinstance(index, Class):
-        index_obj = index
-    else:
-        index_obj = compiled.create(evaluator, index)
-    result = \
-        evaluator.execute_evaluated(factory, compiled_classname, index_obj)
+
+    result = set()
+    for indextyp in dereferencedindextypes:
+        result |= \
+            evaluator.execute_evaluated(factory, compiled_classname, indextyp)
     if result:
         return result
     else: