Feat: not implement keyof this

crates/stc_ts_file_analyzer/src/analyzer/types/keyof.rs

@@ -297,6 +297,12 @@ impl Analyzer<'_, '_> {
                         .context("tried to get keys of Array (builtin)");
                 }
 
+                Type::This(this) => {
+                    if let Some(ty) = self.scope.this().map(Cow::into_owned) {
+                        return self.keyof(this.span, &ty);
+                    }
+                }
+
                 Type::Interface(..) | Type::Enum(..) => {
                     let ty = self
                         .convert_type_to_type_lit(span, ty.freezed(), Default::default())?

crates/stc_ts_file_analyzer/src/analyzer/types/mod.rs

@@ -578,12 +578,14 @@ impl Analyzer<'_, '_> {
                                 return Ok(ty);
                             }
 
-                            let ty = self
-                                .normalize(span, Cow::Owned(prop_ty), opts)
-                                .context("tried to normalize the type of property")?
-                                .into_owned();
-
-                            return Ok(Cow::Owned(ty));
+                            let prev_this = self.scope.this.take();
+                            self.scope.this = Some(*obj_ty);
+                            let result = {
+                                self.normalize(span, Cow::Owned(prop_ty), opts)
+                                    .context("tried to normalize the type of property")
+                            };
+                            self.scope.this = prev_this;
+                            return result;
                         }
                         // TODO(kdy1):
 

crates/stc_ts_file_analyzer/tests/pass-only/conformance/types/conditional/conditionalTypes1/4.ts

@@ -0,0 +1,16 @@
+// @strict: true
+// @declaration: true
+
+type OldDiff<T extends keyof any, U extends keyof any> = (
+    & { [P in T]: P; }
+    & { [P in U]: never; }
+    & { [x: string]: never; }
+)[T];
+interface A {
+    a: 'a';
+}
+interface B1 extends A {
+    b: 'b';
+    c: OldDiff<keyof this, keyof A>;
+}
+type c1 = B1['c']; // 'c' | 'b'

crates/stc_ts_type_checker/tests/conformance/types/conditional/conditionalTypes1.error-diff.json

@@ -30,15 +30,11 @@
     ]
   },
   "extra_errors": {
-    "TS2322": 1,
-    "TS2344": 1
+    "TS2322": 1
   },
   "extra_error_lines": {
     "TS2322": [
       21
-    ],
-    "TS2344": [
-      317
     ]
   }
 }

crates/stc_ts_type_checker/tests/conformance/types/conditional/conditionalTypes1.stats.rust-debug

@@ -1,6 +1,6 @@
 Stats {
     required_error: 11,
     matched_error: 9,
-    extra_error: 2,
+    extra_error: 1,
     panic: 0,
 }

crates/stc_ts_type_checker/tests/tsc-stats.rust-debug

@@ -1,6 +1,6 @@
 Stats {
     required_error: 3502,
     matched_error: 6533,
-    extra_error: 769,
+    extra_error: 768,
     panic: 74,
 }