Set TArgs to TParams rather than Any when creating Type::SelfType

Summary: This fixes a few bugs around generic classes.

Reviewed By: grievejia

Differential Revision: D72358521

fbshipit-source-id: f746c081abbc4a6895c9dc2cf2964f3fced801ec

Author: rchen152

conformance/third_party/conformance.exp

@@ -5484,13 +5484,23 @@
     {
       "code": -2,
       "column": 1,
-      "concise_description": "assert_type((Self) -> Self, (Foo7[int]) -> Foo7[int]) failed",
-      "description": "assert_type((Self) -> Self, (Foo7[int]) -> Foo7[int]) failed",
+      "concise_description": "assert_type(Any, (Foo7[int]) -> Foo7[int]) failed",
+      "description": "assert_type(Any, (Foo7[int]) -> Foo7[int]) failed",
       "line": 166,
       "name": "assert-type",
       "stop_column": 57,
       "stop_line": 166
     },
+    {
+      "code": -2,
+      "column": 13,
+      "concise_description": "Generic attribute `meth` of class `Foo7` is not visible on the class",
+      "description": "Generic attribute `meth` of class `Foo7` is not visible on the class",
+      "line": 166,
+      "name": "missing-attribute",
+      "stop_column": 22,
+      "stop_line": 166
+    },
     {
       "code": -2,
       "column": 1,
@@ -6959,26 +6969,6 @@
     }
   ],
   "generics_typevartuple_basic.py": [
-    {
-      "code": -2,
-      "column": 38,
-      "concise_description": "`?Shape` is not assignable to attribute `_shape` with type `Unknown`",
-      "description": "`?Shape` is not assignable to attribute `_shape` with type `Unknown`",
-      "line": 25,
-      "name": "bad-assignment",
-      "stop_column": 43,
-      "stop_line": 25
-    },
-    {
-      "code": -2,
-      "column": 16,
-      "concise_description": "Returned type `Unknown` is not assignable to declared return type `?Shape`",
-      "description": "Returned type `Unknown` is not assignable to declared return type `?Shape`",
-      "line": 28,
-      "name": "bad-return",
-      "stop_column": 27,
-      "stop_line": 28
-    },
     {
       "code": -2,
       "column": 34,

conformance/third_party/conformance.result

@@ -318,7 +318,7 @@
     "Line 148: Unexpected errors ['Class `Foo6` uses type variables not specified in `Generic` or `Protocol` base']",
     "Line 151: Unexpected errors ['assert_type(type[Foo6[Ellipsis, tuple[str]]], type[Foo6[Ellipsis, tuple[str, (float, bool)]]]) failed', 'Expected a valid ParamSpec expression', 'Expected a valid ParamSpec expression']",
     "Line 152: Unexpected errors ['Expected a valid ParamSpec expression', 'Expected a valid ParamSpec expression']",
-    "Line 166: Unexpected errors ['assert_type((Self) -> Self, (Foo7[int]) -> Foo7[int]) failed']",
+    "Line 166: Unexpected errors ['assert_type(Any, (Foo7[int]) -> Foo7[int]) failed', 'Generic attribute `meth` of class `Foo7` is not visible on the class']",
     "Line 167: Unexpected errors ['assert_type(Any, int) failed', 'Instance-only attribute `attr` of class `Foo7` is not visible on the class']"
   ],
   "generics_defaults_referential.py": [
@@ -417,8 +417,6 @@
   "generics_type_erasure.py": [],
   "generics_typevartuple_args.py": [],
   "generics_typevartuple_basic.py": [
-    "Line 25: Unexpected errors ['`?Shape` is not assignable to attribute `_shape` with type `Unknown`']",
-    "Line 28: Unexpected errors ['Returned type `Unknown` is not assignable to declared return type `?Shape`']",
     "Line 85: Unexpected errors ['Argument `tuple[float]` is not assignable to parameter `arg2` with type `tuple[int]` in function `func2`']"
   ],
   "generics_typevartuple_callable.py": [],

conformance/third_party/results.json

@@ -3,7 +3,7 @@
   "pass": 41,
   "fail": 92,
   "pass_rate": 0.31,
-  "differences": 473,
+  "differences": 471,
   "passing": [
     "annotations_coroutines.py",
     "callables_protocol.py",
@@ -100,7 +100,7 @@
     "generics_syntax_declarations.py": 5,
     "generics_syntax_infer_variance.py": 7,
     "generics_syntax_scoping.py": 8,
-    "generics_typevartuple_basic.py": 3,
+    "generics_typevartuple_basic.py": 1,
     "generics_typevartuple_concat.py": 1,
     "generics_typevartuple_specialization.py": 7,
     "generics_upper_bound.py": 1,

pyre2/lib/alt/function.rs

@@ -179,7 +179,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             None
         } else {
             defining_cls.as_ref().map(|cls| {
-                let cls_type = ClassType::new(cls.dupe(), self.create_default_targs(cls, None));
+                let cls_type = ClassType::new(cls.dupe(), cls.tparams_as_targs());
                 Type::SelfType(cls_type)
             })
         };

pyre2/lib/alt/solve.rs

@@ -209,8 +209,7 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 {
                     let class = &*self.get_idx(*class_key);
                     if let Some(cls) = &class.0 {
-                        let cls_type =
-                            ClassType::new(cls.dupe(), self.create_default_targs(cls, None));
+                        let cls_type = ClassType::new(cls.dupe(), cls.tparams_as_targs());
                         ty.subst_self_special_form_mut(&Type::SelfType(cls_type));
                     }
                 }

pyre2/lib/test/constructors.rs

@@ -50,35 +50,45 @@ Box[int]("oops")  # E: Argument `Literal['oops']` is not assignable to parameter
 );
 
 testcase!(
-    bug = "Inside __init__, self should be parameterized with the same T as x, instead of defaulting to Unknown",
     test_self_in_generic_class,
     r#"
 from typing import reveal_type
 class A[T]:
     x: T
     def __init__(self, x: T):
         reveal_type(self)  # E: revealed type: Self@A
-        reveal_type(self.x)  # E: revealed type: Unknown
-        self.x = 1  # This shouldn't be allowed
+        reveal_type(self.x)  # E: revealed type: ?T
+        self.x = 1  # E: `Literal[1]` is not assignable to attribute `x` with type `?T`
         self.x = x  # OK
     "#,
 );
 
 testcase!(
-    bug = "int should not be assignable to type var with upper bound = int",
     test_bounded_self_in_generic_class,
     r#"
 from typing import reveal_type
 class A[T: int]:
     x: T
     def __init__(self, x: T):
         reveal_type(self)  # E: revealed type: Self@A
-        reveal_type(self.x)  # E: revealed type: int
-        self.x = 1  # Not OK
+        reveal_type(self.x)  # E: revealed type: ?T
+        self.x = 1  # E: `Literal[1]` is not assignable to attribute `x` with type `?T`
         self.x = x  # OK
     "#,
 );
 
+testcase!(
+    test_typing_self_param_in_generic_class,
+    r#"
+from typing import Self, reveal_type
+class A[T]:
+    x: T
+    def __init__(self, other: Self):
+        reveal_type(other.x)  # E: revealed type: ?T
+        self.x = other.x  # OK
+    "#,
+);
+
 testcase!(
     test_generic_init_in_generic_class,
     r#"

pyre2/lib/test/type_var_tuple.rs

@@ -48,19 +48,18 @@ Ts = TypeVarTuple('Ts')
 );
 
 testcase!(
-    bug = "C2 shouldn't give an error here",
     test_type_var_tuple_class_field_and_constructor,
     r#"
 class C1[T]:
-    x: tuple[T]
-    def __init__(self, x: tuple[T]) -> None:
+    x: tuple[T, ...]
+    def __init__(self, x: tuple[T, ...]) -> None:
         self.x = x
-        self.y: T = x
+        self.y: T = x  # E: `tuple[?T, ...]` is not assignable to attribute `y` with type `?T`
 class C2[*Ts]:
     x: tuple[*Ts]
     def __init__(self, x: tuple[*Ts]) -> None:
-        self.x = x  # E: `?Ts` is not assignable to attribute `x` with type `Unknown`
-        self.y: tuple[*Ts] = x  # E: `?Ts` is not assignable to attribute `y` with type `Unknown`
+        self.x = x
+        self.y: tuple[*Ts] = x
 "#,
 );