[ty] Add replace-imports-with-any option (#23122)

## Summary

Add config to specify set of import paths to be resolved to Any. This
config will silence import errors and replace the module with
typing.Any. If the module can be found, its type information will still
be replaced with typing.Any.

Resolves part of astral-sh/ty#2082. I haven't
implmented the suggestion to use Dynamic type to have both any and the
best guess of the type. I'm thinking to do it in next PR.

## Test Plan

Updated mdtest. I didn't add a lot of glob tests since the
allowed-unresolved-imports rule already tested that.

---------

Co-authored-by: Carl Meyer <carl@astral.sh>

Author: Glyphack

crates/ty/docs/configuration.md

@@ -1329,6 +1329,31 @@ pub struct AnalysisOptions {
         "#
     )]
     pub allowed_unresolved_imports: Option<Vec<RangedValue<String>>>,
+
+    /// A list of module glob patterns whose imports should be replaced with `typing.Any`.
+    ///
+    /// Unlike `allowed-unresolved-imports`, this setting replaces the module's type information
+    /// with `typing.Any` even if the module can be resolved. Import diagnostics are
+    /// unconditionally suppressed for matching modules.
+    ///
+    /// - Prefix a pattern with `!` to exclude matching modules
+    ///
+    /// When multiple patterns match, later entries take precedence.
+    ///
+    /// Glob patterns can be used in combinations with each other. For example, to suppress errors for
+    /// any module where the first component contains the substring `test`, use `*test*.**`.
+    ///
+    /// When multiple patterns match, later entries take precedence.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[option(
+        default = r#"[]"#,
+        value_type = "list[str]",
+        example = r#"
+            # Replace all pandas and numpy imports with Any
+            replace-imports-with-any = ["pandas.**", "numpy.**"]
+        "#
+    )]
+    pub replace_imports_with_any: Option<Vec<RangedValue<String>>>,
 }
 
 impl AnalysisOptions {
@@ -1340,11 +1365,13 @@ impl AnalysisOptions {
         let Self {
             respect_type_ignore_comments,
             allowed_unresolved_imports,
+            replace_imports_with_any,
         } = self;
 
         let AnalysisSettings {
             respect_type_ignore_comments: respect_type_ignore_default,
             allowed_unresolved_imports: allowed_unresolved_imports_default,
+            replace_imports_with_any: replace_imports_with_any_default,
         } = AnalysisSettings::default();
 
         let allowed_unresolved_imports =
@@ -1358,10 +1385,22 @@ impl AnalysisOptions {
                 allowed_unresolved_imports_default
             };
 
+        let replace_imports_with_any =
+            if let Some(replace_imports_with_any) = replace_imports_with_any {
+                build_module_glob_set(db, replace_imports_with_any, "replace_imports_with_any")
+                    .unwrap_or_else(|error| {
+                        diagnostics.push(*error);
+                        ModuleGlobSet::empty()
+                    })
+            } else {
+                replace_imports_with_any_default
+            };
+
         AnalysisSettings {
             respect_type_ignore_comments: respect_type_ignore_comments
                 .unwrap_or(respect_type_ignore_default),
             allowed_unresolved_imports,
+            replace_imports_with_any,
         }
     }
 }

crates/ty_project/src/metadata/options.rs

@@ -0,0 +1,154 @@
+# Replace imports with Any
+
+When a module cannot be found and matches the pattern, the import is replaced with `Any` and no
+diagnostic is emitted.
+
+The syntax uses globe patterns. See `allowed-unresolved-imports` for syntax.
+
+## Unresolvable module is replaced with Any
+
+```toml
+[analysis]
+replace-imports-with-any = ["foo.**"]
+```
+
+```py
+import foo
+from foo import bar
+from foo.sub import baz
+
+reveal_type(foo)  # revealed: Any
+reveal_type(bar)  # revealed: Any
+reveal_type(baz)  # revealed: Any
+```
+
+## Resolvable module is also replaced with Any
+
+Even when the module exists and has type information, its types are replaced with `Any`.
+
+```toml
+[analysis]
+replace-imports-with-any = ["pkg.**"]
+```
+
+`pkg/__init__.py`:
+
+```py
+x: int = 1
+```
+
+`pkg/sub.py`:
+
+```py
+y: str = "hello"
+```
+
+`main.py`:
+
+```py
+from pkg import x
+from pkg.sub import y
+import pkg
+
+reveal_type(x)  # revealed: Any
+reveal_type(y)  # revealed: Any
+reveal_type(pkg)  # revealed: Any
+```
+
+## Glob Pattern
+
+```toml
+[analysis]
+replace-imports-with-any = ["aws*.**"]
+```
+
+```py
+import aws
+import awscli
+import awscli.customizations
+
+reveal_type(aws)  # revealed: Any
+reveal_type(awscli)  # revealed: Any
+reveal_type(awscli.customizations)  # revealed: Any
+```
+
+## Negative pattern
+
+```toml
+[analysis]
+replace-imports-with-any = ["pkg.**", "!pkg.keep"]
+```
+
+`pkg/__init__.py`:
+
+```py
+```
+
+`pkg/keep.py`:
+
+```py
+value: int = 1
+```
+
+`main.py`:
+
+```py
+from pkg.keep import value
+from pkg.skip import other
+
+reveal_type(value)  # revealed: int
+reveal_type(other)  # revealed: Any
+```
+
+## Relative Imports
+
+The match happens on the module absolute path. If the absolute path that a relative import is
+pointing to matches the condition it will be applied.
+
+```toml
+[analysis]
+replace-imports-with-any = ["**.foo", "bar"]
+```
+
+`package/__init__.py`:
+
+```py
+```
+
+`package/foo.py`:
+
+```py
+val = 1
+```
+
+`package/main.py`:
+
+```py
+from .foo import val
+
+# .bar would not match "bar" rule because the absolute import is package.bar
+from .bar import val2  # error: [unresolved-import]
+
+reveal_type(val)  # revealed: Any
+```
+
+## Non-matching modules are unaffected
+
+```toml
+[analysis]
+replace-imports-with-any = ["skipped.**"]
+```
+
+`real_module.py`:
+
+```py
+value: int = 42
+```
+
+`main.py`:
+
+```py
+from real_module import value
+
+reveal_type(value)  # revealed: int
+```

crates/ty_python_semantic/resources/mdtest/import/replace_imports_with_any.md

@@ -89,13 +89,16 @@ pub struct AnalysisSettings {
     pub respect_type_ignore_comments: bool,
 
     pub allowed_unresolved_imports: ModuleGlobSet,
+
+    pub replace_imports_with_any: ModuleGlobSet,
 }
 
 impl Default for AnalysisSettings {
     fn default() -> Self {
         Self {
             respect_type_ignore_comments: true,
             allowed_unresolved_imports: ModuleGlobSet::empty(),
+            replace_imports_with_any: ModuleGlobSet::empty(),
         }
     }
 }