/**
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

const skipFilter = new Set([
  /**
   * Observable different in logging between Forget and non-Forget
   */
  "early-return-no-declarations-reassignments-dependencies",

  /**
   * Category A:
   * Tests with 0 parameters and 0 refs to external values
   */
  // TODO: fix invalid .set call
  "assignment-variations-complex-lvalue-array",
  // TODO: uses jsx (requires React)
  "sketchy-code-rules-of-hooks",
  // TODO: fix infinite loop
  "ssa-for-trivial-update",
  // TODO: fix infinite loop
  "ssa-while-no-reassign",

  /**
   * Category B:
   * Tests with at least one param and 0 refs to external values
   */
  "bug.useMemo-deps-array-not-cleared",
  "capture_mutate-across-fns",
  "capture-indirect-mutate-alias",
  "capturing-arrow-function-1",
  "capturing-func-mutate-3",
  "capturing-func-mutate-nested",
  "capturing-func-mutate",
  "capturing-function-1",
  "capturing-function-alias-computed-load",
  "capturing-function-decl",
  "capturing-function-skip-computed-path",
  "capturing-function-within-block",
  "capturing-member-expr",
  "capturing-nested-member-call",
  "capturing-nested-member-expr-in-nested-func",
  "capturing-nested-member-expr",
  "capturing-variable-in-nested-block",
  "capturing-variable-in-nested-function",
  "complex-while",
  "component",
  "cond-deps-conditional-member-expr",
  "conditional-break-labeled",
  "conditional-set-state-in-render",
  "constant-computed",
  "constant-propagation-phi",
  "debugger-memoized",
  "debugger",
  "declare-reassign-variable-in-closure",
  "delete-computed-property",
  "delete-property",
  "dependencies-outputs",
  "dependencies",
  "destructure-direct-reassignment",
  "destructuring-array-default",
  "destructuring-array-param-default",
  "destructuring-assignment-array-default",
  "destructuring-assignment",
  "destructuring-object-default",
  "destructuring-object-param-default",
  "destructuring",
  "disable-jsx-memoization",
  "do-while-break",
  "do-while-compound-test",
  "dominator",
  "early-return",
  "escape-analysis-destructured-rest-element",
  "escape-analysis-jsx-child",
  "escape-analysis-logical",
  "escape-analysis-non-escaping-interleaved-allocating-dependency",
  "escape-analysis-non-escaping-interleaved-allocating-nested-dependency",
  "escape-analysis-non-escaping-interleaved-primitive-dependency",
  "escape-analysis-not-conditional-test",
  "escape-analysis-not-if-test",
  "escape-analysis-not-switch-case",
  "escape-analysis-not-switch-test",
  "expression-with-assignment-dynamic",
  "extend-scopes-if",
  "fbt/fbt-params",
  "for-empty-update-with-continue",
  "for-empty-update",
  "for-logical",
  "for-return",
  "function-declaration-simple",
  "function-param-assignment-pattern",
  "globals-Boolean",
  "globals-Number",
  "globals-String",
  "holey-array-pattern-dce-2",
  "holey-array-pattern-dce",
  "holey-array",
  "independently-memoize-object-property",
  "inverted-if-else",
  "inverted-if",
  "jsx-empty-expression",
  "jsx-fragment",
  "jsx-namespaced-name",
  "lambda-mutated-non-reactive-to-reactive",
  "lambda-mutated-ref-non-reactive",
  "logical-expression-object",
  "logical-expression",
  "nested-function-shadowed-identifiers",
  "nonoptional-load-from-optional-memberexpr",
  "object-computed-access-assignment",
  "object-expression-string-literal-key",
  "object-literal-spread-element",
  "object-pattern-params",
  "optional-member-expression-chain",
  "overlapping-scopes-interleaved-by-terminal",
  "overlapping-scopes-interleaved",
  "overlapping-scopes-shadowed",
  "overlapping-scopes-shadowing-within-block",
  "overlapping-scopes-while",
  "overlapping-scopes-within-block",
  "prop-capturing-function-1",
  "reactive-scopes-if",
  "reactive-scopes",
  "reactivity-analysis-interleaved-reactivity",
  "reassign-object-in-context",
  "reassignment-separate-scopes",
  "return-conditional",
  "return-undefined",
  "reverse-postorder",
  "same-variable-as-dep-and-redeclare-maybe-frozen",
  "same-variable-as-dep-and-redeclare",
  "simple-scope",
  "ssa-arrayexpression",
  "ssa-cascading-eliminated-phis",
  "ssa-for-of",
  "ssa-multiple-phis",
  "ssa-nested-loops-no-reassign",
  "ssa-nested-partial-phi",
  "ssa-nested-partial-reassignment",
  "ssa-non-empty-initializer",
  "ssa-objectexpression",
  "ssa-property-alias-if",
  "ssa-reassign",
  "ssa-renaming-ternary-destruction",
  "ssa-renaming-ternary",
  "ssa-renaming-unconditional-ternary",
  "ssa-renaming-via-destructuring",
  "ssa-renaming",
  "ssa-sibling-phis",
  "switch-with-fallthrough",
  "ternary-assignment-expression",
  "ternary-expression",
  "trivial",
  "type-args-test-binary-operator",
  "type-cast-expression.flow",
  "unary-expr",
  "unconditional-break-label",
  "unused-array-middle-element",
  "unused-array-rest-element",
  "unused-conditional",
  "unused-logical",
  "unused-object-element-with-rest",
  "unused-object-element",
  "useMemo-inlining-block-return",
  "useMemo-inverted-if",
  "useMemo-labeled-statement-unconditional-return",
  "useMemo-logical",
  "useMemo-nested-ifs",
  "useMemo-switch-no-fallthrough",
  "useMemo-switch-return",
  "while-break",
  "while-conditional-continue",
  "while-logical",
  "while-property",
  "validate-no-set-state-in-render-uncalled-function-with-mutable-range-is-valid",
  // Category B with multiple entrypoints,
  "conditional-break",

  /**
   * Category C:
   * Tests with at 0 params and at least one ref to external values
   */
  "alias-capture-in-method-receiver",
  "alias-nested-member-path-mutate",
  "concise-arrow-expr",
  "const-propagation-into-function-expression-global",
  "declare-reassign-variable-in-function-declaration",
  "lambda-mutate-shadowed-object",
  "fbt/lambda-with-fbt",
  "recursive-function-expr",
  "ref-current-aliased-no-added-to-dep",
  "ref-current-field-not-added-to-dep",
  "ref-current-not-added-to-dep",
  "ref-current-optional-field-no-added-to-dep",
  "ref-current-write-not-added-to-dep",
  "rewrite-phis-in-lambda-capture-context",
  "sketchy-code-exhaustive-deps",
  "ssa-property-alias-mutate",
  "ssa-property-mutate-2",
  "ssa-property-mutate-alias",
  "ssa-property-mutate",
  "ssa-reassign-in-rval",
  "store-via-call",
  "store-via-new",
  "tagged-template-literal",
  "transitive-alias-fields",
  "type-binary-operator",
  "type-test-field-load-binary-op",
  "type-test-polymorphic",
  "type-test-return-type-inference",
  "use-callback-simple",
  // defines two functions
  "simple-alias",

  /**
   * Category D:
   * Tests with one or more params, with external references.
   */
  "alias-computed-load",
  "allocating-primitive-as-dep",
  "allow-passing-refs-as-props",
  "array-at-closure",
  "array-at-effect",
  "array-at-mutate-after-capture",
  "array-join",
  "array-push-effect",
  "arrow-function-expr-gating-test",
  "assignment-in-nested-if",
  "await-side-effecting-promise",
  "await",
  "builtin-jsx-tag-lowered-between-mutations",
  "call-args-assignment",
  "call-args-destructuring-assignment",
  "call-spread",
  "call-with-independently-memoizable-arg",
  "capture-param-mutate",
  "capturing-fun-alias-captured-mutate-2",
  "capturing-fun-alias-captured-mutate-arr-2",
  "capturing-func-alias-captured-mutate-arr",
  "capturing-func-alias-captured-mutate",
  "capturing-func-alias-computed-mutate",
  "capturing-func-alias-mutate",
  "capturing-func-alias-receiver-computed-mutate",
  "capturing-func-alias-receiver-mutate",
  "capturing-func-simple-alias",
  "capturing-function-capture-ref-before-rename",
  "capturing-function-conditional-capture-mutate",
  "capturing-function-member-expr-arguments",
  "capturing-function-member-expr-call",
  "capturing-function-renamed-ref",
  "capturing-function-runs-inference",
  "capturing-function-shadow-captured",
  "capturing-reference-changes-type",
  "codegen-emit-imports-same-source",
  "codegen-emit-make-read-only",
  "computed-call-spread",
  "computed-load-primitive-as-dependency",
  "computed-store-alias",
  "constant-propagation-into-function-expressions",
  "destructuring-mixed-scope-declarations-and-locals",
  "destructuring-property-inference",
  "do-while-conditional-break",
  "do-while-early-unconditional-break",
  "fbt/fbt-params-complex-param-value",
  "function-expression-captures-value-later-frozen-jsx",
  "function-expression-maybe-mutates-hook-return-value",
  "function-expression-with-store-to-parameter",
  "global-jsx-tag-lowered-between-mutations",
  "hook-inside-logical-expression",
  "immutable-hooks",
  "inadvertent-mutability-readonly-class",
  "inadvertent-mutability-readonly-lambda",
  "infer-computed-delete",
  "infer-property-delete",
  "inner-memo-value-not-promoted-to-outer-scope-dynamic",
  "inner-memo-value-not-promoted-to-outer-scope-static",
  "issue852",
  "jsx-member-expression-tag-grouping",
  "jsx-member-expression",
  "jsx-spread",
  "lambda-capture-returned-alias",
  "method-call-computed",
  "method-call-fn-call",
  "nested-optional-member-expr",
  "nested-scopes-hook-call",
  "new-spread",
  "obj-literal-cached-in-if-else",
  "obj-literal-mutated-after-if-else",
  "obj-mutated-after-if-else-with-alias",
  "obj-mutated-after-if-else",
  "obj-mutated-after-nested-if-else-with-alias",
  "object-properties",
  "optional-call-chained",
  "optional-call-logical",
  "optional-call-simple",
  "optional-call-with-independently-memoizable-arg",
  "optional-call-with-optional-property-load",
  "optional-call",
  "optional-computed-load-static",
  "optional-computed-member-expression",
  "optional-member-expression-call-as-property",
  "optional-member-expression-with-optional-member-expr-as-property",
  "optional-member-expression",
  "optional-method-call",
  "optional-receiver-method-call",
  "optional-receiver-optional-method",
  "primitive-alias-mutate",
  "primitive-as-dep",
  "property-assignment",
  "property-call-spread",
  "reactive-dependencies-non-optional-properties-inside-optional-chain",
  "reactivity-analysis-reactive-via-mutation-of-computed-load",
  "reactivity-analysis-reactive-via-mutation-of-property-load",
  "reassigned-phi-in-returned-function-expression",
  "reassignment-conditional",
  "reassignment",
  "ref-current-aliased-not-added-to-dep-2",
  "ref-current-not-added-to-dep-2",
  "ref-in-effect",
  "regexp-literal",
  "remove-memoization-kitchen-sink",
  "repro-reassign-to-variable-without-mutable-range",
  "repro-scope-missing-mutable-range",
  "repro",
  "simple",
  "ssa-leave-case",
  "ssa-property-alias-alias-mutate-if",
  "ssa-property-alias-mutate-if",
  "ssa-property-alias-mutate-inside-if",
  "ssa-renaming-ternary-destruction-with-mutation",
  "ssa-renaming-ternary-with-mutation",
  "ssa-renaming-unconditional-with-mutation",
  "ssa-renaming-via-destructuring-with-mutation",
  "ssa-renaming-with-mutation",
  "switch-global-propertyload-case-test",
  "switch-non-final-default",
  "switch",
  "tagged-template-in-hook",
  "temporary-accessed-outside-scope",
  "temporary-at-start-of-value-block",
  "temporary-property-load-accessed-outside-scope",
  "timers",
  "todo-function-expression-captures-value-later-frozen",
  "uninitialized-declaration-in-reactive-scope",
  "unknown-hooks-do-not-assert",
  "unused-logical-assigned-to-variable",
  "unused-optional-method-assigned-to-variable",
  "unused-ternary-assigned-to-variable",
  "useEffect-arg-memoized",
  "useEffect-nested-lambdas",
  "useMemo-if-else-multiple-return",
  "useMemo-independently-memoizeable",
  "useMemo-named-function",
  "useMemo-return-empty",
  "useMemo-simple",
  "use-no-forget-module-level",
  "use-no-memo-module-level",
  // defines multiple functions
  "alias-while",
  "babel-existing-react-import",
  "babel-existing-react-kitchensink-import",
  "call",
  "codegen-instrument-forget-gating-test",
  "codegen-instrument-forget-test",
  "conditional-on-mutable",
  "constructor",
  "frozen-after-alias",
  "gating-test-export-default-function",
  "gating-test-export-function-and-default",
  "gating-test-export-function",
  "gating-test",
  "gating-with-hoisted-type-reference.flow",
  "hook-call",
  "hooks-freeze-arguments",
  "hooks-freeze-possibly-mutable-arguments",
  "independent-across-if",
  "independent",
  "interdependent-across-if",
  "interdependent",
  "multi-arrow-expr-export-gating-test",
  "multi-arrow-expr-gating-test",
  "mutable-liverange-loop",
  "sequence-expression",
  "ssa-call-jsx-2",
  "ssa-call-jsx",
  "ssa-newexpression",
  "ssa-shadowing",
  "template-literal",
  "multi-arrow-expr-export-default-gating-test",

  // TODO: we should be able to support these
  "component-declaration-basic.flow",
  "hook-declaration-basic.flow",
  "nested-function-with-param-as-captured-dep",
  "deeply-nested-function-expressions-with-params",
  "readonly-object-method-calls",
  "readonly-object-method-calls-mutable-lambda",

  // TODO: we probably want to always skip these
  "rules-of-hooks/rules-of-hooks-0592bd574811",
  "rules-of-hooks/rules-of-hooks-0e2214abc294",
  "rules-of-hooks/rules-of-hooks-1ff6c3fbbc94",
  "rules-of-hooks/rules-of-hooks-23dc7fffde57",
  "rules-of-hooks/rules-of-hooks-2bec02ac982b",
  "rules-of-hooks/rules-of-hooks-2e405c78cb80",
  "rules-of-hooks/rules-of-hooks-33a6e23edac1",
  "rules-of-hooks/rules-of-hooks-347b0dae66f1",
  "rules-of-hooks/rules-of-hooks-485bf041f55f",
  "rules-of-hooks/rules-of-hooks-4f6c78a14bf7",
  "rules-of-hooks/rules-of-hooks-7e52f5eec669",
  "rules-of-hooks/rules-of-hooks-844a496db20b",
  "rules-of-hooks/rules-of-hooks-8f1c2c3f71c9",
  "rules-of-hooks/rules-of-hooks-9a47e97b5d13",
  "rules-of-hooks/rules-of-hooks-9d7879272ff6",
  "rules-of-hooks/rules-of-hooks-c1e8c7f4c191",
  "rules-of-hooks/rules-of-hooks-c5d1f3143c4c",
  "rules-of-hooks/rules-of-hooks-cfdfe5572fc7",
  "rules-of-hooks/rules-of-hooks-df4d750736f3",
  "rules-of-hooks/rules-of-hooks-dfde14171fcd",
  "rules-of-hooks/rules-of-hooks-e5dd6caf4084",
  "rules-of-hooks/rules-of-hooks-e66a744cffbe",
  "rules-of-hooks/rules-of-hooks-eacfcaa6ef89",
  "rules-of-hooks/rules-of-hooks-fe6042f7628b",
  "infer-function-assignment",
  "infer-functions-component-with-jsx",
  "infer-function-forwardRef",
  "infer-function-React-memo",
  "infer-functions-component-with-hook-call",
  "infer-functions-component-with-jsx",
  "infer-functions-hook-with-hook-call",
  "infer-functions-hook-with-jsx",
  "infer-function-expression-component",
  "infer-function-expression-React-memo-gating",
  "infer-skip-components-without-hooks-or-jsx",
  "class-component-with-render-helper",
  "fbt/fbtparam-with-jsx-element-content",
  "fbt/fbtparam-text-must-use-expression-container",
  "fbt/fbtparam-with-jsx-fragment-value",
  "fbt/fbt-preserve-jsxtext",
  "todo.useContext-mutate-context-in-callback",
  "loop-unused-let",
  "reanimated-no-memo-arg",

  // Tested e2e in forget-feedback repo
  "userspace-use-memo-cache",
  "transitive-freeze-function-expressions",

  // nothing to compile/run
  "repro-no-gating-import-without-compiled-functions",

  // TODOs
  "rules-of-hooks/todo.bail.rules-of-hooks-279ac76f53af",
  "rules-of-hooks/todo.bail.rules-of-hooks-28a78701970c",
  "rules-of-hooks/todo.bail.rules-of-hooks-3d692676194b",
  "rules-of-hooks/todo.bail.rules-of-hooks-6949b255e7eb",
  "rules-of-hooks/todo.bail.rules-of-hooks-8503ca76d6f8",
  "rules-of-hooks/todo.bail.rules-of-hooks-e0a5db3ae21e",
  "rules-of-hooks/todo.bail.rules-of-hooks-e9f9bac89f8f",
  "rules-of-hooks/todo.bail.rules-of-hooks-fadd52c1e460",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-0a1dbff27ba0",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-0de1224ce64b",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-191029ac48c8",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-206e2811c87c",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-28a7111f56a7",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-2c51251df67a",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-449a37146a83",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-5a7ac9a6e8fa",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-76a74b4666e9",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-8303403b8e4c",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-99b5c750d1d1",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-9c79feec4b9b",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-a63fd4f9dcc0",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-acb56658fe7e",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-c59788ef5676",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-d842d36db450",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-d952b82c2597",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-ddeca9708b63",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-e675f0a672d8",
  "rules-of-hooks/todo.invalid.invalid-rules-of-hooks-e69ffce323c3",
  "todo.unnecessary-lambda-memoization",
  "rules-of-hooks/rules-of-hooks-93dc5d5e538a",
  "rules-of-hooks/rules-of-hooks-69521d94fa03",

  // bugs
  "bug-invalid-hoisting-functionexpr",
  "original-reactive-scopes-fork/bug-nonmutating-capture-in-unsplittable-memo-block",
  "original-reactive-scopes-fork/bug-hoisted-declaration-with-scope",

  // 'react-compiler-runtime' not yet supported
  "flag-enable-emit-hook-guards",

  "fast-refresh-refresh-on-const-changes-dev",
  "useState-pruned-dependency-change-detect",
  "useState-unpruned-dependency",
  "useState-and-other-hook-unpruned-dependency",
  "change-detect-reassign",

  // needs to be executed as a module
  "meta-property",
]);

export default skipFilter;