Remove disallow_invalid_arraykey configuration

Summary: This has been set to true for years.

Reviewed By: mheiber

Differential Revision: D84158739

fbshipit-source-id: 946407b86e580b0a29cf993489dadc3e1aeca1fc

Author: Andrew Kennedy

hphp/hack/src/client_and_server/serverConfig.ml

@@ -380,7 +380,6 @@ let load_config (config : Config_file_common.t) (options : GlobalOptions.t) :
     ~po
     ?tco_language_feature_logging:(bool_opt "language_feature_logging" config)
     ?tco_timeout:(int_opt "timeout" config)
-    ?tco_disallow_invalid_arraykey:(bool_opt "disallow_invalid_arraykey" config)
     ?tco_constraint_array_index:(bool_opt "constraint_array_index" config)
     ?tco_constraint_array_index_assign:
       (bool_opt "constraint_array_index_assign" config)

hphp/hack/src/options/globalOptions.ml

@@ -102,7 +102,6 @@ type t = {
   tco_log_inference_constraints: bool;
   tco_language_feature_logging: bool;
   tco_timeout: int;
-  tco_disallow_invalid_arraykey: bool;
   tco_constraint_array_index: bool;
   tco_constraint_array_index_assign: bool;
   tco_constraint_method_call: bool;
@@ -223,7 +222,6 @@ let default =
     tco_log_inference_constraints = false;
     tco_language_feature_logging = false;
     tco_timeout = 0;
-    tco_disallow_invalid_arraykey = true;
     tco_constraint_array_index = true;
     tco_constraint_array_index_assign = false;
     tco_constraint_method_call = false;
@@ -343,7 +341,6 @@ let set
     ?so_naming_sqlite_path
     ?tco_language_feature_logging
     ?tco_timeout
-    ?tco_disallow_invalid_arraykey
     ?tco_constraint_array_index
     ?tco_constraint_array_index_assign
     ?tco_constraint_method_call
@@ -496,10 +493,6 @@ let set
     tco_language_feature_logging =
       setting tco_language_feature_logging options.tco_language_feature_logging;
     tco_timeout = setting tco_timeout options.tco_timeout;
-    tco_disallow_invalid_arraykey =
-      setting
-        tco_disallow_invalid_arraykey
-        options.tco_disallow_invalid_arraykey;
     tco_constraint_array_index =
       setting tco_constraint_array_index options.tco_constraint_array_index;
     tco_constraint_array_index_assign =

hphp/hack/src/options/globalOptions.mli

@@ -94,9 +94,6 @@ type t = {
         Currently used for lambdas. *)
   tco_timeout: int;
       (** If non-zero, give up type checking a class or function after this many seconds *)
-  tco_disallow_invalid_arraykey: bool;
-      (** Flag to disallow using values that get casted to array keys at runtime;
-        like bools, floats, or null; as array keys. *)
   tco_constraint_array_index: bool;
       (** Flag to enable the constraint solver to infer that a type can be indexed *)
   tco_constraint_array_index_assign: bool;
@@ -321,7 +318,6 @@ val set :
   ?so_naming_sqlite_path:string ->
   ?tco_language_feature_logging:bool ->
   ?tco_timeout:int ->
-  ?tco_disallow_invalid_arraykey:bool ->
   ?tco_constraint_array_index:bool ->
   ?tco_constraint_array_index_assign:bool ->
   ?tco_constraint_method_call:bool ->

hphp/hack/src/options/typecheckerOptions.ml

@@ -89,8 +89,6 @@ let migration_flags_all = List.fold_right ~init:SSet.empty ~f:SSet.add []
 
 let timeout t = t.GlobalOptions.tco_timeout
 
-let disallow_invalid_arraykey t = t.GlobalOptions.tco_disallow_invalid_arraykey
-
 let constraint_array_index t = t.GlobalOptions.tco_constraint_array_index
 
 let constraint_array_index_assign t =

hphp/hack/src/oxidized/gen/global_options.rs

@@ -3,7 +3,7 @@
 // This source code is licensed under the MIT license found in the
 // LICENSE file in the "hack" directory of this source tree.
 //
-// @generated SignedSource<<09d7a09f844f0189eb598083b89bbc6e>>
+// @generated SignedSource<<5184475c9d375c70536f0d2c0622536d>>
 //
 // To regenerate this file, run:
 //   buck run @fbcode//mode/dev-nosan-lg fbcode//hphp/hack/src:oxidized_regen
@@ -189,9 +189,6 @@ pub struct GlobalOptions {
     pub tco_language_feature_logging: bool,
     /// If non-zero, give up type checking a class or function after this many seconds
     pub tco_timeout: isize,
-    /// Flag to disallow using values that get casted to array keys at runtime;
-    /// like bools, floats, or null; as array keys.
-    pub tco_disallow_invalid_arraykey: bool,
     /// Flag to enable the constraint solver to infer that a type can be indexed
     pub tco_constraint_array_index: bool,
     /// Flag to enable the constraint solver to infer that a type can be indexed then assigned

hphp/hack/src/oxidized/manual/global_options_impl.rs

@@ -53,7 +53,6 @@ impl Default for GlobalOptions {
             tco_log_inference_constraints: false,
             tco_language_feature_logging: false,
             tco_timeout: 0,
-            tco_disallow_invalid_arraykey: false, // true in ocaml, true in .hhconfig
             tco_constraint_array_index: true,
             tco_constraint_array_index_assign: false,
             tco_constraint_method_call: false,

hphp/hack/src/typing/tast_check/invalid_index_check.ml

@@ -11,13 +11,10 @@ open Hh_prelude
 open Aast
 open Typing_defs
 module Env = Tast_env
-module TCO = TypecheckerOptions
 module MakeType = Typing_make_type
 module SN = Naming_special_names
 open String.Replace_polymorphic_compare
 
-let should_enforce env = TCO.disallow_invalid_arraykey (Env.get_tcopt env)
-
 let equiv_ak_inter_dyn env ty_expect =
   let r = get_reason ty_expect in
   let ak_dyn =
@@ -60,7 +57,6 @@ let rec array_get ~array_pos ~expr_pos ~index_pos env array_ty index_ty =
       )
       (* If the key is not even an arraykey, we've already produced an error *)
       || (not (Env.can_subtype env ty_have (MakeType.arraykey Reason.none)))
-         && should_enforce env
       (* Keytype of arraykey&dynamic happens when you assign a dynamic into a dict,
          but the above coercion doesn't work. *)
       || equiv_ak_inter_dyn env ty_expect

hphp/hack/src/typing/typing_array_access.ml

@@ -187,70 +187,67 @@ let widen_for_array_get ~lhs_of_null_coalesce ~expr_pos index_expr env ty =
  * being a subtype of arraykey
  *)
 let check_arraykey_index error env pos container_ty index_ty =
-  if TypecheckerOptions.disallow_invalid_arraykey (Env.get_tcopt env) then (
-    let (env, container_ty) = Env.expand_type env container_ty in
-    let reason =
-      match get_node container_ty with
-      | Tclass ((_, cn), _, _) -> Reason.index_class cn
-      | _ -> Reason.index_array
-    in
-    let info_of_type ty = (get_pos ty, lazy (Typing_print.error env ty)) in
-    let container_info = info_of_type container_ty in
-    let index_info = info_of_type index_ty in
-    let ty_arraykey = MakeType.arraykey (Reason.idx_dict pos) in
-    (* If we have an error in coercion here, we will add a `Hole` indicating the
-       actual and expected type. The `Hole` may then be used in a codemod to
-       add a call to `UNSAFE_CAST` so we need to consider what type we expect.
-       There is a somewhat common pattern in older parts of www to do something like:
+  let (env, container_ty) = Env.expand_type env container_ty in
+  let reason =
+    match get_node container_ty with
+    | Tclass ((_, cn), _, _) -> Reason.index_class cn
+    | _ -> Reason.index_array
+  in
+  let info_of_type ty = (get_pos ty, lazy (Typing_print.error env ty)) in
+  let container_info = info_of_type container_ty in
+  let index_info = info_of_type index_ty in
+  let ty_arraykey = MakeType.arraykey (Reason.idx_dict pos) in
+  (* If we have an error in coercion here, we will add a `Hole` indicating the
+     actual and expected type. The `Hole` may then be used in a codemod to
+     add a call to `UNSAFE_CAST` so we need to consider what type we expect.
+     There is a somewhat common pattern in older parts of www to do something like:
 
-       ```
-       function keyset_issue(?string $x): keyset<string> {
-         $xs = keyset<string>[];
-         ...
-         /* HH_FIXME[4435] keyset values must be arraykeys */
-         $xs[] = $x;
-         return Keyset\filter_nulls($xs);
-       }
-       ```
-       (even though it is impossible for keysets to contain nulls).
+     ```
+     function keyset_issue(?string $x): keyset<string> {
+       $xs = keyset<string>[];
+       ...
+       /* HH_FIXME[4435] keyset values must be arraykeys */
+       $xs[] = $x;
+       return Keyset\filter_nulls($xs);
+     }
+     ```
+     (even though it is impossible for keysets to contain nulls).
 
-       If we were to add an expected type of 'arraykey' here it would be
-       correct but adding an `UNSAFE_CAST<?string,arraykey>($x)` means we
-       get cascading errors; here, we now have the wrong return type.
+     If we were to add an expected type of 'arraykey' here it would be
+     correct but adding an `UNSAFE_CAST<?string,arraykey>($x)` means we
+     get cascading errors; here, we now have the wrong return type.
 
-       To try and prevent this, if this is an optional type where the nonnull
-       part can be coerced to arraykey, we prefer that type as our expected type.
-    *)
-    let base_error = error pos container_info index_info in
-    let (ty_actual, is_option) =
-      match deref index_ty with
-      | (_, Toption inner_ty) -> (inner_ty, true)
-      | _ -> (index_ty, false)
-    in
-    let (env, e1) =
-      Typing_coercion.coerce_type
-        ~coerce_for_op:true
-        pos
-        reason
-        env
-        ty_actual
-        ty_arraykey
-        Enforced
-      @@ Typing_error.Callback.always base_error
-    in
-    let (ty_mismatch, e2) =
-      match e1 with
-      | None when is_option ->
-        (Error (index_ty, ty_actual), Some (Typing_error.primary base_error))
-      | None -> (Ok index_ty, None)
-      | Some _ -> (Error (index_ty, ty_arraykey), None)
-    in
-    Option.(
-      iter ~f:(Typing_error_utils.add_typing_error ~env)
-      @@ merge e1 e2 ~f:Typing_error.both);
-    (env, ty_mismatch)
-  ) else
-    (env, Ok index_ty)
+     To try and prevent this, if this is an optional type where the nonnull
+     part can be coerced to arraykey, we prefer that type as our expected type.
+  *)
+  let base_error = error pos container_info index_info in
+  let (ty_actual, is_option) =
+    match deref index_ty with
+    | (_, Toption inner_ty) -> (inner_ty, true)
+    | _ -> (index_ty, false)
+  in
+  let (env, e1) =
+    Typing_coercion.coerce_type
+      ~coerce_for_op:true
+      pos
+      reason
+      env
+      ty_actual
+      ty_arraykey
+      Enforced
+    @@ Typing_error.Callback.always base_error
+  in
+  let (ty_mismatch, e2) =
+    match e1 with
+    | None when is_option ->
+      (Error (index_ty, ty_actual), Some (Typing_error.primary base_error))
+    | None -> (Ok index_ty, None)
+    | Some _ -> (Error (index_ty, ty_arraykey), None)
+  in
+  Option.(
+    iter ~f:(Typing_error_utils.add_typing_error ~env)
+    @@ merge e1 e2 ~f:Typing_error.both);
+  (env, ty_mismatch)
 
 let check_arraykey_index_read =
   let mk_err pos (container_pos, container_ty_name) (key_pos, key_ty_name) =

hphp/hack/src/typing/typing_subtype.ml

@@ -6865,70 +6865,67 @@ end = struct
    * being a subtype of arraykey
    *)
   let check_arraykey_index error env pos container_ty index_ty =
-    if TypecheckerOptions.disallow_invalid_arraykey (Env.get_tcopt env) then (
-      let (env, container_ty) = Env.expand_type env container_ty in
-      let reason =
-        match get_node container_ty with
-        | Tclass ((_, cn), _, _) -> Reason.index_class cn
-        | _ -> Reason.index_array
-      in
-      let info_of_type ty = (get_pos ty, lazy (Typing_print.error env ty)) in
-      let container_info = info_of_type container_ty in
-      let index_info = info_of_type index_ty in
-      let ty_arraykey = MakeType.arraykey (Reason.idx_dict pos) in
-      (* If we have an error in coercion here, we will add a `Hole` indicating the
-         actual and expected type. The `Hole` may then be used in a codemod to
-         add a call to `UNSAFE_CAST` so we need to consider what type we expect.
-         There is a somewhat common pattern in older parts of www to do something like:
-
-         ```
-         function keyset_issue(?string $x): keyset<string> {
-           $xs = keyset<string>[];
-           ...
-           /* HH_FIXME[4435] keyset values must be arraykeys */
-           $xs[] = $x;
-           return Keyset\filter_nulls($xs);
-         }
-         ```
-         (even though it is impossible for keysets to contain nulls).
-
-         If we were to add an expected type of 'arraykey' here it would be
-         correct but adding an `UNSAFE_CAST<?string,arraykey>($x)` means we
-         get cascading errors; here, we now have the wrong return type.
-
-         To try and prevent this, if this is an optional type where the nonnull
-         part can be coerced to arraykey, we prefer that type as our expected type.
-      *)
-      let base_error = error pos container_info index_info in
-      let (ty_actual, is_option) =
-        match deref index_ty with
-        | (_, Toption inner_ty) -> (inner_ty, true)
-        | _ -> (index_ty, false)
-      in
-      let (env, e1) =
-        Typing_coercion.coerce_type
-          ~coerce_for_op:true
-          pos
-          reason
-          env
-          ty_actual
-          ty_arraykey
-          Enforced
-        @@ Typing_error.Callback.always base_error
-      in
-      let (ty_mismatch, e2) =
-        match e1 with
-        | None when is_option ->
-          (Error (index_ty, ty_actual), Some (Typing_error.primary base_error))
-        | None -> (Ok index_ty, None)
-        | Some _ -> (Error (index_ty, ty_arraykey), None)
-      in
-      Option.(
-        iter ~f:(Typing_error_utils.add_typing_error ~env)
-        @@ merge e1 e2 ~f:Typing_error.both);
-      (env, ty_mismatch)
-    ) else
-      (env, Ok index_ty)
+    let (env, container_ty) = Env.expand_type env container_ty in
+    let reason =
+      match get_node container_ty with
+      | Tclass ((_, cn), _, _) -> Reason.index_class cn
+      | _ -> Reason.index_array
+    in
+    let info_of_type ty = (get_pos ty, lazy (Typing_print.error env ty)) in
+    let container_info = info_of_type container_ty in
+    let index_info = info_of_type index_ty in
+    let ty_arraykey = MakeType.arraykey (Reason.idx_dict pos) in
+    (* If we have an error in coercion here, we will add a `Hole` indicating the
+       actual and expected type. The `Hole` may then be used in a codemod to
+       add a call to `UNSAFE_CAST` so we need to consider what type we expect.
+       There is a somewhat common pattern in older parts of www to do something like:
+
+       ```
+       function keyset_issue(?string $x): keyset<string> {
+         $xs = keyset<string>[];
+         ...
+         /* HH_FIXME[4435] keyset values must be arraykeys */
+         $xs[] = $x;
+         return Keyset\filter_nulls($xs);
+       }
+       ```
+       (even though it is impossible for keysets to contain nulls).
+
+       If we were to add an expected type of 'arraykey' here it would be
+       correct but adding an `UNSAFE_CAST<?string,arraykey>($x)` means we
+       get cascading errors; here, we now have the wrong return type.
+
+       To try and prevent this, if this is an optional type where the nonnull
+       part can be coerced to arraykey, we prefer that type as our expected type.
+    *)
+    let base_error = error pos container_info index_info in
+    let (ty_actual, is_option) =
+      match deref index_ty with
+      | (_, Toption inner_ty) -> (inner_ty, true)
+      | _ -> (index_ty, false)
+    in
+    let (env, e1) =
+      Typing_coercion.coerce_type
+        ~coerce_for_op:true
+        pos
+        reason
+        env
+        ty_actual
+        ty_arraykey
+        Enforced
+      @@ Typing_error.Callback.always base_error
+    in
+    let (ty_mismatch, e2) =
+      match e1 with
+      | None when is_option ->
+        (Error (index_ty, ty_actual), Some (Typing_error.primary base_error))
+      | None -> (Ok index_ty, None)
+      | Some _ -> (Error (index_ty, ty_arraykey), None)
+    in
+    Option.(
+      iter ~f:(Typing_error_utils.add_typing_error ~env)
+      @@ merge e1 e2 ~f:Typing_error.both);
+    (env, ty_mismatch)
 
   let check_arraykey_index_write =
     let mk_err pos (container_pos, container_ty_name) (key_pos, key_ty_name) =

hphp/hack/src/utils/hh_config/hh_config.rs

@@ -344,10 +344,6 @@ impl HhConfig {
             tco_log_inference_constraints: default.tco_log_inference_constraints,
             tco_language_feature_logging: default.tco_language_feature_logging,
             tco_timeout: hhconfig.get_int_or("timeout", default.tco_timeout)?,
-            tco_disallow_invalid_arraykey: hhconfig.get_bool_or(
-                "disallow_invalid_arraykey",
-                default.tco_disallow_invalid_arraykey,
-            )?,
             tco_constraint_array_index: hhconfig
                 .get_bool_or("constraint_array_index", default.tco_constraint_array_index)?,
             tco_constraint_array_index_assign: hhconfig.get_bool_or(