[flow][tslib] Delete dead ETSSyntax error variants for unconditionally-accepted TS syntax

Summary:
The `TSUnknown`, `TSKeyof`, and `TSTypeParamExtends` variants of `ts_syntax_kind` were defined and matched in code-action handlers but never actually emitted: `unknown`, `keyof`, and `T extends U` in type-parameter bounds are all accepted unconditionally by the type-annotation converter, so the corresponding `ETSSyntax` errors are never produced and the `Convert to mixed` / `Convert to $Keys<T>` / `Convert to : T` autofixes can never fire. Removes the variants from `error_message.ml`, the matching `MessageTS*` cases from `flow_intermediate_error_types.ml` and `flow_intermediate_error.ml`, the dead handlers in `code_action_service.ml`, and the unused `convert_unknown_type` / `convert_keyof_type` / `convert_type_param_extends` autofix functions (plus their type-mapper cases) in `autofix_ts_syntax.ml`/`.mli`.

Changelog: [internal]

Reviewed By: marcoww6

Differential Revision: D105753396

fbshipit-source-id: 1b9278151cc4d7ff5005def0442fd744192185fd

Author: gkz

rust_port/crates/flow_services_code_action/src/autofix_ts_syntax.rs

@@ -25,13 +25,10 @@ use crate::contains_mapper::ContainsMapper;
 
 #[derive(PartialEq, Eq)]
 enum Kind {
-    UnknownType,
     NeverType,
     UndefinedType,
-    KeyofType,
     ReadOnlyArrayType,
     ReadOnlyTupleType,
-    TypeParamExtends,
     TypeParamColon,
     InOutVariance,
     ReadonlyVariance,
@@ -61,11 +58,6 @@ impl AstVisitor<'_, Loc> for Mapper {
 
     fn map_type_(&mut self, t: &ast::types::Type<Loc, Loc>) -> ast::types::Type<Loc, Loc> {
         match &**t {
-            TypeInner::Unknown { loc, comments }
-                if self.kind == Kind::UnknownType && self.contains.is_target(loc) =>
-            {
-                ast_builder::types::mixed(None, comments.clone())
-            }
             TypeInner::Never { loc, comments }
                 if self.kind == Kind::NeverType && self.contains.is_target(loc) =>
             {
@@ -76,21 +68,6 @@ impl AstVisitor<'_, Loc> for Mapper {
             {
                 ast_builder::types::void(None, comments.clone())
             }
-            TypeInner::Keyof { loc, inner }
-                if self.kind == Kind::KeyofType && self.contains.is_target(loc) =>
-            {
-                let targs = ast_builder::types::type_args(
-                    None,
-                    None,
-                    vec![map_type_default(self, &inner.argument)],
-                );
-                ast_builder::types::unqualified_generic(
-                    inner.comments.clone(),
-                    None,
-                    Some(targs),
-                    "$Keys",
-                )
-            }
             TypeInner::ReadOnly { loc, inner }
                 if self.kind == Kind::ReadOnlyArrayType && self.contains.is_target(loc) =>
             {
@@ -144,17 +121,6 @@ impl AstVisitor<'_, Loc> for Mapper {
     ) -> ast::types::TypeParam<Loc, Loc> {
         use ast::types::type_param::BoundKind;
         match tparam {
-            ast::types::TypeParam {
-                bound_kind: BoundKind::Extends,
-                loc,
-                ..
-            } if self.kind == Kind::TypeParamExtends && self.contains.is_target(loc) => {
-                ast::types::TypeParam {
-                    loc: LOC_NONE,
-                    bound_kind: BoundKind::Colon,
-                    ..tparam.clone()
-                }
-            }
             ast::types::TypeParam {
                 bound_kind: BoundKind::Colon,
                 loc,
@@ -310,14 +276,6 @@ impl AstVisitor<'_, Loc> for Mapper {
     }
 }
 
-pub fn convert_unknown_type(ast: &ast::Program<Loc, Loc>, loc: Loc) -> ast::Program<Loc, Loc> {
-    let mut mapper = Mapper {
-        contains: ContainsMapper::new(loc),
-        kind: Kind::UnknownType,
-    };
-    mapper.map_program(ast)
-}
-
 pub fn convert_never_type(ast: &ast::Program<Loc, Loc>, loc: Loc) -> ast::Program<Loc, Loc> {
     let mut mapper = Mapper {
         contains: ContainsMapper::new(loc),
@@ -334,25 +292,6 @@ pub fn convert_undefined_type(ast: &ast::Program<Loc, Loc>, loc: Loc) -> ast::Pr
     mapper.map_program(ast)
 }
 
-pub fn convert_keyof_type(ast: &ast::Program<Loc, Loc>, loc: Loc) -> ast::Program<Loc, Loc> {
-    let mut mapper = Mapper {
-        contains: ContainsMapper::new(loc),
-        kind: Kind::KeyofType,
-    };
-    mapper.map_program(ast)
-}
-
-pub fn convert_type_param_extends(
-    ast: &ast::Program<Loc, Loc>,
-    loc: Loc,
-) -> ast::Program<Loc, Loc> {
-    let mut mapper = Mapper {
-        contains: ContainsMapper::new(loc),
-        kind: Kind::TypeParamExtends,
-    };
-    mapper.map_program(ast)
-}
-
 pub fn convert_type_param_colon(ast: &ast::Program<Loc, Loc>, loc: Loc) -> ast::Program<Loc, Loc> {
     let mut mapper = Mapper {
         contains: ContainsMapper::new(loc),

rust_port/crates/flow_services_code_action/src/code_action_service.rs

@@ -1451,24 +1451,6 @@ pub fn ast_transforms_of_error(
                 vec![]
             }
         }
-        ErrorMessage::ETSSyntax(box ETSSyntaxData {
-            kind: TSSyntaxKind::TSUnknown,
-            loc: error_loc,
-        }) => {
-            if loc_opt_intersects(loc, error_loc.dupe()) {
-                vec![AstTransformOfError {
-                    title: "Convert to `mixed`".to_string(),
-                    diagnostic_title: "convert_unknown_type".to_string(),
-                    transform: untyped_ast_transform(Box::new(|ast, loc| {
-                        autofix_ts_syntax::convert_unknown_type(ast, loc)
-                    })),
-                    target_loc: error_loc.dupe(),
-                    confidence: QuickfixConfidence::WillFixErrorAndSafeForRunningOnSave,
-                }]
-            } else {
-                vec![]
-            }
-        }
         ErrorMessage::ETSSyntax(box ETSSyntaxData {
             kind: TSSyntaxKind::TSNever,
             loc: error_loc,
@@ -1505,42 +1487,6 @@ pub fn ast_transforms_of_error(
                 vec![]
             }
         }
-        ErrorMessage::ETSSyntax(box ETSSyntaxData {
-            kind: TSSyntaxKind::TSKeyof,
-            loc: error_loc,
-        }) => {
-            if loc_opt_intersects(loc, error_loc.dupe()) {
-                vec![AstTransformOfError {
-                    title: "Convert to `$Keys<T>`".to_string(),
-                    diagnostic_title: "convert_keyof_type".to_string(),
-                    transform: untyped_ast_transform(Box::new(|ast, loc| {
-                        autofix_ts_syntax::convert_keyof_type(ast, loc)
-                    })),
-                    target_loc: error_loc.dupe(),
-                    confidence: QuickfixConfidence::WillFixErrorAndSafeForRunningOnSave,
-                }]
-            } else {
-                vec![]
-            }
-        }
-        ErrorMessage::ETSSyntax(box ETSSyntaxData {
-            kind: TSSyntaxKind::TSTypeParamExtends,
-            loc: error_loc,
-        }) => {
-            if loc_opt_intersects(loc, error_loc.dupe()) {
-                vec![AstTransformOfError {
-                    title: "Convert to `: T`".to_string(),
-                    diagnostic_title: "convert_type_param_extends".to_string(),
-                    transform: untyped_ast_transform(Box::new(|ast, loc| {
-                        autofix_ts_syntax::convert_type_param_extends(ast, loc)
-                    })),
-                    target_loc: error_loc.dupe(),
-                    confidence: QuickfixConfidence::WillFixErrorAndSafeForRunningOnSave,
-                }]
-            } else {
-                vec![]
-            }
-        }
         ErrorMessage::ETSSyntax(box ETSSyntaxData {
             kind: TSSyntaxKind::DeprecatedTypeParamColon,
             loc: error_loc,

rust_port/crates/flow_typing_errors/src/error_message.rs

@@ -3001,11 +3001,8 @@ pub enum UpperKind<L: Dupe> {
     serde::Deserialize
 )]
 pub enum TSSyntaxKind {
-    TSUnknown,
     TSNever,
     TSUndefined,
-    TSKeyof,
-    TSTypeParamExtends,
     TSReadonlyVariance,
     TSInOutVariance(InOutVariance),
     TSReadonlyType(Option<ReadonlyTypeKind>),
@@ -8863,11 +8860,8 @@ impl<L: Dupe + PartialEq + Eq + PartialOrd + Ord> ErrorMessage<L> {
             ErrorMessage::ETSSyntax(box ETSSyntaxData { kind, .. }) => {
                 use crate::intermediate_error_types::Message;
                 let msg = match kind {
-                    TSSyntaxKind::TSUnknown => Message::MessageTSUnknownType,
                     TSSyntaxKind::TSNever => Message::MessageTSNeverType,
                     TSSyntaxKind::TSUndefined => Message::MessageTSUndefinedType,
-                    TSSyntaxKind::TSKeyof => Message::MessageTSKeyofType,
-                    TSSyntaxKind::TSTypeParamExtends => Message::MessageTSParamExtends,
                     TSSyntaxKind::TSReadonlyVariance => Message::MessageTSVarianceReadOnly,
                     TSSyntaxKind::TSInOutVariance(InOutVariance::In) => {
                         Message::MessageTSVarianceIn

rust_port/crates/flow_typing_errors/src/intermediate_error.rs

@@ -8131,33 +8131,13 @@ where
                 features.extend(suggestion);
                 friendly::Message(features)
             }
-            MessageTSKeyofType => friendly::Message(vec![
-                code("keyof"),
-                text(" is only supported when used inline in a mapped type. "),
-                text("The equivalent of TypeScript's "),
-                code("keyof"),
-                text(" type operator in Flow is the "),
-                code("$Keys"),
-                text(" utility type, used in the form "),
-                code("$Keys<T>"),
-                text("."),
-            ]),
             MessageTSNeverType => friendly::Message(vec![
                 text("The closest equivalent of TypeScript's "),
                 code("never"),
                 text(" type in Flow is "),
                 code("empty"),
                 text("."),
             ]),
-            MessageTSParamExtends => friendly::Message(vec![
-                text("While TypeScript uses "),
-                code("extends"),
-                text(" to specify type parameter bounds, Flow uses "),
-                code(":"),
-                text(" in the form "),
-                code("type T<A: B> = ..."),
-                text("."),
-            ]),
             MessageTSReadonlyOperatorOnArray => friendly::Message(vec![
                 text("The equivalent of TypeScript's "),
                 code("readonly"),
@@ -8311,13 +8291,6 @@ where
                 code("undefined"),
                 text(" types."),
             ]),
-            MessageTSUnknownType => friendly::Message(vec![
-                text("The equivalent of TypeScript's "),
-                code("unknown"),
-                text(" type in Flow is "),
-                code("mixed"),
-                text("."),
-            ]),
             MessageUnclearType => friendly::Message(vec![
                 text("Unclear type. Using "),
                 code("any"),

rust_port/crates/flow_typing_errors/src/intermediate_error_types.rs

@@ -2179,9 +2179,7 @@ pub enum Message<L: Dupe> {
 
     MessageThisSuperInObject(VirtualReason<L>, ThisFinderKind),
 
-    MessageTSKeyofType,
     MessageTSNeverType,
-    MessageTSParamExtends,
     MessageTSReadonlyOperatorOnArray,
     MessageTSReadonlyOperatorOnTuple,
     MessageTSReadonlyType,
@@ -2196,7 +2194,6 @@ pub enum Message<L: Dupe> {
     MessageAbstractClass,
     MessageAbstractMethod,
     MessageTSUndefinedType,
-    MessageTSUnknownType,
 
     MessageTupleElementNotReadable(Box<MessageTupleElementNotReadableData<L>>),
 

rust_port/crates/flow_typing_statement/src/type_annotation.rs

@@ -796,15 +796,6 @@ fn convert_inner<'a>(
             })
         }
         TypeInner::Unknown { loc, comments } => {
-            if !(cx.ts_syntax() || cx.ts_utility_syntax()) {
-                flow_js_utils::add_output_non_speculating(
-                    cx,
-                    ErrorMessage::ETSSyntax(Box::new(ETSSyntaxData {
-                        kind: flow_typing_errors::error_message::TSSyntaxKind::TSUnknown,
-                        loc: loc.dupe(),
-                    })),
-                );
-            }
             let rt = mixed_t::at(loc.dupe());
             ast::types::Type::new(TypeInner::Unknown {
                 loc: (loc.dupe(), rt),
@@ -963,15 +954,6 @@ fn convert_inner<'a>(
                 reason::mk_reason(reason::VirtualReasonDesc::RKeySet, loc.dupe()),
                 arg_t,
             ));
-            if !(cx.ts_syntax() || cx.ts_utility_syntax()) {
-                flow_js_utils::add_output_non_speculating(
-                    cx,
-                    ErrorMessage::ETSSyntax(Box::new(ETSSyntaxData {
-                        kind: flow_typing_errors::error_message::TSSyntaxKind::TSKeyof,
-                        loc: loc.dupe(),
-                    })),
-                );
-            }
             ast::types::Type::new(TypeInner::Keyof {
                 loc: (loc.dupe(), t),
                 inner: ast::types::Keyof {

src/services/code_action/autofix_ts_syntax.ml

@@ -12,15 +12,10 @@ class mapper target_loc kind =
     method! type_ t =
       let open Flow_ast.Type in
       match t with
-      | (loc, Unknown comments) when kind = `UnknownType && this#is_target loc ->
-        Ast_builder.Types.mixed ?comments ()
       | (loc, Never comments) when kind = `NeverType && this#is_target loc ->
         Ast_builder.Types.empty ?comments ()
       | (loc, Undefined comments) when kind = `UndefinedType && this#is_target loc ->
         Ast_builder.Types.void ?comments ()
-      | (loc, Keyof { Keyof.argument; comments }) when kind = `KeyofType && this#is_target loc ->
-        let targs = Ast_builder.Types.type_args [super#type_ argument] in
-        Ast_builder.Types.unqualified_generic ?comments ~targs "$Keys"
       | (loc, ReadOnly { ReadOnly.argument = (_, Array { Array.argument; _ }); comments })
         when kind = `ReadOnlyArrayType && this#is_target loc ->
         let targs = Ast_builder.Types.type_args [super#type_ argument] in
@@ -34,8 +29,6 @@ class mapper target_loc kind =
     method! type_param ~kind:k (loc, tparam) =
       let open Flow_ast.Type.TypeParam in
       match tparam with
-      | { bound_kind = Extends; _ } when kind = `TypeParamExtends && this#is_target loc ->
-        (Loc.none, { tparam with bound_kind = Colon })
       | { bound_kind = Colon; _ } when kind = `TypeParamColon && this#is_target loc ->
         (Loc.none, { tparam with bound_kind = Extends })
       | { variance = Some (v_loc, Flow_ast.Variance.{ kind = InOut; _ }); _ }
@@ -77,10 +70,6 @@ class mapper target_loc kind =
       | _ -> super#expression e
   end
 
-let convert_unknown_type ast loc =
-  let mapper = new mapper loc `UnknownType in
-  mapper#program ast
-
 let convert_never_type ast loc =
   let mapper = new mapper loc `NeverType in
   mapper#program ast
@@ -89,14 +78,6 @@ let convert_undefined_type ast loc =
   let mapper = new mapper loc `UndefinedType in
   mapper#program ast
 
-let convert_keyof_type ast loc =
-  let mapper = new mapper loc `KeyofType in
-  mapper#program ast
-
-let convert_type_param_extends ast loc =
-  let mapper = new mapper loc `TypeParamExtends in
-  mapper#program ast
-
 let convert_type_param_colon ast loc =
   let mapper = new mapper loc `TypeParamColon in
   mapper#program ast

src/services/code_action/autofix_ts_syntax.mli

@@ -5,11 +5,6 @@
  * LICENSE file in the root directory of this source tree.
  *)
 
-val convert_unknown_type :
-  (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t ->
-  Loc.t ->
-  (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t
-
 val convert_never_type :
   (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t ->
   Loc.t ->
@@ -20,16 +15,6 @@ val convert_undefined_type :
   Loc.t ->
   (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t
 
-val convert_keyof_type :
-  (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t ->
-  Loc.t ->
-  (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t
-
-val convert_type_param_extends :
-  (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t ->
-  Loc.t ->
-  (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t
-
 val convert_type_param_colon :
   (Loc.t, Loc.t) Flow_ast_mapper.Ast.Program.t ->
   Loc.t ->