pyrefly 0.30.0__tar.gz → 0.31.0__tar.gz

{pyrefly-0.30.0 → pyrefly-0.31.0}/Cargo.lock

@@ -2064,7 +2064,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "anstream",
  "anyhow",
@@ -2083,6 +2083,7 @@ dependencies = [
  "parse-display",
  "paste",
  "pretty_assertions",
+ "pyrefly_build",
  "pyrefly_bundled",
  "pyrefly_config",
  "pyrefly_derive",
@@ -2110,9 +2111,25 @@ dependencies = [
  "yansi 1.0.1",
 ]
 
+[[package]]
+name = "pyrefly_build"
+version = "0.31.0"
+dependencies = [
+ "anyhow",
+ "dupe",
+ "pyrefly_python",
+ "pyrefly_util",
+ "serde",
+ "serde_json",
+ "starlark_map",
+ "static_interner",
+ "tracing",
+ "vec1",
+]
+
 [[package]]
 name = "pyrefly_bundled"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "anyhow",
  "starlark_map",
@@ -2122,7 +2139,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_config"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "anyhow",
  "clap",
@@ -2155,7 +2172,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_derive"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -2164,7 +2181,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_python"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "anyhow",
  "dupe",
@@ -2187,7 +2204,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_types"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "compact_str 0.8.0",
  "dupe",
@@ -2207,7 +2224,7 @@ dependencies = [
 
 [[package]]
 name = "pyrefly_util"
-version = "0.30.0"
+version = "0.31.0"
 dependencies = [
  "anstream",
  "anyhow",

{pyrefly-0.30.0 → pyrefly-0.31.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyrefly
-Version: 0.30.0
+Version: 0.31.0
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3

pyrefly-0.31.0/crates/pyrefly_build/Cargo.toml

@@ -0,0 +1,24 @@
+# @generated by autocargo from //pyrefly/crates/pyrefly_build:pyrefly_build
+
+[package]
+name = "pyrefly_build"
+version = "0.31.0"
+authors = ["Meta"]
+edition = "2024"
+repository = "https://github.com/facebook/pyrefly"
+license = "MIT"
+
+[dependencies]
+anyhow = "1.0.98"
+dupe = "0.9.1"
+pyrefly_python = { path = "../pyrefly_python" }
+pyrefly_util = { path = "../pyrefly_util" }
+serde = { version = "1.0.219", features = ["derive", "rc"] }
+serde_json = { version = "1.0.140", features = ["alloc", "float_roundtrip", "raw_value", "unbounded_depth"] }
+starlark_map = "0.13.0"
+static_interner = "0.1.1"
+tracing = { version = "0.1.41", features = ["attributes", "valuable"] }
+vec1 = { version = "1", features = ["serde"] }
+
+[lints]
+rust = { unexpected_cfgs = { check-cfg = ["cfg(fbcode_build)"], level = "warn" } }

pyrefly-0.30.0/pyrefly/lib/buck/source_db.rs → pyrefly-0.31.0/crates/pyrefly_build/src/buck/buck_check.rs

@@ -13,21 +13,18 @@ use std::path::PathBuf;
 use anyhow::Context as _;
 use pyrefly_python::module_name::ModuleName;
 use pyrefly_python::module_path::ModulePath;
+use pyrefly_util::absolutize::Absolutize as _;
 use pyrefly_util::fs_anyhow;
 use starlark_map::small_map::SmallMap;
 use tracing::debug;
 use vec1::Vec1;
 
-#[derive(Debug, PartialEq, Eq)]
+use crate::source_db::SourceDatabase;
+
+#[derive(Debug, PartialEq, Eq, Clone)]
 struct ManifestItem {
     module_name: ModuleName,
-    relative_path: PathBuf,
-}
-
-#[derive(Debug, PartialEq, Eq)]
-pub struct BuckSourceDatabase {
-    sources: SmallMap<ModuleName, Vec1<PathBuf>>,
-    dependencies: SmallMap<ModuleName, Vec1<PathBuf>>,
+    absolute_path: PathBuf,
 }
 
 fn read_manifest_file_data(data: &[u8]) -> anyhow::Result<Vec<ManifestItem>> {
@@ -36,10 +33,12 @@ fn read_manifest_file_data(data: &[u8]) -> anyhow::Result<Vec<ManifestItem>> {
     for raw_item in raw_items {
         match ModuleName::from_relative_path(Path::new(raw_item[0].as_str())) {
             Ok(module_name) => {
-                let relative_path = PathBuf::from(raw_item[1].clone());
+                // absolutize should be fine here to get absolute path, since Pyrefly
+                // will be run from Buck root.
+                let absolute_path = PathBuf::from(raw_item[1].clone()).absolutize();
                 results.push(ManifestItem {
                     module_name,
-                    relative_path,
+                    absolute_path,
                 });
             }
             Err(error) => {
@@ -87,7 +86,7 @@ fn create_manifest_item_index(
         accumulated
             .entry(item.module_name)
             .or_default()
-            .push(item.relative_path);
+            .push(item.absolute_path);
     }
     accumulated
         .into_iter()
@@ -98,7 +97,30 @@ fn create_manifest_item_index(
         .collect()
 }
 
-impl BuckSourceDatabase {
+pub struct BuckCheckSourceDatabase {
+    sources: SmallMap<ModuleName, Vec1<PathBuf>>,
+    dependencies: SmallMap<ModuleName, Vec1<PathBuf>>,
+}
+
+impl SourceDatabase for BuckCheckSourceDatabase {
+    fn modules_to_check(&self) -> Vec<(ModuleName, PathBuf)> {
+        self.sources
+            .iter()
+            .flat_map(|(name, paths)| paths.iter().map(|path| (*name, path.clone())))
+            .collect()
+    }
+
+    fn list(&self) -> SmallMap<ModuleName, pyrefly_python::module_path::ModulePath> {
+        // Iterate the sources second so if there are any conflicts the source wins.
+        self.dependencies
+            .iter()
+            .chain(self.sources.iter())
+            .map(|(name, paths)| (*name, ModulePath::filesystem(paths.first().clone())))
+            .collect()
+    }
+}
+
+impl BuckCheckSourceDatabase {
     pub fn from_manifest_files(
         source_manifests: &[PathBuf],
         dependency_manifests: &[PathBuf],
@@ -115,29 +137,13 @@ impl BuckSourceDatabase {
         dependency_items: Vec<ManifestItem>,
         typeshed_items: Vec<ManifestItem>,
     ) -> Self {
-        BuckSourceDatabase {
+        Self {
             sources: create_manifest_item_index(source_items.into_iter()),
             dependencies: create_manifest_item_index(
                 dependency_items.into_iter().chain(typeshed_items),
             ),
         }
     }
-
-    pub fn modules_to_check(&self) -> Vec<(ModuleName, PathBuf)> {
-        self.sources
-            .iter()
-            .flat_map(|(name, paths)| paths.iter().map(|path| (*name, path.clone())))
-            .collect()
-    }
-
-    pub fn list(&self) -> SmallMap<ModuleName, ModulePath> {
-        // Iterate the sources second so if there are any conflicts the source wins.
-        self.dependencies
-            .iter()
-            .chain(self.sources.iter())
-            .map(|(name, paths)| (*name, ModulePath::filesystem(paths.first().clone())))
-            .collect()
-    }
 }
 
 #[cfg(test)]
@@ -146,7 +152,7 @@ mod tests {
 
     use super::*;
 
-    /// Return type from `BuckSourceDatabase::lookup`
+    /// Return type from `BuckCheckSourceDatabase::lookup`
     #[derive(Debug, PartialEq, Eq)]
     enum LookupResult {
         /// Source file of this module is owned by the current target.
@@ -159,7 +165,7 @@ mod tests {
         NoSource,
     }
 
-    impl BuckSourceDatabase {
+    impl BuckCheckSourceDatabase {
         fn lookup(&self, module: ModuleName) -> LookupResult {
             match self.sources.get(&module) {
                 Some(paths) => LookupResult::OwningSource(paths.first().clone()),
@@ -178,7 +184,7 @@ mod tests {
                 .unwrap(),
             vec![ManifestItem {
                 module_name: ModuleName::from_str("foo.bar"),
-                relative_path: PathBuf::from_str("root/foo/bar.py").unwrap()
+                absolute_path: PathBuf::from_str("root/foo/bar.py").unwrap().absolutize()
             }]
         );
         assert_eq!(
@@ -195,18 +201,18 @@ mod tests {
         let foo_path = PathBuf::from_str("/root/foo.py").unwrap();
         let bar_path = PathBuf::from_str("/root/bar.py").unwrap();
         let baz_path = PathBuf::from_str("/root/baz.py").unwrap();
-        let source_db = BuckSourceDatabase::from_manifest_items(
+        let source_db = BuckCheckSourceDatabase::from_manifest_items(
             vec![ManifestItem {
                 module_name: ModuleName::from_str("foo"),
-                relative_path: foo_path.clone(),
+                absolute_path: foo_path.clone(),
             }],
             vec![ManifestItem {
                 module_name: ModuleName::from_str("bar"),
-                relative_path: bar_path.clone(),
+                absolute_path: bar_path.clone(),
             }],
             vec![ManifestItem {
                 module_name: ModuleName::from_str("baz"),
-                relative_path: baz_path.clone(),
+                absolute_path: baz_path.clone(),
             }],
         );
         assert_eq!(
@@ -235,25 +241,25 @@ mod tests {
         let src_bar_path = PathBuf::from_str("/src/bar.py").unwrap();
         let dep_bar_path = PathBuf::from_str("/dep/bar.pyi").unwrap();
 
-        let source_db = BuckSourceDatabase::from_manifest_items(
+        let source_db = BuckCheckSourceDatabase::from_manifest_items(
             vec![
                 ManifestItem {
                     module_name: ModuleName::from_str("foo"),
-                    relative_path: src_foo_path.clone(),
+                    absolute_path: src_foo_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("bar"),
-                    relative_path: src_bar_path.clone(),
+                    absolute_path: src_bar_path.clone(),
                 },
             ],
             vec![
                 ManifestItem {
                     module_name: ModuleName::from_str("foo"),
-                    relative_path: dep_foo_path.clone(),
+                    absolute_path: dep_foo_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("bar"),
-                    relative_path: dep_bar_path.clone(),
+                    absolute_path: dep_bar_path.clone(),
                 },
             ],
             vec![],
@@ -275,25 +281,25 @@ mod tests {
         let bar_py_path = PathBuf::from_str("/root/bar.py").unwrap();
         let bar_pyi_path = PathBuf::from_str("/root/bar.pyi").unwrap();
 
-        let source_db = BuckSourceDatabase::from_manifest_items(
+        let source_db = BuckCheckSourceDatabase::from_manifest_items(
             vec![
                 ManifestItem {
                     module_name: ModuleName::from_str("foo"),
-                    relative_path: foo_py_path.clone(),
+                    absolute_path: foo_py_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("foo"),
-                    relative_path: foo_pyi_path.clone(),
+                    absolute_path: foo_pyi_path.clone(),
                 },
             ],
             vec![
                 ManifestItem {
                     module_name: ModuleName::from_str("bar"),
-                    relative_path: bar_py_path.clone(),
+                    absolute_path: bar_py_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("bar"),
-                    relative_path: bar_pyi_path.clone(),
+                    absolute_path: bar_pyi_path.clone(),
                 },
             ],
             vec![],
@@ -320,42 +326,42 @@ mod tests {
         let typeshed_c_path = PathBuf::from_str("/typeshed/c.pyi").unwrap();
         let typeshed_d_path = PathBuf::from_str("/typeshed/d.pyi").unwrap();
 
-        let source_db = BuckSourceDatabase::from_manifest_items(
+        let source_db = BuckCheckSourceDatabase::from_manifest_items(
             vec![],
             vec![
                 ManifestItem {
                     module_name: ModuleName::from_str("a"),
-                    relative_path: dep_a_path.clone(),
+                    absolute_path: dep_a_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("b"),
-                    relative_path: dep_b_path.clone(),
+                    absolute_path: dep_b_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("c"),
-                    relative_path: dep_c_path.clone(),
+                    absolute_path: dep_c_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("d"),
-                    relative_path: dep_d_path.clone(),
+                    absolute_path: dep_d_path.clone(),
                 },
             ],
             vec![
                 ManifestItem {
                     module_name: ModuleName::from_str("a"),
-                    relative_path: typeshed_a_path.clone(),
+                    absolute_path: typeshed_a_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("b"),
-                    relative_path: typeshed_b_path.clone(),
+                    absolute_path: typeshed_b_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("c"),
-                    relative_path: typeshed_c_path.clone(),
+                    absolute_path: typeshed_c_path.clone(),
                 },
                 ManifestItem {
                     module_name: ModuleName::from_str("d"),
-                    relative_path: typeshed_d_path.clone(),
+                    absolute_path: typeshed_d_path.clone(),
                 },
             ],
         );

pyrefly-0.31.0/crates/pyrefly_build/src/buck/bxl.rs

@@ -0,0 +1,98 @@
+/*
+ * 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.
+ */
+
+use std::ops::Deref;
+use std::path::PathBuf;
+
+use dupe::Dupe as _;
+use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::sys_info::PythonPlatform;
+use pyrefly_python::sys_info::PythonVersion;
+use pyrefly_python::sys_info::SysInfo;
+use serde::Deserialize;
+use starlark_map::small_map::SmallMap;
+use starlark_map::small_set::SmallSet;
+use vec1::Vec1;
+
+use crate::source_db::Target;
+
+#[derive(Debug, PartialEq, Eq, Deserialize)]
+#[serde(untagged)]
+pub(crate) enum TargetManifest {
+    Library {
+        deps: SmallSet<Target>,
+        srcs: SmallMap<ModuleName, Vec1<PathBuf>>,
+        python_version: PythonVersion,
+        python_platform: PythonPlatform,
+    },
+    Alias {
+        alias: Target,
+    },
+}
+
+impl TargetManifest {
+    #[expect(unused)]
+    pub fn new_library(
+        srcs: SmallMap<ModuleName, Vec1<PathBuf>>,
+        deps: SmallSet<Target>,
+        sys_info: SysInfo,
+    ) -> Self {
+        Self::Library {
+            srcs,
+            deps,
+            python_version: sys_info.version().dupe(),
+            python_platform: sys_info.platform().clone(),
+        }
+    }
+
+    #[expect(unused)]
+    pub fn new_alias(alias: Target) -> Self {
+        Self::Alias { alias }
+    }
+
+    pub(crate) fn iter_srcs<'a>(
+        &'a self,
+    ) -> Box<dyn Iterator<Item = (&'a ModuleName, &'a Vec1<PathBuf>)> + 'a> {
+        match &self {
+            Self::Library { srcs, .. } => Box::new(srcs.iter()),
+            Self::Alias { .. } => Box::new(std::iter::empty::<(&ModuleName, &Vec1<PathBuf>)>()),
+        }
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Deserialize)]
+pub(crate) struct TargetManifestDatabase {
+    db: SmallMap<Target, TargetManifest>,
+    root: PathBuf,
+}
+
+impl Deref for TargetManifestDatabase {
+    type Target = SmallMap<Target, TargetManifest>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.db
+    }
+}
+
+impl TargetManifestDatabase {
+    #[expect(unused)]
+    pub fn new(db: SmallMap<Target, TargetManifest>, root: PathBuf) -> Self {
+        Self { db, root }
+    }
+
+    #[allow(unused)]
+    pub(crate) fn iter_srcs<'a>(
+        &'a self,
+    ) -> impl Iterator<Item = (&'a Target, &'a ModuleName, Vec1<PathBuf>)> + 'a {
+        let root = &self.root;
+        self.db.iter().flat_map(move |(target, manifest)| {
+            manifest
+                .iter_srcs()
+                .map(move |(module, paths)| (target, module, paths.mapped_ref(|p| root.join(p))))
+        })
+    }
+}

{pyrefly-0.30.0/pyrefly/lib → pyrefly-0.31.0/crates/pyrefly_build/src}/buck/mod.rs

@@ -5,4 +5,5 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-pub mod source_db;
+pub mod buck_check;
+pub mod bxl;

{pyrefly-0.30.0/pyrefly/lib/state → pyrefly-0.31.0/crates/pyrefly_build/src}/handle.rs

@@ -10,11 +10,14 @@ use pyrefly_python::module_name::ModuleName;
 use pyrefly_python::module_path::ModulePath;
 use pyrefly_python::sys_info::SysInfo;
 
+use crate::source_db::Target;
+
 #[derive(Debug, Clone, Dupe, PartialEq, Eq, Hash)]
 pub struct Handle {
     module: ModuleName,
     path: ModulePath,
     sys_info: SysInfo,
+    target: Option<Target>,
 }
 
 impl Handle {
@@ -23,6 +26,22 @@ impl Handle {
             module,
             path,
             sys_info,
+            target: None,
+        }
+    }
+
+    #[expect(unused)]
+    pub(crate) fn new_with_target(
+        module: ModuleName,
+        path: ModulePath,
+        sys_info: SysInfo,
+        target: Target,
+    ) -> Self {
+        Self {
+            module,
+            path,
+            sys_info,
+            target: Some(target),
         }
     }
 
@@ -37,4 +56,9 @@ impl Handle {
     pub fn sys_info(&self) -> &SysInfo {
         &self.sys_info
     }
+
+    #[expect(unused)]
+    pub(crate) fn target(&self) -> Option<&Target> {
+        self.target.as_ref()
+    }
 }

pyrefly-0.31.0/crates/pyrefly_build/src/lib.rs

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+
+#![warn(clippy::all)]
+#![allow(clippy::enum_variant_names)]
+#![allow(clippy::manual_flatten)]
+#![allow(clippy::match_like_matches_macro)]
+#![allow(clippy::module_inception)]
+#![allow(clippy::needless_lifetimes)]
+#![allow(clippy::new_without_default)]
+#![allow(clippy::should_implement_trait)]
+#![allow(clippy::single_match)]
+#![allow(clippy::too_many_arguments)]
+#![allow(clippy::type_complexity)]
+#![allow(clippy::wrong_self_convention)]
+#![deny(clippy::cloned_instead_of_copied)]
+#![deny(clippy::derive_partial_eq_without_eq)]
+#![deny(clippy::inefficient_to_string)]
+#![deny(clippy::str_to_string)]
+#![deny(clippy::string_to_string)]
+#![deny(clippy::trivially_copy_pass_by_ref)]
+#![feature(const_type_name)]
+#![feature(if_let_guard)]
+#![feature(let_chains)]
+
+pub mod buck;
+pub mod handle;
+pub mod source_db;

pyrefly-0.31.0/crates/pyrefly_build/src/source_db.rs

@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+use std::fmt;
+use std::path::PathBuf;
+
+use dupe::Dupe;
+use pyrefly_python::module_name::ModuleName;
+use pyrefly_python::module_path::ModulePath;
+use serde::Deserialize;
+use serde::Deserializer;
+use serde::Serialize;
+use serde::Serializer;
+use starlark_map::small_map::SmallMap;
+use static_interner::Intern;
+use static_interner::Interner;
+
+// We're interning `Target`s, since they'll be duplicated all over the place,
+// and it would be nice to have something that implements `Copy`.
+// We choose Interning over `Arc`, since we want to make sure all `Target`s
+// with the same data (especially when deserialied) point to the same value.
+static TARGET_INTERNER: Interner<String> = Interner::new();
+
+#[derive(Debug, Clone, Dupe, Copy, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub(crate) struct Target(Intern<String>);
+impl Serialize for Target {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+        serializer.serialize_str(&self.0)
+    }
+}
+
+impl<'de> Deserialize<'de> for Target {
+    fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
+        let s: &str = Deserialize::deserialize(deserializer)?;
+        Ok(Self::from_string(s.to_owned()))
+    }
+}
+
+impl fmt::Display for Target {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl Target {
+    #[allow(unused)]
+    pub fn from_string(x: String) -> Self {
+        Target(TARGET_INTERNER.intern(x))
+    }
+}
+
+/// Represents a virtual filesystem provided by a build system. A build system
+/// should understand the relationship between targets and importable qualified
+/// paths to the files contained in the build system.
+pub trait SourceDatabase {
+    fn modules_to_check(&self) -> Vec<(ModuleName, PathBuf)>;
+    fn list(&self) -> SmallMap<ModuleName, ModulePath>;
+}

{pyrefly-0.30.0 → pyrefly-0.31.0}/crates/pyrefly_bundled/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_bundled"
-version = "0.30.0"
+version = "0.31.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.30.0 → pyrefly-0.31.0}/crates/pyrefly_config/Cargo.toml

@@ -2,7 +2,7 @@
 
 [package]
 name = "pyrefly_config"
-version = "0.30.0"
+version = "0.31.0"
 authors = ["Meta"]
 edition = "2024"
 repository = "https://github.com/facebook/pyrefly"

{pyrefly-0.30.0 → pyrefly-0.31.0}/crates/pyrefly_config/src/base.rs

@@ -60,6 +60,10 @@ pub struct ConfigBase {
     )]
     pub untyped_def_behavior: Option<UntypedDefBehavior>,
 
+    /// Whether to disable type errors in language server. By default errors will be shown in IDEs.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub disable_type_errors_in_ide: Option<bool>,
+
     /// Whether to ignore type errors in generated code. By default this is disabled.
     /// Generated code is defined as code that contains the marker string `@` immediately followed by `generated`.
     #[serde(
@@ -111,6 +115,10 @@ impl ConfigBase {
         base.untyped_def_behavior
     }
 
+    pub fn get_disable_type_errors_in_ide(base: &Self) -> Option<bool> {
+        base.disable_type_errors_in_ide
+    }
+
     pub fn get_ignore_errors_in_generated_code(base: &Self) -> Option<bool> {
         base.ignore_errors_in_generated_code
     }