Struct stc_ts_type_checker::Checker

pub struct Checker<L>where
    L: LoadModule,{
    pub(crate) cm: Arc<SourceMap>,
    pub(crate) handler: Arc<Handler>,
    pub(crate) module_types: RwLock<FxHashMap<ModuleId, Arc<OnceCell<Type>>>>,
    pub(crate) declared_modules: DashMap<String, ModuleId, FxBuildHasher>,
    pub(crate) dts_modules: Arc<DashMap<ModuleId, RModule, FxBuildHasher>>,
    pub(crate) module_loader: L,
    pub(crate) started: Arc<DashSet<ModuleId, FxBuildHasher>>,
    pub(crate) errors: Mutex<Vec<Error>>,
    pub(crate) env: Env,
    pub(crate) debugger: Option<Debugger>,
}

Onc instance per swc::Compiler

Fields

cm: Arc<SourceMap>

handler: Arc<Handler>

module_types: RwLock<FxHashMap<ModuleId, Arc<OnceCell<Type>>>>

Cache

declared_modules: DashMap<String, ModuleId, FxBuildHasher>

dts_modules: Arc<DashMap<ModuleId, RModule, FxBuildHasher>>

Information required to generate .d.ts files.

module_loader: L

started: Arc<DashSet<ModuleId, FxBuildHasher>>

Modules which are being processed or analyzed.

errors: Mutex<Vec<Error>>

env: Env

debugger: Option<Debugger>

Implementations

impl<L> Checker<L>where
    L: LoadModule,

fn try_loading_typing_of_one_package(&self, dir: &Path)

fn load_typings_from_dir(&self, dir: &Path, types: Option<&[String]>)

pub fn load_typings(
    &self,
    base: &Path,
    _type_roots: Option<&[PathBuf]>,
    types: Option<&[String]>
)

Load typings from node_modules.

• https://www.typescriptlang.org/tsconfig#typeRoots
• https://www.typescriptlang.org/tsconfig#types

impl<L> Checker<L>where
    L: LoadModule,

pub fn new(
    cm: Arc<SourceMap>,
    handler: Arc<Handler>,
    env: Env,
    debugger: Option<Debugger>,
    module_loader: L
) -> Self

impl<L> Checker<L>where
    L: LoadModule,

pub fn get_types(&self, id: ModuleId) -> Option<Type>

Get type information of a module.

pub fn take_dts(&self, id: ModuleId) -> Option<Module>

Removes dts module from self and return it.

pub fn module_loader(&self) -> &L

pub fn check(&self, entry: Arc<FileName>) -> ModuleId

After calling this method, you can get errors using .take_errors()

pub fn take_errors(&mut self) -> Vec<Error>

pub(crate) fn analyze_module(
    &self,
    starter: Option<Arc<FileName>>,
    path: Arc<FileName>
) -> Type

Analyzes one module.

pub(crate) fn analyze_non_circular_module(
    &self,
    module_id: ModuleId,
    path: Arc<FileName>
) -> Type

Trait Implementations

impl<L> Load for Checker<L>where
    L: LoadModule,

fn module_id(
    &self,
    base: &Arc<FileName>,
    module_specifier: &str
) -> Option<ModuleId>

fn is_in_same_circular_group(
    &self,
    base: &Arc<FileName>,
    module_specifier: &str
) -> bool

Note: This method called within a thread

fn load_circular_dep(
    &self,
    base: &Arc<FileName>,
    dep: &str,
    _partial: &ModuleTypeData
) -> VResult<Type>

This method can be called multiple time for same module.

fn load_non_circular_dep(&self, base: &Arc<FileName>, dep: &str) -> VResult<Type>

Note: This method is called in parallel.

fn declare_module(&self, name: &JsWord, module: Type) -> ModuleId

module should be Type::Arc of Type::Module.