Properly convert compiled values to generic classes

jedi/inference/compiled/access.py

@@ -5,6 +5,7 @@ import sys
 import operator as op
 from collections import namedtuple
 import warnings
+import re
 
 from jedi._compatibility import unicode, is_py3, builtins, \
     py_version, force_unicode
@@ -491,10 +492,15 @@ class DirectObjectAccess(object):
         if sys.version_info < (3, 5):
             return None, ()
 
-        import typing
-        args = typing.get_args(self._obj)
-        origin = typing.get_origin(self._obj)
-        name = None if origin is None else str(origin)
+        name = None
+        args = ()
+        if safe_getattr(self._obj, '__module__', default='') == 'typing':
+            m = re.match(r'typing.(\w+)\[', repr(self._obj))
+            if m is not None:
+                name = m.group(1)
+
+                import typing
+                args = typing.get_args(self._obj)
         return name, tuple(self._create_access_path(arg) for arg in args)
 
     def needs_type_completions(self):

jedi/inference/compiled/value.py

@@ -273,9 +273,20 @@ class CompiledObject(Value):
             return ValueSet([self])
 
         name, args = self.access_handle.get_annotation_name_and_args()
-        arguments = [create_from_access_path(self.inference_state, path) for path in args]
-        if name == 'typing.Union':
+        arguments = [
+            ValueSet([create_from_access_path(self.inference_state, path)])
+            for path in args
+        ]
+        if name == 'Union':
             return ValueSet.from_sets(arg.execute_annotation() for arg in arguments)
+        elif name:
+            # While with_generics only exists on very specific objects, we
+            # should probably be fine, because we control all the typing
+            # objects.
+            return ValueSet([
+                v.with_generics(arguments)
+                for v in self.inference_state.typing_module.py__getattribute__(name)
+            ]).execute_annotation()
         return super(CompiledObject, self).execute_annotation()
 
     def negate(self):

jedi/inference/gradual/typing.py

@@ -16,7 +16,7 @@ from jedi.inference.names import NameWrapper, ValueName
 from jedi.inference.value.klass import ClassMixin
 from jedi.inference.gradual.base import BaseTypingValue, BaseTypingValueWithGenerics
 from jedi.inference.gradual.type_var import TypeVarClass
-from jedi.inference.gradual.generics import LazyGenericManager
+from jedi.inference.gradual.generics import LazyGenericManager, TupleGenericManager
 
 _PROXY_CLASS_TYPES = 'Tuple Generic Protocol Callable Type'.split()
 _TYPE_ALIAS_TYPES = {
@@ -144,6 +144,14 @@ class ProxyTypingValue(BaseTypingValue):
     index_class = TypingValueWithIndex
     py__simple_getitem__ = None
 
+    def with_generics(self, generics_tuple):
+        return self.index_class.create_cached(
+            self.inference_state,
+            self.parent_context,
+            self._tree_name,
+            generics_manager=TupleGenericManager(generics_tuple)
+        )
+
     def py__getitem__(self, index_value_set, contextualized_node):
         return ValueSet(
             self.index_class.create_cached(

jedi/inference/value/klass.py

@@ -286,6 +286,13 @@ class ClassValue(use_metaclass(CachedMetaClass, ClassMixin, FunctionAndClassBase
             for index_value in index_value_set
         )
 
+    def with_generics(self, generics_tuple):
+        from jedi.inference.gradual.base import GenericClass
+        return GenericClass(
+            self,
+            TupleGenericManager(generics_tuple)
+        )
+
     def define_generics(self, type_var_dict):
         from jedi.inference.gradual.base import GenericClass